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

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

IP电话/视频会议

开发平台：

Visual C++

VolumeInXXX.cpp：源码内容
  1. //NetTalk
  2. /*------------------------------------------------------------------------------*
  3.  =============================
  4.    模块名称: AudioPlay.cpp
  5.  =============================
  6.  
  7.  [版权]
  8.  
  9.    Alex Chmut
  10.                                               
  11. *------------------------------------------------------------------------------*/
  13. #include <Windows.h>
  15. #include "VolumeInXXX.h"
  17. /////////////////////////////////////////////////////////////////////////////
  18. //  Defines
  19. #define BAD_DWORD (DWORD)-1
  20. #define WND_CLASS_NAME "Input Volume Msg Wnd Class"
  21. #define WND_NAME "Input Volume Msg Wnd"
  23. /////////////////////////////////////////////////////////////////////////////
  24. //  Globals
  25. PCVolumeInXXX 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. inline
  34. void SetDeviceType( WAVEFORMATEX* pwfe )
  35. {
  36. memset( pwfe, 0, sizeof(WAVEFORMATEX) );
  37. WORD  nBlockAlign = (AUDCHANNELS*AUDBITSMPL)/8;
  38. DWORD nSamplesPerSec = AUDFREQ;
  39. pwfe->wFormatTag = WAVE_FORMAT_PCM;
  40. pwfe->nChannels = AUDCHANNELS;
  41. pwfe->nBlockAlign = nBlockAlign;
  42. pwfe->nSamplesPerSec = nSamplesPerSec;
  43. pwfe->wBitsPerSample = AUDBITSMPL;
  44. pwfe->nAvgBytesPerSec = nSamplesPerSec*nBlockAlign;
  45. }
  46. //}}} Audio specific functions
  48. /////////////////////////////////////////////////////////////////////////////
  49. //  Implementation
  50. //////////////
  51. bool CALLBACK EnumInputLineProc( UINT uLineIndex, MIXERLINE* pLineInfo, DWORD dwUserValue )
  52. {
  53. if ( pLineInfo->dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE )
  54. {
  55. *((UINT*)dwUserValue) = uLineIndex;
  56. return false;
  57. }
  58. return true;
  59. }
  60. /*------------------------------------------------------------------------------*/
  61. CVolumeInXXX::CVolumeInXXX()
  62. : m_bOK(false),
  63. m_bInitialized(false),
  64. m_bAvailable(false),
  66. m_uMixerID(0L),
  67. m_dwMixerHandle(0L),
  68. m_hWnd(NULL),
  70. m_uMicrophoneSourceLineIndex(BAD_DWORD),
  72. m_dwMinimalVolume(BAD_DWORD),
  73. m_dwMaximalVolume(BAD_DWORD),
  75. m_pfUserSink(NULL),
  76. m_dwUserValue(0L)
  77. {
  78. if ( m_bOK = Init() )
  79. {
  80. g_pThis = this;
  81. UINT i=-1;
  82. EnumerateInputLines(EnumInputLineProc,(DWORD)&i);
  83. if(i!=(UINT)-1)
  84. {
  85. if ( !Initialize( i ) )
  86. {
  87. Done();
  88. g_pThis = NULL;
  89. }
  90. }
  91. }
  92. }
  93. /*------------------------------------------------------------------------------*/
  94. CVolumeInXXX::CVolumeInXXX( UINT uLineIndex )
  95. : m_bOK(false),
  96. m_bInitialized(false),
  97. m_bAvailable(false),
  99. m_uMixerID(0L),
  100. m_dwMixerHandle(0L),
  101. m_hWnd(NULL),
  103. m_uMicrophoneSourceLineIndex(BAD_DWORD),
  105. m_dwMinimalVolume(BAD_DWORD),
  106. m_dwMaximalVolume(BAD_DWORD),
  108. m_pfUserSink(NULL),
  109. m_dwUserValue(0L)
  110. {
  111. if ( m_bOK = Init() )
  112. {
  113. g_pThis = this;
  114. if ( !Initialize( uLineIndex ) )
  115. {
  116. Done();
  117. g_pThis = NULL;
  118. }
  119. }
  120. }
  121. /*------------------------------------------------------------------------------*/
  122. //////////////
  123. CVolumeInXXX::~CVolumeInXXX()
  124. {
  125. if ( m_bOK )
  126. Done();
  127. g_pThis = NULL;
  128. }
  129. /*------------------------------------------------------------------------------*/
  130. //////////////
  131. bool CVolumeInXXX::Init()
  132. {
  133. if ( !mixerGetNumDevs() )
  134. return false;
  135. // Getting Mixer ID
  136. HWAVEIN hwaveIn;
  137. MMRESULT mmResult;
  138. WAVEFORMATEX WaveFmt;
  139. SetDeviceType( &WaveFmt );
  140. mmResult = waveInOpen( &hwaveIn, WAVE_MAPPER, &WaveFmt, 0L, 0L, CALLBACK_NULL );
  141. if ( mmResult != MMSYSERR_NOERROR )
  142. {
  144. return false;
  145. } else {
  146. mmResult = mixerGetID( (HMIXEROBJ)hwaveIn, &m_uMixerID, MIXER_OBJECTF_HWAVEIN );
  147. waveInClose( hwaveIn );
  148. if ( mmResult != MMSYSERR_NOERROR )
  149. {
  151. return false;
  152. }
  153. }
  154. // Exposing Window to Mixer
  155. WNDCLASSEX wcx;
  156. memset( &wcx, 0, sizeof(WNDCLASSEX) );
  157. wcx.cbSize = sizeof(WNDCLASSEX);
  158. wcx.lpszClassName = WND_CLASS_NAME;
  159. wcx.lpfnWndProc = (WNDPROC)MixerWndProc;
  160. ::RegisterClassEx(&wcx);
  161. m_hWnd = CreateWindow( WND_CLASS_NAME,
  162. WND_NAME,
  163. WS_POPUP | WS_DISABLED,
  164. 0, 0, 0, 0,
  165. NULL, NULL, NULL, NULL );
  166. if ( !m_hWnd )
  167. {
  169. return false;
  170. }
  171. ::ShowWindow(m_hWnd, SW_HIDE);
  172. mmResult = mixerOpen( (LPHMIXER)&m_dwMixerHandle, m_uMixerID, (DWORD)m_hWnd, 0L, CALLBACK_WINDOW );
  173. if ( mmResult != MMSYSERR_NOERROR )
  174. {
  176. ::DestroyWindow( m_hWnd );
  177. return false;
  178. }
  179. return true;
  180. }
  181. /*------------------------------------------------------------------------------*/
  182. //////////////
  183. void CVolumeInXXX::Done()
  184. {
  185. if ( mixerClose( (HMIXER)m_dwMixerHandle ) != MMSYSERR_NOERROR )
  186. {
  188. }
  189. ::DestroyWindow( m_hWnd );
  190. m_bInitialized = false;
  191. m_bOK = false;
  192. }
  193. /*------------------------------------------------------------------------------*/
  194. //////////////
  195. void CVolumeInXXX::OnControlChanged( DWORD dwControlID )
  196. {
  197. if ( m_dwVolumeControlID == dwControlID )
  198. {
  199. DWORD dwVolume = GetCurrentVolume();
  200. if ( (dwVolume!=BAD_DWORD) && (m_pfUserSink) )
  201. {
  202. (*m_pfUserSink)( dwVolume, m_dwUserValue );
  203. }
  204. }
  205. }
  206. /*------------------------------------------------------------------------------*/
  207. //////////////
  208. bool CVolumeInXXX::Initialize( UINT uLineIndex )
  209. {
  210. MMRESULT mmResult;
  211. if ( !m_bOK )
  212. return false;
  214. MIXERLINE MixerLine;
  215. memset( &MixerLine, 0, sizeof(MIXERLINE) );
  216. MixerLine.cbStruct = sizeof(MIXERLINE);
  217. MixerLine.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
  218. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &MixerLine, MIXER_GETLINEINFOF_COMPONENTTYPE );
  219. if ( mmResult != MMSYSERR_NOERROR )
  220. {
  222. return false;
  223. }
  225. MIXERCONTROL Control;
  226. memset( &Control, 0, sizeof(MIXERCONTROL) );
  227. Control.cbStruct = sizeof(MIXERCONTROL);
  229. MIXERLINECONTROLS LineControls;
  230. memset( &LineControls, 0, sizeof(MIXERLINECONTROLS) );
  231. LineControls.cbStruct = sizeof(MIXERLINECONTROLS);
  233. MIXERLINE Line;
  234. memset( &Line, 0, sizeof(MIXERLINE) );
  235. Line.cbStruct = sizeof(MIXERLINE);
  237. if ( ( uLineIndex < MixerLine.cConnections ) )
  238. {
  239. Line.dwDestination = MixerLine.dwDestination;
  240. Line.dwSource = uLineIndex;
  241. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &Line, MIXER_GETLINEINFOF_SOURCE );
  242. if ( mmResult != MMSYSERR_NOERROR )
  243. {
  245. return false;
  246. }
  248. LineControls.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
  249. LineControls.dwLineID = Line.dwLineID;
  250. LineControls.cControls = 1;
  251. LineControls.cbmxctrl = sizeof(MIXERCONTROL);
  252. LineControls.pamxctrl = &Control;
  253. mmResult = mixerGetLineControls( (HMIXEROBJ)m_dwMixerHandle, &LineControls, MIXER_GETLINECONTROLSF_ONEBYTYPE );
  254. if ( mmResult == MMSYSERR_NOERROR )
  255. {
  256. if ( !(Control.fdwControl & MIXERCONTROL_CONTROLF_DISABLED) )
  257. {
  258. m_bAvailable = true;
  260. } else {
  261. }
  262. } else {
  263. }
  264. } else {
  265. return false;
  266. }
  268. // Retrieving Microphone Source Line
  269. for ( UINT uLine = 0; uLine < MixerLine.cConnections; uLine++ )
  270. {
  271. MIXERLINE MicrophoneLine;
  272. memset( &MicrophoneLine, 0, sizeof(MIXERLINE) );
  273. MicrophoneLine.cbStruct = sizeof(MIXERLINE);
  274. MicrophoneLine.dwDestination = MixerLine.dwDestination;
  275. MicrophoneLine.dwSource = uLine;
  276. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &MicrophoneLine, MIXER_GETLINEINFOF_SOURCE );
  277. if ( mmResult == MMSYSERR_NOERROR )
  278. {
  279. if ( MicrophoneLine.dwComponentType == MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE )
  280. {
  281. m_uMicrophoneSourceLineIndex = MicrophoneLine.dwSource;
  282. break;
  283. }
  284. }
  285. }
  286. if ( m_uMicrophoneSourceLineIndex == BAD_DWORD )
  287. {
  288. }
  290. m_uSourceLineIndex = uLineIndex;
  291. m_nChannelCount = Line.cChannels;
  292. m_dwLineID = LineControls.dwLineID;
  293. m_dwVolumeControlID = Control.dwControlID;
  294. m_dwMinimalVolume = Control.Bounds.dwMinimum;
  295. m_dwMaximalVolume = Control.Bounds.dwMaximum;
  296. m_dwVolumeStep = Control.Metrics.cSteps;
  298. m_bInitialized = true;
  299. return true;
  300. }
  301. /*------------------------------------------------------------------------------*/
  302. //////////////////////////////////////////////
  303. bool CVolumeInXXX::GetMicrophoneSourceLineIndex( UINT* puLineIndex )
  304. {
  305. if ( !puLineIndex || !m_bInitialized || (m_uMicrophoneSourceLineIndex==BAD_DWORD) )
  306. return false;
  307. *puLineIndex = m_uMicrophoneSourceLineIndex;
  308. return true;
  309. }
  310. /*------------------------------------------------------------------------------*/
  311. //////////////////////////////////////////////
  312. // IVolume interface
  313. //////////////
  315. bool CVolumeInXXX::IsAvailable()
  316. {
  317. return m_bAvailable;
  318. }
  319. /*------------------------------------------------------------------------------*/
  320. //////////////
  321. void CVolumeInXXX::Enable()
  322. {
  323. if ( !m_bInitialized )
  324. return;
  325. bool bAnyEnabled = false;
  326. MMRESULT mmResult;
  328. MIXERLINE lineDestination;
  329. memset( &lineDestination, 0, sizeof(MIXERLINE) );
  330. lineDestination.cbStruct = sizeof(MIXERLINE);
  331. lineDestination.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
  332. mmResult = mixerGetLineInfo( (HMIXEROBJ)m_dwMixerHandle, &lineDestination, MIXER_GETLINEINFOF_COMPONENTTYPE );
  333. if ( mmResult != MMSYSERR_NOERROR )
  334. {
  335. return;
  336. }
  337. // Getting all line's controls
  338. int nControlCount = lineDestination.cControls;
  339. int nChannelCount = lineDestination.cChannels;
  340. MIXERLINECONTROLS LineControls;
  341. memset( &LineControls, 0, sizeof(MIXERLINECONTROLS) );
  342. MIXERCONTROL* aControls = (MIXERCONTROL*)malloc( nControlCount * sizeof(MIXERCONTROL) );
  343. if ( !aControls )
  344. {
  345. return;
  346. }
  347. memset( &aControls[0], 0, sizeof(nControlCount * sizeof(MIXERCONTROL)) );
  348. for ( int i = 0; i < nControlCount; i++ )
  349. {
  350. aControls[i].cbStruct = sizeof(MIXERCONTROL);
  351. }
  352. LineControls.cbStruct = sizeof(MIXERLINECONTROLS);
  353. LineControls.dwLineID = lineDestination.dwLineID;
  354. LineControls.cControls = nControlCount;
  355. LineControls.cbmxctrl = sizeof(MIXERCONTROL);
  356. LineControls.pamxctrl = &aControls[0];
  357. mmResult = mixerGetLineControls( (HMIXEROBJ)m_dwMixerHandle, &LineControls, MIXER_GETLINECONTROLSF_ALL );
  358. if ( mmResult == MMSYSERR_NOERROR )
  359. {
  360. for ( i = 0; i < nControlCount; i++ )
  361. {
  362. if ( aControls[i].dwControlType & MIXERCONTROL_CT_UNITS_BOOLEAN )
  363. {
  364. MIXERCONTROLDETAILS_BOOLEAN* aDetails = NULL;
  365. int nMultipleItems = aControls[i].cMultipleItems;
  366. int nChannels = nChannelCount;
  367. // MIXERCONTROLDETAILS
  368. MIXERCONTROLDETAILS ControlDetails;
  369. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  370. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  371. ControlDetails.dwControlID = aControls[i].dwControlID;
  372. if ( aControls[i].fdwControl & MIXERCONTROL_CONTROLF_UNIFORM )
  373. {
  374. nChannels = 1;
  375. }
  376. if ( aControls[i].fdwControl & MIXERCONTROL_CONTROLF_MULTIPLE )
  377. {
  378. nMultipleItems = aControls[i].cMultipleItems;
  379. aDetails = (MIXERCONTROLDETAILS_BOOLEAN*)malloc(nMultipleItems*nChannels*sizeof(MIXERCONTROLDETAILS_BOOLEAN));
  380. if ( !aDetails )
  381. {
  382. continue;
  383. }
  384. for ( int nItem = 0; nItem < nMultipleItems; nItem++ )
  385. {
  386. LONG lValue = FALSE;
  387. if ( nItem == (int)m_uSourceLineIndex )
  388. lValue = TRUE;
  389. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  390. {
  391. aDetails[nItem+nChannel].fValue = lValue;
  392. }
  393. }
  394. } else {
  395. nMultipleItems = 0;
  396. aDetails = (MIXERCONTROLDETAILS_BOOLEAN*)malloc(nChannels*sizeof(MIXERCONTROLDETAILS_BOOLEAN));
  397. if ( !aDetails )
  398. {
  399. continue;
  400. }
  401. for ( int nChannel = 0; nChannel < nChannels; nChannel++ )
  402. {
  403. aDetails[nChannel].fValue = (LONG)TRUE;
  404. }
  405. }
  406. ControlDetails.cChannels = nChannels;
  407. ControlDetails.cMultipleItems = nMultipleItems;
  408. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
  409. ControlDetails.paDetails = &aDetails[0];
  410. mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, 0L );
  411. if ( mmResult == MMSYSERR_NOERROR )
  412. {
  413. bAnyEnabled = true;
  414. }
  415. free( aDetails );
  416. }
  417. }
  418. } else {
  419. }
  420. free( aControls );
  421. if ( !bAnyEnabled )
  422. {
  423. }
  424. }
  425. /*------------------------------------------------------------------------------*/
  426. //////////////
  427. void CVolumeInXXX::Disable()
  428. {
  429. }
  430. /*------------------------------------------------------------------------------*/
  431. //////////////
  432. DWORD CVolumeInXXX::GetVolumeMetric()
  433. {
  434. if ( !m_bAvailable )
  435. return BAD_DWORD;
  436. return m_dwVolumeStep;
  437. }
  438. /*------------------------------------------------------------------------------*/
  439. //////////////
  440. DWORD CVolumeInXXX::GetMinimalVolume()
  441. {
  442. if ( !m_bAvailable )
  443. return BAD_DWORD;
  444. return m_dwMinimalVolume;
  445. }
  446. /*------------------------------------------------------------------------------*/
  447. //////////////
  448. DWORD CVolumeInXXX::GetMaximalVolume()
  449. {
  450. if ( !m_bAvailable )
  451. return BAD_DWORD;
  452. return m_dwMaximalVolume;
  453. }
  454. /*------------------------------------------------------------------------------*/
  455. //////////////
  456. DWORD CVolumeInXXX::GetCurrentVolume()
  457. {
  458. if ( !m_bAvailable )
  459. return BAD_DWORD;
  460. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  461. if ( !aDetails )
  462. return BAD_DWORD;
  463. MIXERCONTROLDETAILS ControlDetails;
  464. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  465. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  466. ControlDetails.dwControlID = m_dwVolumeControlID;
  467. ControlDetails.cChannels = m_nChannelCount;
  468. ControlDetails.cMultipleItems = 0;
  469. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  470. ControlDetails.paDetails = &aDetails[0];
  471. MMRESULT mmResult = mixerGetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_GETCONTROLDETAILSF_VALUE );
  472. DWORD dw = aDetails[0].dwValue;
  473. free( aDetails );
  474. if ( mmResult != MMSYSERR_NOERROR )
  475. {
  476. return BAD_DWORD;
  477. }
  478. return dw;
  479. }
  480. /*------------------------------------------------------------------------------*/
  481. //////////////
  482. void CVolumeInXXX::SetCurrentVolume( DWORD dwValue )
  483. {
  484. if ( !m_bAvailable || (dwValue<m_dwMinimalVolume) || (dwValue>m_dwMaximalVolume) )
  485. return;
  486. MIXERCONTROLDETAILS_UNSIGNED* aDetails = (MIXERCONTROLDETAILS_UNSIGNED*)malloc(m_nChannelCount*sizeof(MIXERCONTROLDETAILS_UNSIGNED));
  487. if ( !aDetails )
  488. return;
  489. for ( int i = 0; i < m_nChannelCount; i++ )
  490. {
  491. aDetails[i].dwValue = dwValue;
  492. }
  493. MIXERCONTROLDETAILS ControlDetails;
  494. memset( &ControlDetails, 0, sizeof(MIXERCONTROLDETAILS) );
  495. ControlDetails.cbStruct = sizeof(MIXERCONTROLDETAILS);
  496. ControlDetails.dwControlID = m_dwVolumeControlID;
  497. ControlDetails.cChannels = m_nChannelCount;
  498. ControlDetails.cMultipleItems = 0;
  499. ControlDetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  500. ControlDetails.paDetails = &aDetails[0];
  501. MMRESULT mmResult = mixerSetControlDetails( (HMIXEROBJ)m_dwMixerHandle, &ControlDetails, MIXER_SETCONTROLDETAILSF_VALUE );
  502. free( aDetails );
  503. if ( mmResult != MMSYSERR_NOERROR )
  504. {
  505. }
  506. }
  507. /*------------------------------------------------------------------------------*/
  508. //////////////
  509. void CVolumeInXXX::RegisterNotificationSink( PONMICVOULUMECHANGE pfUserSink, DWORD dwUserValue )
  510. {
  511. m_pfUserSink = pfUserSink;
  512. m_dwUserValue = dwUserValue;
  513. }
  514. /*------------------------------------------------------------------------------*/
  515. ////////////////////////////////////////////////////////////////////////
  516. LRESULT CALLBACK CVolumeInXXX::MixerWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  517. {
  518. if ( uMsg == MM_MIXM_CONTROL_CHANGE )
  519. {
  520. if ( g_pThis )
  521. {
  522. g_pThis->OnControlChanged( (DWORD)lParam );
  523. }
  524. }
  525. return ::DefWindowProc( hwnd, uMsg, wParam, lParam);
  526. }
  527. /*------------------------------------------------------------------------------*/
  528. ////////////////////////////////////////////////////////////////////////
  529. bool CVolumeInXXX::EnumerateInputLines( PINPUTLINEPROC pUserCallback, DWORD dwUserValue )
  530. {
  531. if ( !pUserCallback )
  532. return false;
  533. MMRESULT mmResult;
  534. HWAVEIN hwaveIn;
  535. WAVEFORMATEX WaveFmt;
  536. SetDeviceType( &WaveFmt );
  537. mmResult = waveInOpen( &hwaveIn, WAVE_MAPPER, &WaveFmt, 0L, 0L, CALLBACK_NULL );
  538. if ( mmResult != MMSYSERR_NOERROR )
  539. {
  540. return false;
  541. }
  542. UINT uMixerID;
  543. DWORD dwMixerHandle;
  544. mmResult = mixerGetID( (HMIXEROBJ)hwaveIn, &uMixerID, MIXER_OBJECTF_HWAVEIN );
  545. waveInClose( hwaveIn );
  546. if ( mmResult != MMSYSERR_NOERROR )
  547. {
  548. return false;
  549. }
  550. mmResult = mixerOpen( (LPHMIXER)&dwMixerHandle, uMixerID, 0L, 0L, 0L );
  551. if ( mmResult != MMSYSERR_NOERROR )
  552. {
  553. mixerClose( (HMIXER)dwMixerHandle );
  554. return false;
  555. }
  556. MIXERLINE MixerLine;
  557. memset( &MixerLine, 0, sizeof(MIXERLINE) );
  558. MixerLine.cbStruct = sizeof(MIXERLINE);
  559. MixerLine.dwComponentType = MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
  560. mmResult = mixerGetLineInfo( (HMIXEROBJ)dwMixerHandle, &MixerLine, MIXER_GETLINEINFOF_COMPONENTTYPE );
  561. if ( mmResult != MMSYSERR_NOERROR )
  562. {
  563. mixerClose( (HMIXER)dwMixerHandle );
  564. return false;
  565. }
  566. MIXERLINE Line;
  567. for ( UINT uLineIndex = 0; uLineIndex < MixerLine.cConnections; uLineIndex++ )
  568. {
  569. memset( &Line, 0, sizeof(MIXERLINE) );
  570. Line.cbStruct = sizeof(MIXERLINE);
  571. Line.dwDestination = MixerLine.dwDestination;
  572. Line.dwSource = uLineIndex;
  573. mmResult = mixerGetLineInfo( (HMIXEROBJ)dwMixerHandle, &Line, MIXER_GETLINEINFOF_SOURCE );
  574. if ( mmResult != MMSYSERR_NOERROR )
  575. {
  576. mixerClose( (HMIXER)dwMixerHandle );
  577. return false;
  578. }
  579. if ( !((*pUserCallback)( uLineIndex, &Line, dwUserValue )) )
  580. {
  581. break;
  582. }
  583. }
  584. mixerClose( (HMIXER)dwMixerHandle );
  585. return true;
  586. }