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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
AVDlg.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：11k
源码类别：

VC书籍

开发平台：

Visual C++

AVDlg.cpp：源码内容
  3. #include "stdafx.h"
  4. #include "rtccore.h"
  5. #include "AVDConf.h"
  6. #include "AVDlg.h"
  7. #include "defines.h"
  9. #ifdef _DEBUG
  10. #define new DEBUG_NEW
  11. #undef THIS_FILE
  12. static char THIS_FILE[] = __FILE__;
  13. #endif
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CAVDlg dialog
  19. CAVDlg::CAVDlg(CWnd* pParent /*=NULL*/)
  20. : CDialog(CAVDlg::IDD, pParent)
  21. {
  22. m_pParentClient = NULL;
  23. //{{AFX_DATA_INIT(CAVDlg)
  24. //}}AFX_DATA_INIT
  25. }
  26.    
  28. void CAVDlg::DoDataExchange(CDataExchange* pDX)
  29. {
  30. CDialog::DoDataExchange(pDX);
  31. //{{AFX_DATA_MAP(CAVDlg)
  32. DDX_Control(pDX, IDC_SPEAKERMUTE, m_cSpeakerMute);
  33. DDX_Control(pDX, IDC_SPEAKER_BAR, m_cSpeakerLevel);
  34. DDX_Control(pDX, IDC_MIC_BAR, m_cMicLevel);
  35. DDX_Control(pDX, IDC_SPEAKER_SLIDER, m_cSpeakerSlider);
  36. DDX_Control(pDX, IDC_MICMUTE, m_cMicMute);
  37. DDX_Control(pDX, IDC_SPEAKER_TEXT, m_cSpeakerText);
  38. DDX_Control(pDX, IDC_MIC_TEXT, m_cMicText);
  39. DDX_Control(pDX, IDC_MIC_SLIDER, m_cMicSlider);
  40. //}}AFX_DATA_MAP
  41. }
  44. BEGIN_MESSAGE_MAP(CAVDlg, CDialog)
  45. //{{AFX_MSG_MAP(CAVDlg)
  46. ON_NOTIFY(NM_OUTOFMEMORY, IDC_SPEAKER_SLIDER, OnSpeakerSlider)
  47. ON_NOTIFY(NM_OUTOFMEMORY, IDC_MIC_SLIDER, OnMicSlider)
  48. ON_BN_CLICKED(IDC_SPEAKERMUTE, OnSpeakermute)
  49. ON_BN_CLICKED(IDC_MICMUTE, OnMicmute)
  50. //}}AFX_MSG_MAP
  51. END_MESSAGE_MAP()
  54. void CAVDlg::OnOK() 
  55. {
  56. if (m_pSession)
  57. {
  58. HRESULT hr = m_pSession->Terminate(RTCTR_NORMAL);
  59. }
  61. CDialog::OnOK();
  62. }
  65. void CAVDlg::OnCancel ()
  66. {
  67. return;
  68. }
  71. void CAVDlg::OnSpeakerSlider(NMHDR* pNMHDR, LRESULT* pResult) 
  72. {
  73. long lPos = m_cSpeakerSlider.GetPos ();
  74. DoVolume (RTCAD_SPEAKER, lPos);
  75. *pResult = 0;
  76. }
  79. void CAVDlg::OnMicSlider(NMHDR* pNMHDR, LRESULT* pResult) 
  80. {
  81. long lPos = m_cMicSlider.GetPos ();
  82. DoVolume (RTCAD_MICROPHONE, lPos);
  83. *pResult = 0;
  84. }
  87. void CAVDlg::OnMicmute() 
  88. {
  89. if (m_cMicMute.IsDlgButtonChecked (IDC_MICMUTE) != 0)
  90. m_cMicSlider.EnableWindow (FALSE);
  91. else
  92. m_cMicSlider.EnableWindow (TRUE);
  94. DoMute (RTCAD_MICROPHONE);
  95. }
  98. void CAVDlg::OnSpeakermute() 
  99. {
  100. if (IsDlgButtonChecked (IDC_SPEAKERMUTE) != 0)
  101. m_cSpeakerSlider.EnableWindow (FALSE);
  102. else
  103. m_cSpeakerSlider.EnableWindow (TRUE);
  105. DoMute (RTCAD_SPEAKER);
  106. }
  109. HRESULT CAVDlg::SetParentClient(IRTCClient *pClient)
  110. {
  111. m_pParentClient = pClient;
  112. ShowAudio();
  113. return S_OK;
  114. }
  117. HRESULT CAVDlg::DoMute(RTC_AUDIO_DEVICE enDevice)
  118. {
  119.     IRTCClient * pClient = NULL;
  120.     BOOL fMute = FALSE;   
  121.     HWND hWnd = NULL;
  122.     HRESULT hr;
  124. if (m_pParentClient == NULL)
  125. return -1;
  127. fMute = IsDlgButtonChecked ( (enDevice == RTCAD_SPEAKER) ? IDC_SPEAKERMUTE : IDC_MICMUTE);
  129.     hr = m_pParentClient->put_AudioMuted(enDevice, fMute ? VARIANT_TRUE : VARIANT_FALSE);
  131.     if (FAILED(hr))
  132.     {
  133.         return hr;
  134.     }
  135.     return S_OK;
  136. }
  139. HRESULT CAVDlg::DoVolume(RTC_AUDIO_DEVICE enDevice, long lVolume)
  140. {
  141.     HRESULT hr;
  143. if (m_pParentClient == NULL)
  144. return -1;
  146.     hr = m_pParentClient->put_Volume(enDevice, lVolume);
  148.     if (FAILED(hr))
  149.     {
  150.         return hr;
  151.     }
  153. return S_OK;
  154. }
  157. HRESULT CAVDlg::ShowAudio()
  158. {
  159.     VARIANT_BOOL fMute = FALSE;
  160.     long lVolume = 0;
  161.     long lMediaCaps = 0;
  162.     HRESULT hr;
  164.     if (m_pParentClient == NULL)
  165. return -1;
  167.     hr = m_pParentClient->get_MediaCapabilities(&lMediaCaps);
  169.     if (FAILED(hr))
  170.     {
  171.         return hr;
  172.     }
  174.     if (lMediaCaps & RTCMT_AUDIO_RECEIVE)
  175.     {
  176.         hr = m_pParentClient->get_AudioMuted(RTCAD_SPEAKER, &fMute);
  178.         if (FAILED(hr))
  179.         {
  180.             return hr;
  181.         }
  183.         m_cSpeakerMute.SetCheck ( fMute ? BST_CHECKED : BST_UNCHECKED);
  185.         hr = m_pParentClient->get_Volume(RTCAD_SPEAKER, &lVolume);
  187.         if (FAILED(hr))
  188.         {
  189.             return hr;
  190.         }
  192. m_cSpeakerSlider.SetPos (lVolume);
  193.     }
  195.     if (lMediaCaps & RTCMT_AUDIO_SEND)
  196.     {
  197.   
  198.         hr = m_pParentClient->get_AudioMuted(RTCAD_MICROPHONE, &fMute);
  200.         if (FAILED(hr))
  201.         {
  202.             return hr;
  203.         }
  205.         m_cMicMute.SetCheck ( fMute ? BST_CHECKED : BST_UNCHECKED );
  206.    
  207.         hr = m_pParentClient->get_Volume(RTCAD_MICROPHONE, &lVolume);
  209.         if (FAILED(hr))
  210.         {
  211.             return hr;
  212.         }
  214. m_cSpeakerSlider.SetPos (lVolume);
  215.     }
  216.     return S_OK;
  217. }
  220. HRESULT CAVDlg::ShowVideo(RTC_VIDEO_DEVICE enDevice, BOOL fShow)
  221. {
  222.     IVideoWindow * pVid = NULL;
  223.     long lMediaCaps = 0;
  224.     HWND hWnd = NULL;
  225.     HRESULT hr;
  227.     if (m_pParentClient == NULL)
  228. {
  229. return -1;
  230. }
  232.     hr = m_pParentClient->get_MediaCapabilities(&lMediaCaps);
  234.     if (FAILED(hr))
  235.     {
  236.         return hr;
  237.     }
  239. hr = m_pParentClient->get_IVideoWindow(enDevice, &pVid);
  241.     if (FAILED(hr))
  242.     {
  243.         return hr;
  244.     }
  246. if (enDevice == RTCVD_PREVIEW)
  247.     {          
  248.         fShow = fShow && (lMediaCaps & RTCMT_VIDEO_SEND);
  249.         m_fShowPrev = fShow;
  250.         hWnd = m_hPrevVideoParent;
  252.         ::ShowWindow(m_hPrevVideoParent, fShow ? SW_SHOW : SW_HIDE);
  254.         HRGN hRegion;
  256.         if (fShow)
  257.         {
  258.             POINT rgPoints[6] =
  259.                     { 0, 0,
  260.                       0, m_lRecvHeight,
  261.                       m_lRecvWidth - m_lPrevWidth, m_lRecvHeight,
  262.                       m_lRecvWidth - m_lPrevWidth, m_lRecvHeight - m_lPrevHeight,
  263.                       m_lRecvWidth, m_lRecvHeight - m_lPrevHeight,
  264.                       m_lRecvWidth, 0
  265.                     };
  267.             hRegion = CreatePolygonRgn(rgPoints, 6, ALTERNATE);
  268.         }
  269.         else
  270.         {
  271.             hRegion = CreateRectRgn(0, 0, m_lRecvWidth, m_lRecvHeight);
  272.         }
  274.         ::SetWindowRgn(m_hRecvVideoParent, hRegion, TRUE);
  275.     }
  276.     else
  277.     {
  278.         fShow = fShow && (lMediaCaps & RTCMT_VIDEO_RECEIVE);
  279.         m_fShowRecv = fShow;
  280.         hWnd = m_hRecvVideoParent;
  282.         ::ShowWindow(m_hRecvVideoParent, SW_SHOW);
  283.     }
  285.     if ( fShow == TRUE )
  286.     {
  287.         pVid->put_WindowStyle( WS_CHILD |
  288.                                WS_CLIPCHILDREN |
  289.                                WS_CLIPSIBLINGS );
  290.         
  291.         pVid->put_Owner( (OAHWND)hWnd );
  293.         RECT rc;
  294.         ::GetClientRect(hWnd, &rc );  
  295.         
  296.         pVid->SetWindowPosition(
  297.             rc.left,
  298.             rc.top,
  299.             rc.right,
  300.             rc.bottom
  301.             );
  303.         pVid->put_Visible(-1);        
  304.     }       
  306.     SAFE_RELEASE(pVid);    
  308.     return S_OK;
  309. }
  311. HRESULT CAVDlg::DeliverMedia(long lMediaType, RTC_MEDIA_EVENT_TYPE enType, 
  312.  RTC_MEDIA_EVENT_REASON enReason)
  313. {
  314.     RTC_VIDEO_DEVICE enVideo;
  315.     BOOL fShow;
  316.     HRESULT hr = S_OK;
  318.     
  319.     switch (lMediaType)
  320.     {
  321.     case RTCMT_VIDEO_SEND:
  322.         enVideo = RTCVD_PREVIEW;
  323.         break;
  325.     case RTCMT_VIDEO_RECEIVE:
  326.         enVideo = RTCVD_RECEIVE;
  327.         break;
  329.     case RTCMT_T120_SENDRECV:
  330. break;
  332. default:
  333.         return S_OK;
  334.     }
  336.     switch (enType) 
  337.     {
  338.     case RTCMET_STARTED:
  339.         fShow = TRUE;
  340.         break;
  342.     case RTCMET_STOPPED:
  343. ::ShowWindow(m_hRecvVideoParent, SW_HIDE);
  344. ::SetParent(m_hRecvVideoParent, NULL);
  346. ::ShowWindow(m_hPrevVideoParent, SW_HIDE);
  347. ::SetParent(m_hPrevVideoParent, NULL);
  349. SetState (RTCSS_IDLE);
  351. SAFE_RELEASE(m_pSession);
  353. DestroyWindow();
  354. return S_OK;
  356.     case RTCMET_FAILED:
  357.         fShow = FALSE;
  358.         break;
  360.     default:
  361.         return S_OK;
  362.     }
  364.     hr = ShowVideo(enVideo, fShow);
  366.     return hr;
  368. }
  371. HRESULT CAVDlg::DeliverIntensity(RTC_AUDIO_DEVICE enDevice, long lLevel)
  372. {
  373.     switch(enDevice)
  374.     {
  375.     case RTCAD_SPEAKER:
  376. m_cSpeakerLevel.SetPos (lLevel);
  377.         break;
  379.     case RTCAD_MICROPHONE:
  380. m_cMicLevel.SetPos (lLevel);
  381.         break;
  382.     }
  384.     return S_OK;
  385. }
  388. HRESULT CAVDlg::DeliverClient(RTC_CLIENT_EVENT_TYPE enEventType)
  389. {
  390.     switch(enEventType)
  391.     {
  392.     case RTCCET_VOLUME_CHANGE:
  393.         
  394.         ShowAudio();
  395.         break;
  397.     case RTCCET_DEVICE_CHANGE:
  398.       
  399.         ShowAudio();
  400.         ShowVideo(RTCVD_PREVIEW, m_fShowPrev);
  401.         ShowVideo(RTCVD_RECEIVE, m_fShowRecv);
  402.         break;
  403.     }
  405.     return S_OK;
  406. }
  409. BOOL CAVDlg::OnInitDialog() 
  410. {
  411. CDialog::OnInitDialog();
  413. int OFFSETX = 10;
  414. int OFFSETY = 50;
  416.     RECT rcWnd;
  417.     const int SIZE_EDGE = 5;
  418.     const int TEXT_HEIGHT = 16;
  419.     const int LEVEL_HEIGHT = 10;
  420.     const int VOL_HEIGHT = 20;   
  422.     ::GetClientRect(m_hWnd, &rcWnd);    
  424. m_pParentClient = NULL;
  425.     
  426.     float fAspectRatio = (float)QCIF_CY_SIZE/(float)QCIF_CX_SIZE;
  427.     m_lRecvWidth = rcWnd.right - rcWnd.left - 2*SIZE_EDGE;
  428.     m_lRecvHeight = (long)(fAspectRatio * (float)m_lRecvWidth);
  430.     m_lPrevWidth = QQCIF_CX_SIZE;
  431.     m_lPrevHeight = QQCIF_CY_SIZE;
  433.     RECT rcRecvVid;
  435.     rcRecvVid.left = rcWnd.left + SIZE_EDGE; 
  436.     rcRecvVid.right = rcWnd.left + m_lRecvWidth + SIZE_EDGE;
  437.     rcRecvVid.top = rcWnd.top + SIZE_EDGE;
  438.     rcRecvVid.bottom = rcWnd.top + m_lRecvHeight + SIZE_EDGE;
  439.     
  440.     RECT rcPrevVid;
  442.     rcPrevVid.left = rcRecvVid.right - m_lPrevWidth; 
  443.     rcPrevVid.right = rcRecvVid.right;
  444.     rcPrevVid.top = rcRecvVid.bottom - m_lPrevHeight;
  445.     rcPrevVid.bottom = rcRecvVid.bottom;         
  447. m_hRecvVideoParent = NULL;
  448. m_hPrevVideoParent = NULL;
  450. m_cSpeakerSlider.SetRangeMax (0xffff);
  451. m_cMicSlider.SetRangeMax (0xffff);
  453.     if (m_hRecvVideoParent == NULL)
  454.     {
  455.         m_hRecvVideoParent = CreateWindowExW(
  456.             WS_EX_CLIENTEDGE,
  457.             L"STATIC",
  458.             NULL,
  459.             WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
  460. rcRecvVid.left, rcRecvVid.top,
  461. m_lRecvWidth, m_lRecvHeight,
  462.             m_hWnd,
  463.             NULL,
  464.             GetModuleHandle(NULL),
  465.             NULL);
  466.     
  467.         if ( !m_hRecvVideoParent )
  468.         {
  469.             return -1;
  470.         }
  471.     }
  472.     else
  473.     {
  474.         if (!::SetParent(m_hRecvVideoParent, m_hWnd))
  475.         {
  476.             // SetParent failed
  477.             return -1;
  478.         }
  479.     }
  481. if (m_hPrevVideoParent == NULL)
  482.     {
  483.         m_hPrevVideoParent = CreateWindowExW(
  484.             WS_EX_CLIENTEDGE,
  485.             L"STATIC",
  486.             NULL,
  487.             WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
  488. rcPrevVid.left, rcPrevVid.top,
  489. m_lPrevWidth, m_lPrevHeight,
  490.             m_hWnd,
  491.             NULL,
  492.             GetModuleHandle(NULL),
  493.             NULL);
  494.     
  495.         if ( !m_hPrevVideoParent )
  496.         {
  497.             return -1;
  498.         }
  499.     }
  500.     else
  501.     {
  502.         if (!::SetParent(m_hPrevVideoParent, m_hWnd))
  503.         {
  504.             return -1;
  505.         }
  506.     }
  508. return TRUE;  
  509. }
  512. void CAVDlg::SetSession(IRTCSession *pSession)
  513. {
  514. m_pSession = pSession;
  515. }
  518. void CAVDlg::SetState(RTC_SESSION_STATE enState)
  519. {
  520. m_rtcState = enState;
  521. }
  524. RTC_SESSION_STATE CAVDlg::GetState()
  525. {
  526. return m_rtcState;
  527. }