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

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

VC书籍

开发平台：

Visual C++

MAV8Dlg.cpp：源码内容
  1. // MAV8Dlg.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "MAV8.h"
  6. #include <windows.h>
  7. #include <mmsystem.h>
  9. #include ".av8incav8api.h"
  10. #include ".av8incdefine.h"
  12. #include "Overlay.h"
  13. #include "PlayWnd.h"
  14. #include "MAV8Dlg.h"
  16. #include "PlayWnd.h"
  18. #ifdef _DEBUG
  19. #define new DEBUG_NEW
  20. #undef THIS_FILE
  21. static char THIS_FILE[] = __FILE__;
  22. #endif
  24. #define WM_DATABLOCK_UPDATE WM_USER+20
  26. static char caFileName[STRSIZE];// = "catest1.mpg";
  28. typedef WORD (CALLBACK *USER_CALLBACK) (HDRVR hdrvr, UINT msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
  30. WORD CALLBACK _loadds MyCallBack(HDRVR hdrvr, UINT msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
  32. static HMMIO hmmioInput;
  33. static HMMIO hmmioOutput;
  34. HDRVR hVFDrv;
  35. BYTE bStream;
  37. HWND hWnd;
  38. BOOL Ready = false;
  39. extern PBYTE  pbMem[];
  40. extern BOOL Rendered;
  41. PBYTE RWPtr;
  42. PBYTE tmpMem;
  43. DWORD m_ReceivedBytes = 0; // maximize = 0x8000
  44. DWORD m_RemainBytes = 0; // maximize = 0x8000
  45. int rwIndex = 0;
  46. PBYTE Ptr[100];
  47. BOOL CaptureToFile;
  49. extern BOOL PeekAndPump();
  51. void Setdata (LPSTR lpBuffer, LONG dwBufferWrite)
  52. {
  53. DWORD Bytes = (DWORD)(dwBufferWrite);
  54. if ((m_ReceivedBytes + Bytes )> 0x8000) {
  55. CopyMemory((PVOID)(Ptr[rwIndex]+(LONGLONG)m_ReceivedBytes), 
  56. (PVOID)(lpBuffer),
  57. (DWORD)(Bytes = 0x8000 - m_ReceivedBytes));
  58. m_RemainBytes = dwBufferWrite - Bytes;
  59. RWPtr = Ptr[rwIndex];
  60. rwIndex = (rwIndex + 1)%100;
  62. Ready = true;
  64. tmpMem = new BYTE[m_RemainBytes];
  65. CopyMemory((PVOID)(tmpMem), 
  66. (PVOID)(lpBuffer + Bytes),
  67. (DWORD)(m_RemainBytes));
  69. m_ReceivedBytes = 0;
  70. TRACE2 ("A Block Ready = %lX, %lXn",(DWORD)(lpBuffer), Bytes);
  71. } else {
  72. if (m_RemainBytes != 0) {
  73. CopyMemory((PVOID)(Ptr[rwIndex]+(LONGLONG)m_ReceivedBytes), 
  74. (PVOID)(tmpMem),
  75. (DWORD)(m_RemainBytes));
  76. m_ReceivedBytes += m_RemainBytes;
  77. delete tmpMem;
  78. m_RemainBytes = 0;
  79. }
  80. CopyMemory((PVOID)(Ptr[rwIndex]+(LONGLONG)m_ReceivedBytes), 
  81. (PVOID)(lpBuffer),
  82. Bytes);
  84. m_ReceivedBytes += Bytes;
  85. }
  86. }
  89. WORD CALLBACK _loadds MyCallBack(HDRVR hdrvr, UINT msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
  90. {
  91. DWORD dwFlags = 0;
  93. // TRACE0("MyCallBack ");
  94. switch (msg)
  95. {
  96. case VF_MSGUSER_BUF_WRITE:
  97.     {
  98.         LONG lRet;
  99.         LPVF_BUFWRITE_STRUCT lpBufWrite = (LPVF_BUFWRITE_STRUCT)dwParam1;
  101. Setdata ((LPSTR)lpBufWrite->lpBuffer, (LONG)lpBufWrite->dwBufferWrite);
  102. TRACE0 ("Sentn");
  104. if (CaptureToFile) {
  105. lRet = mmioWrite(hmmioOutput, (LPSTR)lpBufWrite->lpBuffer, (LONG)lpBufWrite->dwBufferWrite);         
  106. if (lRet == -1L)
  107. {
  108.     return (FALSE);
  109. }
  110. }
  111.         break;
  112.     }
  114. case VF_MSGUSER_BUF_CREATE:
  115.     {
  116.         LPVF_CALLBACK_STRUCT lpCallback = (LPVF_CALLBACK_STRUCT)dwParam1;
  117. if (CaptureToFile) {
  118.         if (lpCallback->wSubMsg == VF_SUBMSG_OUTPUT)
  119.     {
  120.                 dwFlags = MMIO_CREATE | MMIO_WRITE;
  121.                 hmmioOutput = mmioOpen((LPTSTR)caFileName, (LPMMIOINFO)NULL, dwFlags);
  122.     }
  123.         else
  124.             {
  125.                 dwFlags = MMIO_READ | MMIO_DENYWRITE;
  126.                 hmmioInput = mmioOpen((LPTSTR)caFileName, (LPMMIOINFO)NULL, dwFlags);
  127.             }
  128. }
  129. TRACE0 ("Createn");
  130.         break;
  131.     }
  133. case VF_MSGUSER_BUF_CLOSE:
  134.     {
  135.         LPVF_CALLBACK_STRUCT lpCallback = (LPVF_CALLBACK_STRUCT)dwParam1;
  136. if (CaptureToFile) {
  137.         if (lpCallback->wSubMsg == VF_SUBMSG_OUTPUT)
  138.     {
  139.         if (hmmioOutput)
  140.     {
  141.         mmioClose(hmmioOutput, NULL);
  142.         hmmioOutput = NULL;
  143.     }
  144.     }
  145.         else
  146.     {
  147.         if (hmmioInput)
  148.         {
  149.             mmioClose(hmmioInput, NULL);
  150.             hmmioInput = NULL;
  151.         }
  152.     }
  153. }
  154. TRACE0 ("Closedn");
  155.         break;
  156.     }
  157.     } // switch
  159. return 1;
  160. }
  162. /////////////////////////////////////////////////////////////////////////////
  163. // CAboutDlg dialog used for App About
  165. class CAboutDlg : public CDialog
  166. {
  167. public:
  168. CAboutDlg();
  170. // Dialog Data
  171. //{{AFX_DATA(CAboutDlg)
  172. enum { IDD = IDD_ABOUTBOX };
  173. //}}AFX_DATA
  175. // ClassWizard generated virtual function overrides
  176. //{{AFX_VIRTUAL(CAboutDlg)
  177. protected:
  178. virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
  179. //}}AFX_VIRTUAL
  181. // Implementation
  182. protected:
  183. //{{AFX_MSG(CAboutDlg)
  184. //}}AFX_MSG
  185. DECLARE_MESSAGE_MAP()
  186. };
  188. CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
  189. {
  190. //{{AFX_DATA_INIT(CAboutDlg)
  191. //}}AFX_DATA_INIT
  192. }
  194. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
  195. {
  196. CDialog::DoDataExchange(pDX);
  197. //{{AFX_DATA_MAP(CAboutDlg)
  198. //}}AFX_DATA_MAP
  199. }
  201. BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
  202. //{{AFX_MSG_MAP(CAboutDlg)
  203. // No message handlers
  204. //}}AFX_MSG_MAP
  205. END_MESSAGE_MAP()
  208. void CMAV8Dlg::CountDevice ()
  209. {
  210. CString Msg;
  213. hVFDrv = OpenDriver (L"AV8api.dll", NULL, NULL);
  214. if (hVFDrv) {
  215. if (HVFAssign (hVFDrv, 0)) {
  216. if (HVFLock (hVFDrv, VF_CAP_ALL)) {
  217. pbDeviceLocked = TRUE;
  218. }
  219. else {
  220. pbDeviceLocked= FALSE;
  221. }
  222. }
  223. else {
  224. pbDeviceLocked = FALSE;
  225. CloseDriver (hVFDrv,NULL,NULL);
  226. hVFDrv = 0;
  227. }
  229. } 
  231. GetDlgItem (IDC_CHECK1)->EnableWindow(pbDeviceLocked);
  232. GetDlgItem (IDC_RECORD)->EnableWindow(false);
  233. }
  235. void CMAV8Dlg::CloseAllDevice ()
  236. {
  237. if (hVFDrv) {
  238. HVFUnlock (hVFDrv, VF_CAP_ALL);
  239. CloseDriver (hVFDrv, NULL, NULL);
  240. hVFDrv = NULL;
  241. }
  243. }
  246. BOOL CMAV8Dlg::InitEncodeVideoVxD(HDRVR m_hVFDrv, BYTE m_bStream)
  248. {
  249.     DWORD dwValue;
  250.     WORD  wWidth, wHeight;
  252.     wWidth=352;
  253.     wHeight=288;
  254.     dwValue=MAKELONG(wWidth, wHeight);
  256.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_OUTPUTSIZE, dwValue);
  258.     /* SDL - also set video width and height to scale images */
  259.     wWidth = (wWidth * 45) / 44; // try to maintain standard MPEG SIF aspect ratio
  260.     dwValue = MAKELONG(wWidth, wHeight /* [sic] */);
  261.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_INPUTSIZE, dwValue);
  263.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_BITRATE, 512000); //BITRATE_DEFAULT);
  265.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_RATE, VF_FLAG_VID_25);
  267.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_IINTERVAL, IINTERVAL_DEFAULT);
  269.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_BINTERVAL, PINTERVAL_DEFAULT);
  271.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_MODE, VF_FLAG_VID_PAL);
  273.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_SOURCE, VF_FLAG_VID_COMPOSITE);
  275.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_ALGORITHM, VF_FLAG_VID_MPEG);
  277.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_BRIGHTNESS, BRIGHTNESS_DEFAULT);
  279.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_CONTRAST, CONTRAST_DEFAULT);    
  281.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_HUE, HUE_DEFAULT);
  283.     HVFSet(m_hVFDrv, m_bStream, VF_INDEX_VID_SATURATION, SATURATION_DEFAULT);
  285.     return TRUE;
  286. }
  290. BOOL CMAV8Dlg::InitEncodeAudioVxD(HDRVR m_hVFDrv, BYTE m_bStream)
  292. {
  293.   DWORD dwValue;
  295. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_AUD_SAMPLE, SAMPLE_RATE_DEFAULT);
  296. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_AUD_BITRATE, BIT_RATE_DEFAULT);
  298. dwValue=VF_FLAG_AUD_MPEG; // set to MPEG algorithm
  299. dwValue=(dwValue<<16)+VF_FLAG_AUD_NONE;
  300. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_AUD_ALGORITHM, dwValue);
  301. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_AUD_MODE, MODE_DEFAULT);
  302. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_AUD_VOLUME, VOLUME_MIN);
  303. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_AUD_VOLUME, VOLUME_DEFAULT);
  304. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_AUD_GAIN, GAIN_DEFAULT);
  306. return TRUE;
  307. }
  311. BOOL CMAV8Dlg::InitEncodeSystemVxD(HDRVR m_hVFDrv, BYTE m_bStream)
  312. {
  313. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_STM_TYPE, VF_FLAG_MPGSYS);
  314. HVFSet(m_hVFDrv, m_bStream, VF_INDEX_STM_ENCODEMODE, VF_FLAG_STM_NORMAL);
  315. return TRUE;
  316. }
  318. /////////////////////////////////////////////////////////////////////////////
  319. // CMAV8Dlg dialog
  321. CMAV8Dlg::CMAV8Dlg(CWnd* pParent /*=NULL*/)
  322. : CDialog(CMAV8Dlg::IDD, pParent)
  323. {
  324. //{{AFX_DATA_INIT(CMAV8Dlg)
  325. m_InputWnd = TRUE;
  326. m_ToFile = FALSE;
  327. //}}AFX_DATA_INIT
  328. // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
  329. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  331. pOverlayWnd=NULL;
  332. IsCapture = FALSE;
  333. hVFDrv = 0;
  335. pPlayWnd = NULL;
  336. }
  338. CMAV8Dlg::~CMAV8Dlg()
  339. {
  340. if(pOverlayWnd)
  341. delete pOverlayWnd;
  342. pOverlayWnd = NULL;
  343. IsCapture = FALSE;
  344. hVFDrv = 0;
  345. }
  347. void CMAV8Dlg::DoDataExchange(CDataExchange* pDX)
  348. {
  349. CDialog::DoDataExchange(pDX);
  350. //{{AFX_DATA_MAP(CMAV8Dlg)
  351. DDX_Control(pDX, IDC_CHECK1, m_Check1);
  352. DDX_Check(pDX, IDC_INWINDOW, m_InputWnd);
  353. DDX_Check(pDX, IDC_TOFILE, m_ToFile);
  354. //}}AFX_DATA_MAP
  355. }
  357. BEGIN_MESSAGE_MAP(CMAV8Dlg, CDialog)
  358. //{{AFX_MSG_MAP(CMAV8Dlg)
  359. ON_WM_SYSCOMMAND()
  360. ON_WM_PAINT()
  361. ON_WM_QUERYDRAGICON()
  362. ON_WM_DESTROY()
  363. ON_BN_CLICKED(IDC_CHECK1, OnCheck1)
  364. ON_BN_CLICKED(IDC_RECORD, OnRecstop1)
  365. ON_BN_CLICKED(IDC_TOFILE, OnTofile)
  366. ON_BN_CLICKED(IDC_STOP, OnRecstop1)
  367. ON_BN_CLICKED(IDC_INWINDOW, OnInwindow)
  368. //}}AFX_MSG_MAP
  369. END_MESSAGE_MAP()
  371. /////////////////////////////////////////////////////////////////////////////
  372. // CMAV8Dlg message handlers
  374. BOOL CMAV8Dlg::OnInitDialog()
  375. {
  376. CDialog::OnInitDialog();
  378. // Add "About..." menu item to system menu.
  380. // IDM_ABOUTBOX must be in the system command range.
  381. ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
  382. ASSERT(IDM_ABOUTBOX < 0xF000);
  384. CMenu* pSysMenu = GetSystemMenu(FALSE);
  385. if (pSysMenu != NULL)
  386. {
  387. CString strAboutMenu;
  388. strAboutMenu.LoadString(IDS_ABOUTBOX);
  389. if (!strAboutMenu.IsEmpty())
  390. {
  391. pSysMenu->AppendMenu(MF_SEPARATOR);
  392. pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
  393. }
  394. }
  396. // Set the icon for this dialog.  The framework does this automatically
  397. //  when the application's main window is not a dialog
  398. SetIcon(m_hIcon, TRUE); // Set big icon
  399. SetIcon(m_hIcon, FALSE); // Set small icon
  401. // TODO: Add extra initialization here
  403. CountDevice ();
  405. GetDlgItem (IDC_EDIT1)->SetWindowText ("c:\temp1.mpg");
  406. GetDlgItem (IDC_EDIT1)->EnableWindow (m_ToFile);
  407. GetDlgItem (IDC_STOP)->EnableWindow (IsCapture);
  409. CaptureToFile = m_ToFile;
  410. return TRUE;  // return TRUE  unless you set the focus to a control
  411. }
  413. void CMAV8Dlg::OnSysCommand(UINT nID, LPARAM lParam)
  414. {
  415. if ((nID & 0xFFF0) == IDM_ABOUTBOX)
  416. {
  417. CAboutDlg dlgAbout;
  418. dlgAbout.DoModal();
  419. }
  420. else
  421. {
  422. CDialog::OnSysCommand(nID, lParam);
  423. }
  424. }
  426. // If you add a minimize button to your dialog, you will need the code below
  427. //  to draw the icon.  For MFC applications using the document/view model,
  428. //  this is automatically done for you by the framework.
  430. void CMAV8Dlg::OnPaint() 
  431. {
  432. if (IsIconic())
  433. {
  434. CPaintDC dc(this); // device context for painting
  436. SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  438. // Center icon in client rectangle
  439. int cxIcon = GetSystemMetrics(SM_CXICON);
  440. int cyIcon = GetSystemMetrics(SM_CYICON);
  441. CRect rect;
  442. GetClientRect(&rect);
  443. int x = (rect.Width() - cxIcon + 1) / 2;
  444. int y = (rect.Height() - cyIcon + 1) / 2;
  446. // Draw the icon
  447. dc.DrawIcon(x, y, m_hIcon);
  448. }
  449. else
  450. {
  451. CDialog::OnPaint();
  452. }
  453. }
  455. // The system calls this to obtain the cursor to display while the user drags
  456. //  the minimized window.
  457. HCURSOR CMAV8Dlg::OnQueryDragIcon()
  458. {
  459. return (HCURSOR) m_hIcon;
  460. }
  462. void CMAV8Dlg::OnDestroy() 
  463. {
  464. CDialog::OnDestroy();
  466. CloseAllDevice ();
  467. }
  468. void CMAV8Dlg::CreateVideoWindow ()
  469. {
  470. int nXDelta;
  471. int nXScreenSize, nXNew;
  473. CRect RectDlg;
  474. GetWindowRect(RectDlg);
  475. // readjust the control window location
  476. nXScreenSize=::GetSystemMetrics(SM_CXSCREEN);
  477. nXNew=nXScreenSize/2+50;
  478. nXDelta=nXNew-RectDlg.left;
  479. RectDlg.left=nXNew;
  480. RectDlg.right=RectDlg.right+nXDelta;
  481. MoveWindow(&RectDlg);
  482. // calcuate the overlay window size and location
  483. WORD wOverlayWidth;
  484. WORD wOverlayHeight;
  485. wOverlayWidth = 352;
  486. wOverlayHeight = 288;
  487. RectDlg.left=RectDlg.left-wOverlayWidth-10;
  488. RectDlg.right=RectDlg.left + wOverlayWidth + GetSystemMetrics(SM_CXFRAME)+5;
  489. RectDlg.bottom=RectDlg.top+ wOverlayHeight + 10+
  490. GetSystemMetrics(SM_CYFRAME)+ 
  491. //GetSystemMetrics(SM_CYCAPTION)+GetSystemMetrics(SM_CYMENU);
  492. GetSystemMetrics(SM_CYCAPTION); // test
  495. pOverlayWnd=new COverlay(hVFDrv, RectDlg, wOverlayWidth, wOverlayHeight);
  496. pOverlayWnd->ShowWindow(SW_SHOWNORMAL);
  497. pOverlayWnd->UpdateWindow();
  499. InitEncodeVideoVxD(hVFDrv, 0);
  500.         InitEncodeAudioVxD(hVFDrv, 0);
  501.     InitEncodeSystemVxD(hVFDrv, 0);
  502. }
  504. void CMAV8Dlg::RecordOrStop (int id, CString fn)
  505. {
  506.     WORD flags;
  507. if (IsCapture) {
  508. // Stop capture
  509.         HVFStop(hVFDrv, bStream);
  510. TRACE0 ("HVFStopn");
  511. if (id == 0) {
  512. if (pPlayWnd) {
  513. pPlayWnd->m_pimc->StopWhenReady();
  514. TRACE0 ("StopWhenReadyn");
  515. }
  516. }
  517.         HVFClose(hVFDrv, bStream);
  518. TRACE0 ("HVFClosen");
  519. bStream = 0;
  520. IsCapture = FALSE;
  521. }
  522. else {
  523. // Start Record
  524. IsCapture = TRUE;
  526. flags = VF_FLAG_MPEG | VF_FLAG_ENCODE | VF_FLAG_OUTBUF;
  527. lstrcpy (caFileName, fn.GetBuffer (MAX_PATH));
  528. bStream = static_cast<BYTE> (HVFOpen(hVFDrv, 
  529. flags, 
  530. reinterpret_cast<unsigned long>(MyCallBack)));
  531. fn.ReleaseBuffer ();
  532. InitEncodeVideoVxD(hVFDrv, bStream);
  533.         InitEncodeAudioVxD(hVFDrv, bStream);
  534. InitEncodeSystemVxD(hVFDrv, bStream);
  535.         
  536. if (id == 0) {
  537. for (int i = 0; i< 100; i++)
  538. Ptr[i] = pbMem[i];
  540. rwIndex = 0;
  541. Ready = false;
  542. }
  544. HVFRecord(hVFDrv, bStream, NULL, NULL);
  546. if (id == 0) {
  547. pPlayWnd->Render ();
  548. }
  549. }
  550. GetDlgItem (IDC_STOP)->EnableWindow (IsCapture);
  551. GetDlgItem (IDC_INWINDOW)->EnableWindow (!IsCapture);
  552. GetDlgItem (IDC_TOFILE)->EnableWindow (!IsCapture);
  553. }
  555. void CMAV8Dlg::OnCheck1() 
  556. {
  557. if (m_Check1.GetCheck () == 1) {
  558. if (m_InputWnd && !pOverlayWnd)
  559. CreateVideoWindow ();
  560. GetDlgItem (IDC_RECORD)->EnableWindow (TRUE);
  561. pPlayWnd = new CPlayWnd (); ///
  562. hWnd = pPlayWnd->GetSafeHwnd ();
  563. pPlayWnd->ShowWindow (SW_SHOW); ///
  564. pPlayWnd->UpdateWindow(); ///
  565. }
  566. else {
  567. delete pOverlayWnd;
  568. pOverlayWnd = NULL;
  569. delete pPlayWnd;
  570. pPlayWnd= NULL;
  571. GetDlgItem (IDC_RECORD)->EnableWindow (FALSE);
  572. GetDlgItem (IDC_STOP)->EnableWindow (FALSE);
  573. }
  574. }
  576. void CMAV8Dlg::OnRecstop1() 
  577. {
  579. CString fn;
  581. GetDlgItem (IDC_EDIT1)->GetWindowText (fn);
  583. RecordOrStop (0, fn);
  585. }
  588. void CMAV8Dlg::OnTofile() 
  589. {
  590. UpdateData (TRUE);
  591. CaptureToFile = m_ToFile;
  592. GetDlgItem (IDC_EDIT1)->EnableWindow (m_ToFile);
  593. }
  595. void CMAV8Dlg::OnInwindow() 
  596. {
  597. UpdateData (TRUE);
  599. if (m_InputWnd) {
  600. if(!pOverlayWnd) {
  601. CreateVideoWindow ();
  602. }
  603. } else {
  604. if(pOverlayWnd)
  605. delete pOverlayWnd;
  606. pOverlayWnd = NULL;
  607. }
  609. }