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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
VMR_Capture.cpp
资源名称：VideoMove.rar　[点击查看]
上传用户：czshopping
上传日期：2022-05-22
资源大小：5430k
文件大小：19k
源码类别：

视频捕捉/采集

开发平台：

Visual C++

VMR_Capture.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. //  This class is designed to provide simple interface for 
  4. //  simultaneous Video Capture & Preview using DirectShow
  5. //
  6. //////////////////////////////////////////////////////////////////////
  7. //
  8. // References: MS DirectShow Samples
  9. //
  10. //
  11. //////////////////////////////////////////////////////////////////////
  12. //
  13. // This class was written by Sagar K.R . 
  14. //  Use of this class is not restricted in any
  15. // way whatsoever.Please report the bugs to krssagar@firsteccom.co.kr
  16. //
  17. // Special thanks to all the members at The Code Project! 
  18. // (www.codeproject.com)
  19. //
  20. //////////////////////////////////////////////////////////////////////
  22. // VMR_Capture.cpp: implementation of the CVMR_Capture class.
  23. //
  24. //////////////////////////////////////////////////////////////////////
  26. #include "stdafx.h"
  27. #include "VMR_Capture.h"
  29. #define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
  30. int iMinOld=0,iMinNew=0;
  31. //////////////////////////////////////////////////////////////////////
  32. // Construction/Destruction
  33. //////////////////////////////////////////////////////////////////////
  34. CVMR_Capture::CVMR_Capture()
  35. {
  36. CoInitialize(NULL);
  37. m_pGB = NULL;
  38. m_pMC = NULL;
  39. m_pME = NULL;
  40. m_pWC = NULL;
  41. m_pDF =NULL;
  42. m_pCamOutPin =NULL;
  43. m_pFrame=NULL;
  44. m_nFramelen=0;
  46. m_psCurrent=Stopped;
  47. m_iHeight=240;
  48. m_iWidth=320; 
  49. lpVideo=this;
  50. }
  52. CVMR_Capture::~CVMR_Capture()
  53. {
  54. CloseInterfaces();
  55. CoUninitialize( );
  56. m_MoveTrace.Uninitialize();
  57. }
  58. HRESULT CVMR_Capture::Init(int iDeviceID,HWND hWnd, int iWidth, int iHeight)
  59. {
  60. HRESULT hr;
  61. // Get the interface for DirectShow's GraphBuilder
  62.     hr=CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, 
  63.                          IID_IGraphBuilder, (void **)&m_pGB);
  65.     if(SUCCEEDED(hr))
  66.     {
  67.         // Create the Video Mixing Renderer and add it to the graph
  68.         InitializeWindowlessVMR(hWnd);        
  69. // Bind Device Filter.  We know the device because the id was passed in
  70. if(!BindFilter(iDeviceID, &m_pDF))
  71. return S_FALSE;
  73. hr=m_pGB->AddFilter(m_pDF, L"Video Capture");
  74. if (FAILED(hr))
  75. return hr;
  77. CComPtr<IEnumPins> pEnum;
  78. m_pDF->EnumPins(&pEnum);
  80. hr = pEnum->Reset();
  81. hr = pEnum->Next(1, &m_pCamOutPin, NULL); 
  85.         // QueryInterface for DirectShow interfaces
  86.         hr = m_pGB->QueryInterface(IID_IMediaControl, (void **)&m_pMC);
  88.         hr = m_pGB->QueryInterface(IID_IMediaEventEx, (void **)&m_pME);     
  90. // Have the graph signal event via window callbacks for performance
  91.         //hr = pME->SetNotifyWindow((OAHWND)hWnd, WM_GRAPHNOTIFY, 0);
  94. hr = InitVideoWindow(hWnd,iWidth, iHeight);
  96. m_nFramelen=iWidth*iHeight*3;
  97. m_pFrame=(BYTE*) new BYTE[m_nFramelen];
  99.         
  101. // Run the graph to play the media file
  103. m_psCurrent=Stopped;
  104.         
  105. hr = m_pGB->Render(m_pCamOutPin);
  106. hr = m_pMC->Run();
  107. m_psCurrent=Running;
  109.         
  110. }
  111. // m_hCapWnd=hWnd;
  112. ///////////////////////////////////////
  113. m_hParentWnd=hWnd;
  114. m_hCapWnd=hWnd;
  115. // m_hCapWnd= capCreateCaptureWindow(
  116. // (LPSTR)"Face Video Capture Window", WS_CHILD|WS_VISIBLE,
  117. // 0, 0,m_iWidth,m_iHeight,
  118. //  hwndParent, nCapWndID );
  119. m_pDC=CWnd::FromHandle(m_hParentWnd)->GetDC();
  121. if (m_MemDC.GetSafeHdc()==NULL)
  122. {
  123. m_MemDC.CreateCompatibleDC(m_pDC);
  124. }
  126. m_Bitmap.CreateCompatibleBitmap(m_pDC,m_iWidth,m_iHeight);
  127. m_MoveTrace.Initialize(320, 240,3,3);
  128. m_bStorageData=FALSE;
  129. //////////////////////////////////////
  130. return hr;
  132. }
  135. HRESULT CVMR_Capture::InitializeWindowlessVMR(HWND hWnd)
  136. {
  137.     IBaseFilter* pVmr = NULL;
  139.     // Create the VMR and add it to the filter graph.
  140.     HRESULT hr = CoCreateInstance(CLSID_VideoMixingRenderer, NULL,
  141.                                   CLSCTX_INPROC, IID_IBaseFilter, (void**)&pVmr);
  142.     if (SUCCEEDED(hr)) 
  143.     {
  144.         hr = m_pGB->AddFilter(pVmr, L"Video Mixing Renderer");
  145.         if (SUCCEEDED(hr)) 
  146.         {
  147.             // Set the rendering mode and number of streams.  
  148.             IVMRFilterConfig* pConfig;
  150.             hr = pVmr->QueryInterface(IID_IVMRFilterConfig, (void**)&pConfig);
  151.             if( SUCCEEDED(hr)) 
  152.             {
  153.                 pConfig->SetRenderingMode(VMRMode_Windowless);
  154.                 pConfig->Release();
  155.             }
  157.             hr = pVmr->QueryInterface(IID_IVMRWindowlessControl, (void**)&m_pWC);
  158.             if( SUCCEEDED(hr)) 
  159.             {
  160.                 m_pWC->SetVideoClippingWindow(hWnd);
  161.                 
  162.             }
  163.         }
  164.         pVmr->Release();
  165.     }
  167.     return hr;
  168. }
  170. bool CVMR_Capture::BindFilter(int deviceId, IBaseFilter **pFilter)
  171. {
  172. if (deviceId < 0)
  173. return false;
  175.     // enumerate all video capture devices
  176. CComPtr<ICreateDevEnum> pCreateDevEnum;
  177.     HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
  178.   IID_ICreateDevEnum, (void**)&pCreateDevEnum);
  179.     if (hr != NOERROR)
  180. {
  182. return false;
  183. }
  185.     CComPtr<IEnumMoniker> pEm;
  186.     hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
  187. &pEm, 0);
  188.     if (hr != NOERROR) 
  189. {
  190. return false;
  191.     }
  193.     pEm->Reset();
  194.     ULONG cFetched;
  195.     IMoniker *pM;
  196. int index = 0;
  197.     while(hr = pEm->Next(1, &pM, &cFetched), hr==S_OK, index <= deviceId)
  198.     {
  199. IPropertyBag *pBag;
  200. hr = pM->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pBag);
  201. if(SUCCEEDED(hr)) 
  202. {
  203. VARIANT var;
  204. var.vt = VT_BSTR;
  205. hr = pBag->Read(L"FriendlyName", &var, NULL);
  206. if (hr == NOERROR) 
  207. {
  208. if (index == deviceId)
  209. {
  210. pM->BindToObject(0, 0, IID_IBaseFilter, (void**)pFilter);
  211. }
  212. SysFreeString(var.bstrVal);
  213. }
  214. pBag->Release();
  215. }
  216. pM->Release();
  217. index++;
  218.     }
  219. return true;
  220. }
  222. HRESULT CVMR_Capture::InitVideoWindow(HWND hWnd,int width, int height)
  223. {
  225. // Set the grabbing size
  226.     // First we iterate through the available media types and 
  227.     // store the first one that fits the requested size.
  228.     // If we have found one, we set it.
  229.     // In any case we query the size of the current media type
  230.     // to have this information for clients of this class.
  231.     //     Gerhard Reitmayr <reitmayr@i ...............>
  233. HRESULT hr;
  234. RECT rcDest;
  236.     CComPtr<IAMStreamConfig> pConfig;
  237.     IEnumMediaTypes *pMedia;
  238.     AM_MEDIA_TYPE *pmt = NULL, *pfnt = NULL;
  240.     hr = m_pCamOutPin->EnumMediaTypes( &pMedia );
  241.     if(SUCCEEDED(hr))
  242.     {
  244.         while(pMedia->Next(1, &pmt, 0) == S_OK)
  245.         {
  246.             if( pmt->formattype == FORMAT_VideoInfo )
  247.             {
  248.                 VIDEOINFOHEADER *vih = (VIDEOINFOHEADER *)pmt->pbFormat;
  249.                 // printf("Size %i  %in", vih->bmiHeader.biWidth, vih->bmiHeader.biHeight );
  250.                 if( vih->bmiHeader.biWidth == width && vih->bmiHeader.biHeight == height )
  251.                 {
  252.                     pfnt = pmt;
  254.                     // printf("found mediatype with %i %in", vih->bmiHeader.biWidth, vih->bmiHeader.biHeight );
  255. //char test[100];
  256. //sprintf(test,"Width=%dnHeight=%d",vih->bmiHeader.biWidth, vih->bmiHeader.biHeight);
  257. //MessageBox(test);
  258.                     break;
  259.                 }
  260.                 DeleteMediaType( pmt );
  261.             }                        
  262.         }
  263.         pMedia->Release();
  264.     }
  265.     hr = m_pCamOutPin->QueryInterface( IID_IAMStreamConfig, (void **) &pConfig );
  266.     if(SUCCEEDED(hr))
  267.     {
  268.         if( pfnt != NULL )
  269.         {
  270.             hr=pConfig->SetFormat( pfnt );
  272. //if(SUCCEEDED(hr))        
  273. //MessageBox("OK");
  275.             DeleteMediaType( pfnt );
  276.         }
  277.         hr = pConfig->GetFormat( &pfnt );
  278.         if(SUCCEEDED(hr))
  279.         {
  281.             m_nWidth = ((VIDEOINFOHEADER *)pfnt->pbFormat)->bmiHeader.biWidth;
  282.             m_nHeight = ((VIDEOINFOHEADER *)pfnt->pbFormat)->bmiHeader.biHeight;
  284.             DeleteMediaType( pfnt );
  285.         }
  286.     }
  287. ::GetClientRect (hWnd,&rcDest);
  288.     hr = m_pWC->SetVideoPosition(NULL, &rcDest);
  289.     return hr;
  290. }
  292. void CVMR_Capture::StopCapture()
  293. {
  294.     HRESULT hr;
  296. if((m_psCurrent == Paused) || (m_psCurrent == Running))
  297.     {
  298.         LONGLONG pos = 0;
  299.         hr = m_pMC->Stop();
  300.         m_psCurrent = Stopped;
  301.         // Display the first frame to indicate the reset condition
  302.         hr = m_pMC->Pause();
  303.     }
  304. // CWnd::FromHandle(m_hParentWnd)->ReleaseDC(m_pDC);
  306. m_Bitmap.DeleteObject();
  307. if (m_MemDC.GetSafeHdc()!=NULL)
  308. {
  309. m_MemDC.DeleteDC();
  310. }
  311.    
  313. }
  315. void CVMR_Capture::CloseInterfaces(void)
  316. {
  317.     HRESULT hr;
  319.     
  320. // Stop media playback
  321.     if(m_pMC)
  322.         hr = m_pMC->Stop();     
  323.     m_psCurrent = Stopped;  
  325. // Disable event callbacks
  326. /*
  327.     if (pME)
  328.         hr = m_pME->SetNotifyWindow((OAHWND)NULL, 0, 0);
  329. */
  331. // SAFE_RELEASE(pME);
  335.     // Release and zero DirectShow interfaces
  336. if(m_pCamOutPin)
  337. m_pCamOutPin->Disconnect ();
  340. SAFE_RELEASE(m_pCamOutPin);        
  341.     SAFE_RELEASE(m_pMC);    
  342.     SAFE_RELEASE(m_pGB);    
  343.     SAFE_RELEASE(m_pWC);
  344. SAFE_RELEASE(m_pDF);
  350. //delete allocated memory 
  351. if(m_pFrame!=NULL)
  352. delete []m_pFrame;
  354. }
  356. //Capture RAW IMAGE BITS 24bits/pixel
  357. DWORD CVMR_Capture::ImageCapture(LPCTSTR szFile)
  358. {
  359. BYTE *pImage;
  360. DWORD dwSize,dwWritten;
  361. dwSize=this->GrabFrame ();
  362. this->GetFrame (&pImage);
  364. HANDLE hFile = CreateFile(szFile, GENERIC_WRITE, FILE_SHARE_READ, NULL,
  365.   CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
  367. if (hFile == INVALID_HANDLE_VALUE)
  368. return FALSE;
  370. WriteFile(hFile, (LPCVOID)pImage , m_nFramelen, &dwWritten, 0);
  371. // Close the file
  372. CloseHandle(hFile);
  375. return dwWritten;
  376. }
  378. void CVMR_Capture::DeleteMediaType(AM_MEDIA_TYPE *pmt)
  379. {
  380.     // allow NULL pointers for coding simplicity
  382.     if (pmt == NULL) {
  383.         return;
  384.     }
  386.     if (pmt->cbFormat != 0) {
  387.         CoTaskMemFree((PVOID)pmt->pbFormat);
  389.         // Strictly unnecessary but tidier
  390.         pmt->cbFormat = 0;
  391.         pmt->pbFormat = NULL;
  392.     }
  393.     if (pmt->pUnk != NULL) {
  394.         pmt->pUnk->Release();
  395.         pmt->pUnk = NULL;
  396.     }
  398.     CoTaskMemFree((PVOID)pmt);
  399. }
  402. DWORD CVMR_Capture::GrabFrame()
  403. {
  404. long lOut=-1;
  405. if(m_pWC ) 
  406.     {
  407.        BYTE* lpCurrImage = NULL;
  409.         // Read the current video frame into a byte buffer.  The information
  410.         // will be returned in a packed Windows DIB and will be allocated
  411.         // by the VMR.
  412.         if(m_pWC->GetCurrentImage(&lpCurrImage) == S_OK)
  413.         {
  415. LPBITMAPINFOHEADER  pdib = (LPBITMAPINFOHEADER) lpCurrImage;
  417. if(m_pFrame==NULL || (pdib->biHeight * pdib->biWidth * 3) !=m_nFramelen )
  418. {
  419. if(m_pFrame!=NULL)
  420. delete []m_pFrame;
  422. m_nFramelen=pdib->biHeight * pdib->biWidth * 3;
  423. m_pFrame=new BYTE [pdib->biHeight * pdib->biWidth * 3] ;
  426. }
  428. if(pdib->biBitCount ==32) 
  429. {
  430. DWORD  dwSize=0, dwWritten=0;
  432. BYTE *pTemp32;
  433. pTemp32=lpCurrImage + sizeof(BITMAPINFOHEADER);
  435. //change from 32 to 24 bit /pixel
  436. this->Convert24Image(pTemp32, m_pFrame, pdib->biSizeImage);
  438. }
  440. CoTaskMemFree(lpCurrImage); //free the image 
  441. }
  442. else
  443. {
  444. return lOut;
  445. }
  447. }
  448. else
  449. {
  450. return lOut;
  451. }
  455.     return lOut=m_nFramelen;
  457. }
  459. bool CVMR_Capture::Convert24Image(BYTE *p32Img, BYTE *p24Img,DWORD dwSize32)
  460. {
  462. if(p32Img != NULL && p24Img != NULL && dwSize32>0)
  463. {
  465. DWORD dwSize24;
  467. dwSize24=(dwSize32 * 3)/4;
  469. BYTE *pTemp,*ptr;
  470. //pTemp=p32Img + sizeof(BITMAPINFOHEADER); ;
  471. pTemp=p32Img;
  473. ptr=p24Img + dwSize24-1 ;
  475. int ival=0;
  476. for (DWORD index = 0; index < dwSize32/4 ; index++)
  477. {
  478. unsigned char r = *(pTemp++);
  479. unsigned char g = *(pTemp++);
  480. unsigned char b = *(pTemp++);
  481. (pTemp++);//skip alpha
  483. *(ptr--) = b;
  484. *(ptr--) = g;
  485. *(ptr--) = r;
  487. }
  488. }
  489. else
  490. {
  491. return false;
  492. }
  494. return true;
  495. }
  497. BOOL CVMR_Capture::Pause()
  498. {
  499.     if (!m_pMC)
  500.         return FALSE;
  501.   
  503.     if(((m_psCurrent == Paused) || (m_psCurrent == Stopped)) )
  504.     {
  505. this->StopCapture();
  506.         if (SUCCEEDED(m_pMC->Run()))
  507.             m_psCurrent = Running;
  509.     }
  510.     else
  511.     {
  512.         if (SUCCEEDED(m_pMC->Pause()))
  513.             m_psCurrent = Paused;
  514.     }
  516. return TRUE;
  517. }
  521. DWORD CVMR_Capture::GetFrame(BYTE **pFrame)
  522. {
  523. if(m_pFrame && m_nFramelen)
  524. {
  525. *pFrame=m_pFrame;
  526. }
  529. return m_nFramelen;
  530. }
  532. int  CVMR_Capture::EnumDevices(HWND hList)
  533. {
  534. if (!hList)
  535. return  -1;
  537. int id = 0;
  539.     // enumerate all video capture devices
  540. CComPtr<ICreateDevEnum> pCreateDevEnum;
  541. //    ICreateDevEnum *pCreateDevEnum;
  542.     HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
  543.   IID_ICreateDevEnum, (void**)&pCreateDevEnum);
  544.     if (hr != NOERROR)
  545. {
  547. return -1;
  548. }
  552.     CComPtr<IEnumMoniker> pEm;
  553.     hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
  554. &pEm, 0);
  555.     if (hr != NOERROR) 
  556. {
  558. return -1 ;
  559.     }
  561.     pEm->Reset();
  562.     ULONG cFetched;
  563.     IMoniker *pM;
  564.     while(hr = pEm->Next(1, &pM, &cFetched), hr==S_OK)
  565.     {
  566. IPropertyBag *pBag;
  567. hr = pM->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pBag);
  568. if(SUCCEEDED(hr)) 
  569. {
  570. VARIANT var;
  571. var.vt = VT_BSTR;
  572. hr = pBag->Read(L"FriendlyName", &var, NULL);
  573. if (hr == NOERROR) 
  574. {
  575. TCHAR str[2048];
  578. id++;
  579. WideCharToMultiByte(CP_ACP,0,var.bstrVal, -1, str, 2048, NULL, NULL);
  582. (long)SendMessage(hList, CB_ADDSTRING, 0,(LPARAM)str);
  584. SysFreeString(var.bstrVal);
  585. }
  586. pBag->Release();
  587. }
  588. pM->Release();
  589.     }
  590. return id;
  591. }
  593. typedef struct{ 
  594. int lui;
  595. int luj;
  596. int h;
  597. int w;
  598.  }AREA; 
  600. typedef struct{ 
  601. int upx;
  602. int upy;
  603. int width;
  604. int height;
  606.     AREA leftEyeArea;
  607.     AREA rightEyeArea;
  608.     AREA leftPupil;
  609. AREA rightPupil;
  610.     AREA noseArea;
  611. AREA mouthArea;
  612.  }FACE_LOCATION; 
  613. /*
  614. BOOL UsedFuction(unsigned char * pImage, int Width, int Height, 
  615. FACE_LOCATION * face, int * FaceNumber);
  618. HINSTANCE Dll_handler;
  619. typedef BOOL(DLLTEST)(BYTE* pData,  int w, int h, int* FaceLeftUpX, int* 
  620. FaceLeftUpY,
  621. int* FaceRightDownX, int* FaceRightDownY, int* FaceNumber);
  622. DLLTEST* DllTest;
  624. Dll_handler = 
  625. LoadLibrary("F:\最新文档2006年12月\newdll\Release\newdll");
  626. DllTest=(DLLTEST*)GetProcAddress(Dll_handler,"fuction_1");
  628. iReturn1=(*DllTest)(pData, w, h, FaceLeftUpX,FaceLeftUpY, 
  629. FaceRightDownX,FaceRightDownY, &FaceNumber);
  630. if (!nRet){   TRACE("Failed to detect face.rn");
  631. delete pImg;
  632. continue;
  633. }
  635. FreeLibrary(Dll_handler);
  636. Dll_handler=NULL;
  637. */
  640. BOOL CVMR_Capture::Trace(BYTE *pImageByte)
  641. {
  642. ////////////////////////////////////////////////////////////////////////
  643. // MoveWindow(100,100,320,240);
  644. /////////////////////////////////////
  645. if (lpVideo == NULL) 
  646. return (LRESULT) TRUE;
  647. //////////////////////////////////
  648.     unsigned char* pImgData;
  649. pImgData=pImageByte;
  650. int x, y, nX, nY;
  651. nX = 1;
  652. nY = 1;
  653. const int nMosaicWidth=4;
  654. const int nMosaicHeight=4;
  655. CBitmap *pOldBitmap;
  656. pOldBitmap=lpVideo->m_MemDC.SelectObject(&lpVideo->m_Bitmap);
  658. lpVideo->m_MoveTrace.GetDIBBit(pImgData);//lpVHdr->lpData
  659. lpVideo->m_MoveTrace.Extract(nX, nY);
  661. lpVideo->m_MoveTrace.Grey(); //m_Grey1
  662. lpVideo->m_MoveTrace.Sobel(); //m_Grey1
  664. int nThreshold=lpVideo->m_MoveTrace.GetThreshold(30);// ThresholdDIB((LPSTR)lpVideo->m_MoveTrace.m_pGrey1,320,240);
  666. lpVideo->m_MoveTrace.FrameMinus(); //m_pGrey[x]=abs(m_pGrey1[x] - m_pGrey2[x]);
  667. lpVideo->m_MoveTrace.Mosaic(nMosaicWidth, nMosaicHeight); //m_pGrey --> m_pMosaic
  669. lpVideo->m_MoveTrace.Dither(nThreshold); //m_pMosaic  
  671. for( y=0;y<lpVideo->m_iHeight;y+=1)
  672. {
  673. for( x=0;x<lpVideo->m_iWidth;x+=1)
  674. {
  675. int nPos = y/nY*lpVideo->m_iWidth/nX+x/nX;
  676. int nTemp = lpVideo->m_MoveTrace.m_pMosaic[nPos];
  677. // int nTemp = lpVideo->m_MoveTrace.m_pGrey[nPos];
  678. // int nTemp = lpVideo->m_MoveTrace.m_pGrey1[nPos];
  679. lpVideo->m_MemDC.SetPixel(x,lpVideo->m_iHeight-1-y,RGB(nTemp,nTemp,nTemp));
  680. }
  681. }
  683. lpVideo->m_MoveTrace.SaveFrame(); //m_pGrey2[x] = m_pGrey1[x];
  685. CRect rect;
  686. bool bRet1=lpVideo->m_MoveTrace.Rectangle(rect,100,5);//m_pMosaic
  687. if (bRet1)
  688. {
  689. lpVideo->m_MemDC.Draw3dRect(&rect, RGB(0, 255, 0), RGB(0, 255, 0));
  690. lpVideo->m_MemDC.Draw3dRect(&lpVideo->m_MoveTrace.m_NextRect, RGB(0, 0, 255), RGB(0, 0, 255));
  691. lpVideo->m_MemDC.Draw3dRect(&lpVideo->m_MoveTrace.m_CurrentRect, RGB(255, 0, 0), RGB(255, 0, 0));
  693. }
  694. //SetDIBitsToDevice(lpVideo->m_pDC->m_hDC,0,0,m_iWidth,m_iHeight,0,0,)；
  695. BOOL bRet=lpVideo->m_pDC->BitBlt(
  696. 250,0,
  697. lpVideo->m_iWidth,
  698. lpVideo->m_iHeight,
  699. &lpVideo->m_MemDC,
  700. 0,0,
  701. SRCCOPY);
  703. lpVideo->m_MemDC.SelectObject(pOldBitmap);
  704. //保存图片
  705. CTime Time=CTime::GetCurrentTime();
  706. CString strTime = Time.Format("%H%M%S");
  707. iMinNew=Time.GetMinute( );
  708. strTime="pics\"+strTime;
  709. if((iMinNew-iMinOld)>1)m_bStorageData=TRUE;
  710. if(lpVideo->m_bStorageData)
  711. {
  712. // lpVideo->SaveImage(lpVHdr);
  713. lpVideo->WriteAsBMP(strTime.GetBuffer(strTime.GetLength()),pImgData,320,240);
  714. lpVideo->m_bStorageData = FALSE;
  715. iMinOld=iMinNew;
  716. }
  717. return true;
  720. ////////////////////////////////////////////////////////////////////////
  721.    
  722. }
  723. void CVMR_Capture::MoveWindow(int x,int y,int nWidth,int nHeight)
  724. {
  725. //m_iWidth = nWidth;
  726. //m_iHeight = nHeight;
  727. ::MoveWindow(m_hCapWnd,x,y,nWidth,nHeight,TRUE); 
  728. }
  729. /////////////////////////////////////////////////////////////////////////////////
  730. BOOL CVMR_Capture::WriteAsBMP(char* szFileName,unsigned char* pImgData,int nWidth,int nHeight)
  731. {
  732. char aFileName[255];
  733. int nStrLen;
  734. if(strstr(szFileName,".")==NULL)
  735. {
  736. strcpy(aFileName,szFileName);
  737. strcat(aFileName,".bmp");
  738. }
  739. else
  740. {
  741. nStrLen=strlen(szFileName)-strlen(strstr(szFileName,"."));
  742. strncpy(aFileName,szFileName,nStrLen);
  743. aFileName[nStrLen]='';
  744. strcat(aFileName,".bmp");
  745. }
  747. BITMAPFILEHEADER bmfHdr; // Header for Bitmap file
  749. /* Fill in file type (first 2 bytes must be "BM" for a bitmap) */
  750. bmfHdr.bfType = 0x4d42;  // "BM"
  752. // Calculate the file size by adding the DIB size to sizeof(BITMAPFILEHEADER)
  753. int nImgWidth;
  754. if (nWidth%4==0)
  755. {
  756. nImgWidth=nWidth*3;
  757. }
  758. else
  759. {
  760. nImgWidth=nWidth*3+nWidth%4;
  761. }
  763. bmfHdr.bfSize =(DWORD)( nImgWidth*nHeight + sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER) );
  764. bmfHdr.bfReserved1 = 0;
  765. bmfHdr.bfReserved2 = 0;
  766. bmfHdr.bfOffBits = (DWORD)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER));
  768. BITMAPINFOHEADER BMIH;   // Pointer to DIB info structure
  769. BMIH.biSize=sizeof(BITMAPINFOHEADER);
  770. BMIH.biHeight=nHeight;
  771. BMIH.biWidth=nWidth;
  772. BMIH.biPlanes=1;
  773. BMIH.biBitCount=24;
  774. BMIH.biCompression=BI_RGB;
  775. BMIH.biSizeImage=nImgWidth*nHeight;
  776. BMIH.biXPelsPerMeter=0xec4;
  777. BMIH.biYPelsPerMeter =0xec4;
  778. BMIH.biClrUsed =0;
  779. BMIH.biClrImportant=0;
  781. FILE *pFile;
  783. pFile=fopen(aFileName,"wb");
  784. if (pFile==NULL)
  785. {
  786. return FALSE;
  787. }
  789. BYTE aTemp[12]={0};
  790. try {
  791. // Write the file header
  792. fwrite((BYTE*)&bmfHdr,1,sizeof(BITMAPFILEHEADER),pFile);
  793. // Write the DIB header
  794.         fwrite((BYTE*)&BMIH,1,sizeof(BITMAPINFOHEADER),pFile);
  795. // Write the DIB bits
  796. int j;
  797. for (j=0;j<nHeight;j++)
  798. {
  799. int i;
  800. i=nHeight-j;
  801. fwrite(pImgData+i*nWidth*3,1,nWidth*3,pFile);
  802. fwrite(aTemp,1,nWidth%4,pFile);
  803. }
  804.     }
  805.     catch(...)
  806. {
  807. fclose(pFile);
  809.         return FALSE;
  810.     }
  811. fclose(pFile);
  813.     return TRUE;
  814. }