VC 读取usb相机

最新推荐文章于 2024-09-15 14:51:45 发布

吴安

最新推荐文章于 2024-09-15 14:51:45 发布

阅读量4.1k

点赞数

分类专栏： vc

vc 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

使用vfw
# include <vfw.h>//加入视频采集所需头文件需要用到Vfw32.lib库，在project->setting->link->object/library modules中添加
          char achDeviceVersion[80] ; // 设备版本信息
          char achDeviceAndVersion[160]; //设备名及版本信息
          int uIndex;
  DriverCount=0;//支持的设备驱动程序个数
       for(uIndex=0;uIndex<5;uIndex++)
   {
   if(capGetDriverDescription(uIndex,(LPSTR)achDeviceAndVersion,sizeof(achDeviceAndVersion),(LPSTR)achDeviceVersion,sizeof(achDeviceVersion)))
   {
   strcat(achDeviceAndVersion,",");
           strcat(achDeviceAndVersion,achDeviceVersion);
           DriverCount++;

   }
   else
   break;
   }

   if(DriverCount==0)
   MessageBox("找不到视频设备，请确认已正确连接","错误信息",MB_ICONSTOP|MB_OK);
       else
   {

   CMainFrame *pFrame=(CMainFrame *)AfxGetApp()->m_pMainWnd;
       CTest11View *pView=(CTest11View *)pFrame->GetActiveView();
   HWND hWnd;
   hWnd=pView->GetSafeHwnd();

RECT rc;
GetClientRect(&rc);
        hWndCap=capCreateCaptureWindow(NULL,
WS_CHILD|WS_VISIBLE,30,70,
(rc.right-rc.left)/4,(rc.bottom-rc.top)/4,
hWnd,//parent window
0          //chile window id
);//建立视频采集窗口
ASSERT(hWndCap);
if(capDriverConnect(hWndCap,--uIndex))//判断采集窗口是否与0号采集卡驱动相连接

{
//获取视频设备采集能力
capDriverGetCaps(hWnd,&CapDriverCaps,sizeof(CAPDRIVERCAPS));
        if(CapDriverCaps.fCaptureInitialized)//初始化成功

{  // 设置Preview模式的频帧
            capPreviewRate(hWndCap, 20);
            //启动Preview模式
            capPreview(hWndCap, TRUE);
    //设置每帧结束后所调用的回调函数
//capSetCallbackOnFrame(hWndCap,FrameCallbackProc);

//如果支持视频源选择，则弹出视频源选择对话框
if(CapDriverCaps.fHasDlgVideoSource)
capDlgVideoSource(hWnd);
//如果支持视频格式选择，则弹出视频格式选择对话框
        if(CapDriverCaps.fHasDlgVideoFormat)
capDlgVideoFormat(hWnd);
//如果支持视频显示格式选择，则弹出视频显示格式选择对话框
        if(CapDriverCaps.fHasDlgVideoDisplay)
capDlgVideoDisplay(hWnd);
}
else//初始化不成功
   MessageBox("捕获卡初始化失败","错误信息",MB_ICONSTOP|MB_OK);
   }
else
           MessageBox("捕获卡连接失败","错误信息",MB_ICONSTOP|MB_OK);

}

　在桌面视频会议、可视电话等多媒体应用中，获得数字视频是一个关键的前提
。在Video for Windows（VFW）出现之前，捕获数字视频是一项极其复杂的工作
。Microsoft 的Visual C++自从4.0版就开始支持Video for Windows（简称VFW）
，这给视频捕获编程带来了很大的方便。关于多媒体应用开发，市面流行资料中介
绍较多的是MCI（媒体控制接口）,而本文着重介绍的是如何使用Visual C++提供的
AVICap窗口类进行视频捕获以及其中涉及到的概念和关键问题。

　　一、Video for Windows简介

　　VFW是Microsoft 1992年推出的关于数字视频的一个软件包，它能使应用程序
数字化并播放从传统模拟视频源得到的视频剪辑。VFW的一个关键思想是播放时不
需要专用硬件，为了解决数字视频数据量大的问题，需要对数据进行压缩。它引进
了一种叫AVI的文件标准，该标准未规定如何对视频进行捕获、压缩及播放，仅规
定视频和音频该如何存储在硬盘上，在AVI文件中交替存储视频帧和与之相匹配的
音频数据。VFW给程序员提供.VBX和AVICap窗口类的高级编程工具，使程序员能通
过发送消息或设置属性来捕获、播放和编辑视频剪辑。现在用户不必专门安装VFW
了，Windows95本身包括了Video for Windows1.1，当用户在安装Windows时，安装
程序会自动地安装配置视频所需的组件，如设备驱动程序、视频压缩程序等。

　　VFW主要由以下六个模块组成：

　　（1）AVICAP.DLL：包含了执行视频捕获的函数，它给AVI文件I/O和视频、音
频设备驱动程序提供一个高级接口；

　　（2）MSVIDEO.DLL：用一套特殊的DrawDib函数来处理屏幕上的视频操作；

　　（3）MCIAVI.DRV：此驱动程序包括对VFW的MCI命令的解释器；

　　（4）AVIFILE.DLL：支持由标准多媒体I/O（mmio）函数提供的更高的命令来
访问.AVI文件；

　　（5）压缩管理器（ICM）：管理用于视频压缩－解压缩的编解码器（CODEC）
；

　　（6）音频压缩管理器ACM：提供与ICM相似的服务，不同的是它适于波形音频
。

　　Visual C++在支持VFW方面提供有vfw32.lib、 msacm32.lib 、winmm.lib等类
似的库。特别是它提供了功能强大、简单易行、类似于MCIWnd的窗口类AVICap。
AVICap为应用程序提供了一个简单的、基于消息的接口，使之能访问视频和波形音
频硬件，并能在将视频流捕获到硬盘上的过程中进行控制。

　　二、AVICap编程简介

　　AVICap支持实时的视频流捕获和单帧捕获并提供对视频源的控制。虽然MCI也
提供数字视频服务，比如它为显示.AVI文件的视频提供了avivideo命令集，为视频
叠加提供了overlay命令集，但这些命令主要是基于文件的操作，它不能满足实时
地直接从视频缓存中取数据的要求，对于使用没有视频叠加能力的捕获卡的PC机来
说，用MCI提供的命令集是无法捕获视频流的。而AVICap在捕获视频方面具有一定
的优势，它能直接访问视频缓冲区，不需要生成中间文件，实时性很强，效率很高
。同时，它也可将数字视频捕获到文件。

　　在视频捕获之前需要创建一个捕获窗，所有的捕获操作及其设置都以它为基础
。用AVICap窗口类创建的窗口（通过capCreateCaptureWindow函数创建）被称为“
捕获窗”，其窗口风格一般为WS_CHILD和WS_VISIBLE。在概念上，捕获窗类似于标
准控制（如按钮、列表框等）。捕获窗具有下列功能：

　　（1）将一视频流和音频流捕获到一个AVI文件中；

　　（2）动态地同视频和音频输入器件连接或断开；

　　（3）以Overlay或Preview模式对输入的视频流进行实时显示；

　　（4）在捕获时可指定所用的文件名并能将捕获文件的内容拷贝到另一个文件
；

　　（5）设置捕获速率；

　　（6）显示控制视频源、视频格式、视频压缩的对话框；

　　（7）创建、保存或载入调色板；

　　（8）将图像和相关的调色板拷贝到剪贴板；

　　（9）将捕获的一个单帧图像保存为DIB格式的文件。

　　这里需要解释一下AVICap在显示视频时提供的两种模式：

　　（A）预览（Preview）模式：该模式使用CPU资源，视频帧先从捕获硬件传到
系统内存，接着采用GDI函数在捕获窗中显示。在物理上，这种模式需要通过VGA卡
在监视器上显示。

　　（B）叠加（Overlay）模式：该模式使用硬件叠加进行视频显示，叠加视频的
显示不经过VGA卡，叠加视频的硬件将VGA的输出信号与其自身的输出信号合并，形
成组合信号显示在计算机的监视器上。只有部分视频捕获卡才具有视频叠加能力。

　　除了利用捕获窗的九个功能外，灵活编写AVICap提供的回调函数还可满足一些
特殊需求，比如将宏capCaptureSequenceNoFile同用
capSetCallbackOnVideoStream登记的回调函数一起使用可使应用程序直接使用视
频和音频数据，在视频会议的应用程序中可利用这一点来获得视频帧，回调函数将
捕获的图像传到远端的计算机。应用程序可用捕获窗来登记回调函数（由用户编写
，而由系统调用），以便在发生下列情况时它能通知应用程序作出相应的反应：

　　（1）捕获窗状态改变；

　　（2）出错；

　　（3）视频帧和音频缓存可以使用；

　　（4）在捕获过程中，其它应用程序处于让步（Yield）地位。

　　与普通SDK编程一样，视频捕获编程也要用到涉及视频捕获的结构、宏、消息
和函数。让编程人员感到轻松的是，发送AVICap窗口消息所能完成的功能都能调用
相应的宏来完成。例如，SendMessage（hWndCap,WM_CAP_DRIVER_CONNECT,0,0L）
与capDriverConnect（hWndCap,0）的作用相同，都是将创建的捕获窗同视频输入
器件连接起来。

　　在利用AVICap编程时，应该熟悉与视频捕获相关的结构，下面对常用的四个结
构作一简要介绍，对于前三个结构都有对应的函数来设置和获得结构包含的信息：

　　（1）CAPSTATUS：定义了捕获窗口的当前状态，如图像的宽、高等；

　　（2）CAPDRIVERCAPS：定义了捕获驱动器的能力，如有无视频叠加能力、有无
控制视频源、视频格式的对话框等；

　　（3）CAPTUREPARMS：包含控制视频流捕获过程的参数，如捕获帧频、指定键
盘或鼠标键以终止捕获、捕获时间限制等；

　　（4）VIDEOHDR：定义了视频数据块的头信息，在编写回调函数时常用到其数
据成员lpData（指向数据缓存的指针）和dwBufferLength（数据缓存的大小）。

三、AVICap编程示例

　　下面以一个简单的应用程序为例说明AVICap的使用，该程序对输入的视频流进
行实时的显示和捕获，演示需要一个视频捕获卡和摄像头。界面中的菜单项如图1
所示。其中，菜单项Display可以以Preview 或Overlay模式显示图像；菜单项
Setting可通过弹出AVICap提供的对话框Video Source、Video Format和Video
Display来对捕获进行设置，图4 中的图像就是按照图2、图3的对话框所示进行设
置、以Preview模式显示的结果；菜单项Capture可将视频流或单帧图像捕获到指定
的文件中去。

　　图1 菜单项

　　图2 Video Format对话框

　　图3 Video Source对话框

　　图4 图2和图3设置下显示的一帧图

　　由于篇幅有限，下面仅介绍与视频捕获相关的编程。

　　1、定义全局变量：

　　HWND ghWndCap ; //捕获窗的句柄

　　CAPDRIVERCAPS gCapDriverCaps ; //视频驱动器的能力

　　CAPSTATUS gCapStatus ; //捕获窗的状态

　　2、处理WM_CREATE消息：

　　//创建捕获窗,其中hWnd为主窗口句柄

　　ghWndCap = capCreateCaptureWindow（（LPSTR）"Capture Window",
WS_CHILD | WS_VISIBLE, 0, 0, 300,240, （HWND） hWnd, （int） 0）;

　　//登记三个回调函数，它们应被提前申明

　　capSetCallbackOnError（ghWndCap, （FARPROC）ErrorCallbackProc）;
capSetCallbackOnStatus（ghWndCap, （FARPROC）StatusCallbackProc）;
capSetCallbackOnFrame（ghWndCap, （FARPROC）FrameCallbackProc）;

　　capDriverConnect（ghWndCap,0）; // 将捕获窗同驱动器连接

　　//获得驱动器的能力,相关的信息放在结构变量gCapDriverCaps中

　　capDriverGetCaps（ghWndCap,&gCapDriverCaps,sizeof（CAPDRIVERCAPS））
;

　　3、处理WM_CLOSE消息:

　　//取消所登记的三个回调函数

　　capSetCallbackOnStatus（ghWndCap, NULL）;

　　capSetCallbackOnError（ghWndCap, NULL）;

　　capSetCallbackOnFrame（ghWndCap, NULL）;

　　capCaptureAbort（ghWndCap）;//停止捕获

　　capDriverDisconnect（ghWndCap）; //将捕获窗同驱动器断开

　　4、处理菜单项Preview:

　　capPreviewRate（ghWndCap, 66）; // 设置Preview模式的显示速率

　　capPreview（ghWndCap, TRUE）; //启动Preview模式

　　5、处理菜单项Overlay:

　　if（gCapDriverCaps.fHasOverlay） //检查驱动器是否有叠加能力

　　capOverlay（ghWndCap,TRUE）; //启动Overlay模式

　　6、处理菜单项Exit:

　　SendMessage（hWnd,WM_CLOSE,wParam,lParam）;

　　7、分别处理Setting下的三个菜单项，它们可分别控制视频源、视频格式及显
示：

　　if （gCapDriverCaps.fHasDlgVideoSource）

　　capDlgVideoSource（ghWndCap）; //Video source 对话框

　　if （gapDriverCaps.fHasDlgVideoFormat）

　　capDlgVideoFormat（ghWndCap）; // Video format 对话框

　　if （CapDriverCaps.fHasDlgVideoDisplay）

　　capDlgVideoDisplay（ghWndCap）; // Video display 对话框

　　8、处理Video Stream菜单项,它捕获视频流到一个.AVI文件:

　　char szCaptureFile[] = "MYCAP.AVI";

　　capFileSetCaptureFile（ ghWndCap, szCaptureFile）; //指定捕获文件名

　　capFileAlloc（ ghWndCap, （1024L * 1024L * 5））; //为捕获文件分配存
储空间

　　capCaptureSequence（ghWndCap）; //开始捕获视频序列

　　9、处理Single Frame菜单项:

　　capGrabFrame（ghWndCap）; //捕获单帧图像

　　10、定义三个回调函数：

　　LRESULT CALLBACK StatusCallbackProc（HWND hWnd, int nID, LPSTR
lpStatusText）

　　{

　　if （!ghWndCap） return FALSE;

　　//获得捕获窗的状态

　　capGetStatus（ghWndCap, &gCapStatus, sizeof （CAPSTATUS））;

　　//更新捕获窗的大小

　　SetWindowPos（ghWndCap, NULL, 0, 0, gCapStatus.uiImageWidth,

　　gCapStatus.uiImageHeight, SWP_NOZORDER | SWP_NOMOVE）;

　　if （nID == 0） { // 清除旧的状态信息

　　SetWindowText（ghWndCap, （LPSTR） gachAppName）;

　　return （LRESULT） TRUE;

　　}

　　// 显示状态 ID 和状态文本

　　wsprintf（gachBuffer, "Status# %d: %s", nID, lpStatusText）;

　　SetWindowText（ghWndCap, （LPSTR）gachBuffer）;

　　return （LRESULT） TRUE;

　　}

　　LRESULT CALLBACK ErrorCallbackProc（HWND hWnd, int nErrID,LPSTR
lpErrorText）

　　{

　　if （!ghWndCap）

　　return FALSE;

　　if （nErrID == 0）

　　return TRUE;// 清除旧的错误

　　wsprintf（gachBuffer, "Error# %d", nErrID）; //显示错误标识和文本

　　MessageBox（hWnd, lpErrorText, gachBuffer,MB_OK |
MB_ICONEXCLAMATION）;

　　return （LRESULT） TRUE;

　　}

　　LRESULT CALLBACK FrameCallbackProc（HWND hWnd, LPVIDEOHDR lpVHdr）

　　{

　　if （!ghWndCap）

　　return FALSE;

　　//假设fp为一打开的.dat文件指针

　　fwrite（fp,lpVHdr->lpData,lpVHdr->dwBufferLength,1）;

　　return （LRESULT） TRUE ;

　　}

　　值得注意的是：应在.cpp文件中加入#include 一句,在Link设置中加入
vfw32.lib。

　　上述的回调函数FrameCallbackProc是将视频数据直接从缓冲写入文件，也可
利用memcpy函数将视频数据直接拷贝到另一缓存。同理，可定义
VideoStreamCallbackProc。capSetCallbackOnVideoStream的使用比
capSetCallbackOnFrame稍微复杂一些。在捕获过程中，当一个新的视频缓冲可得
时，系统就调用它所登记的回调函数。在缺省情况下，捕获窗在捕获过程中不允许
其它应用程序继续运行。为了取消这个限制，可以设置CAPTUREPARMS的成员
fYield为TRUE或建立一个Yield回调函数。为了解决潜在的重入（reentry）问题，
可在YieldCallbackProc中用PeekMessage过滤掉一些消息，例如鼠标消息。

　　四、结束语

　　Visual C++提供的AVICap窗口类为捕获数字视频流及其相关操作提供了很大的
方便，灵活编写其中的回调函数可满足实时视频传输的需要，例如应用程序可直接
从缓冲中取得数字视频并对其进行压缩编码后实时地传到远端的计算机。笔者所从
事的电话网上的可视电话系统就是采用AVICap进行视频捕获的，这种方法同样可用
于其它多媒体会议系统中，如ISDN、局域网上的会议系统等。（

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

http://blog.sina.com.cn/s/blog_51396f890102fabr.html

使用VC和DirectShow从摄像头中读取图像（一）

　　在图像处理时经常会用到从摄像头读取图像。OPENCV有提供的方法来实现，非常简单，不用多说。而使用VC++则没有那么容易，下面介绍使用CImage和DirectShow读取摄像头图像，并显示的对话框中。

我用的开发工具是VS2010。

源代码下载，使用VS2010编译通过。
http://download.csdn.net/detail/sdlypyzq/4087013

一、创建一个MFC对话框程序，工程起名为CameraVCTest。

二、删除无用的控件和按钮。添加一个图片控件，ID为IDC_PICTURE，并为其添加CStatic
类型变量m_picture。添加四个按钮，名称分别为预览，拍照，保存，关闭。ID分别为IDC_VIEW,IDC_TAKEPHOTO,IDC_SAVE,IDC_CLOSE。分别为其添加变量m_view,m_takePhoto,m_save,m_close。双击四个按钮，生成四个响应函数。

三、将DirectShow文件夹和CameraDS类的头文件和源文件拷贝到项目源文件夹下。并在项目属性VC++ Directories添加include Directories，“.\DirectShow”。在Solution Exlporer添加上CameraDS类的头文件和源文件。

四、在CCameraVCTestDlg 类的头文件中，添加

#include "CameraDS.h" #include using namespace std;

添加公共变量和方法

vector cameralist; CImage *m_pImage; void ShowPicture(CImage *img,CStatic *pic); voidSaveCard(CImage *img); int m_cam_count; bool isBreak; CString m_savePath; CString savePath; intm_saveIndex; int m_fileCount;

在源文件的初始化函数里添加：

m_cam_count = CCameraDS::CameraCount(); cameralist.resize(m_cam_count); if(! cameralist[m_cam_count-1].OpenCamera(m_cam_count-1, false, 640,480)) { return FALSE; } this->isBreak = false; this->isSave = false; this->m_view.EnableWindow(TRUE); this->m_takePhoto.EnableWindow(FALSE); this->m_save.EnableWindow(FALSE);

添加如下函数

void DoEvents1() { MSG msg; if (::PeekMessage(&msg,NULL,0,0,PM_REMOVE)) { ::TranslateMessage(&msg); ::DispatchMessage(&msg); } } void CCameraVCTestDlg::OnBnClickedView() {// TODO: Add your control notification handler code here this->isBreak = false; this->m_view.EnableWindow(FALSE); this->m_takePhoto.EnableWindow(TRUE); this->m_save.EnableWindow(FALSE); if(m_cam_count==0) { return ; }//CImage imgShow;//imgShow.Create(this->MAX_WIDTH,this->MAX_HEIGHT,24); while(1) { DoEvents1(); if(isBreak) {break; } this->m_pImage = cameralist[m_cam_count-1].QueryFrame2(); this->ShowPicture(m_pImage,&this->m_picture); //if(m_fileCount == 100) //{ // this->isBreak = true; //this->m_bnInit.EnableWindow(TRUE); // this->m_bnTake.EnableWindow(FALSE); // this->m_bnSave.EnableWindow(TRUE); // break; //} if(isSave) { if(this->m_fileCount<<span style="color: #800080;">100) { //this->m_ctrlProg.SetPos(m_fileCount); CString path; path.Format(L"%s\\%d.jpg",savePath,m_fileCount+m_saveIndex); this->m_pImage->Save(path); m_fileCount++; } else { isSave = false; this->m_view.EnableWindow(FALSE); this->m_takePhoto.EnableWindow(TRUE); //this->m_save.EnableWindow(TRUE); } } Sleep(150); } }

添加视频帧显示函数

void CCameraVCTestDlg::ShowPicture(CImage *img,CStatic *pic) { if(img==NULL) { return ; } intwidth = img->GetWidth(); int height = img->GetHeight(); CRect picRect; this->m_picture.GetClientRect(&picRect); CRect rt(picRect); CDC* dc = this->m_picture.GetDC(); CBrush*pBrush = CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH)); //dc->FillRect(rt, pBrush);if(picRect.Height()*width > height*picRect.Width()) { CPoint p1(0,(picRect.Height()-(picRect.Width()*height/width))/2); CPoint p2(picRect.Width(),(picRect.Height() - p1.y)); rt.SetRect(p1,p2); } else { CPoint p1((picRect.Width()-(picRect.Height()*width/height))/2,0); CPoint p2(picRect.Width()-p1.x,picRect.Height()); rt.SetRect(p1,p2); } // } // this->ShowMouseCursor(CursorTag); ::SetStretchBltMode(dc->m_hDC,HALFTONE); img->Draw(dc->m_hDC, rt); }

添加关闭程序

void CCameraVCTestDlg::OnBnClickedClose() { this->isBreak = true; this->OnClose(); }

好了，现在对话框上，点击预览按钮，就可以打开摄像头了，若还需要什么功能自己添加吧，如有问题，可以一起交流。欢迎不吝赐教。

Camera.h

1 #ifndef POINTER_64
2 
3 
4 #if !defined(_MAC) && (defined(_M_MRX000) || defined(_M_AMD64) || defined(_M_IA64)) && (_MSC_VER >= 1100) && !(defined(MIDL_PASS) || defined(RC_INVOKED))
5 #define POINTER_64 __ptr64
6 typedef unsigned __int64 POINTER_64_INT;
7 #if defined(_WIN64)
8 #define POINTER_32 __ptr32
9 #else
10 #define POINTER_32
11 #endif
12 #else
13 #if defined(_MAC) && defined(_MAC_INT_64)
14 #define POINTER_64 __ptr64
15 typedef unsigned __int64 POINTER_64_INT;
16 #else
17 #if (_MSC_VER >= 1300) && !(defined(MIDL_PASS) || defined(RC_INVOKED))
18 #define POINTER_64 __ptr64
19 #else
20 #define POINTER_64
21 #endif
22 typedef unsigned long POINTER_64_INT;
23 #endif
24 #define POINTER_32
25 #endif
26 
27 #endif
28 
29 
30 
31 
32 
33 #ifndef CCAMERA_H
34 #define CCAMERA_H
35 
36 #define WIN32_LEAN_AND_MEAN
37 
38 #include <</span>atlbase.h>
39 #include "qedit.h"
40 #include "dshow.h"
41 #include <</span>windows.h>
42 //#include "cv.h"
43 
44 //#include 
45 
46 #define MYFREEMEDIATYPE(mt) {if ((mt).cbFormat != 0) \
47 {CoTaskMemFree((PVOID)(mt).pbFormat); \
48 (mt).cbFormat =0; \
49 (mt).pbFormat = NULL; \
50 } \
51 if ((mt).pUnk != NULL) \
52 { \
53 (mt).pUnk->Release(); \
54 (mt).pUnk = NULL; \
55 }} 
56 
57 
58 class CCameraDS 
59 {
60 private:
61 // IplImage * m_pFrame;
62 CImage m_image;
63 bool m_bConnected;
64 int m_nWidth;
65 int m_nHeight;
66 bool m_bLock;
67 bool m_bChanged;
68 long m_nBufferSize;
69 
70 CComPtr<</span>IGraphBuilder> m_pGraph;
71 CComPtr<</span>IBaseFilter> m_pDeviceFilter;
72 CComPtr<</span>IMediaControl> m_pMediaControl; 73 CComPtr<</span>IBaseFilter> m_pSampleGrabberFilter; 74 CComPtr<</span>ISampleGrabber> m_pSampleGrabber; 75 CComPtr<</span>IPin> m_pGrabberInput; 76 CComPtr<</span>IPin> m_pGrabberOutput; 77 CComPtr<</span>IPin> m_pCameraOutput; 78 CComPtr<</span>IMediaEvent> m_pMediaEvent; 79 CComPtr<</span>IBaseFilter> m_pNullFilter; 80 CComPtr<</span>IPin> m_pNullInputPin; 81  82 private: 83 bool BindFilter(int nCamIDX, IBaseFilter **pFilter); 84 void SetCrossBar(); 85  86 public: 87 CCameraDS(); 88 virtual~CCameraDS(); 89  90 //打开摄像头，nCamID指定打开哪个摄像头，取值可以为0,1,2,... 91 //bDisplayProperties指示是否自动弹出摄像头属性页 92 //nWidth和nHeight设置的摄像头的宽和高，如果摄像头不支持所设定的宽度和高度，则返回false 93 bool CCameraDS::OpenCamera(int nCamID, bool bDisplayProperties=true, int nWidth =320, intnHeight =240); 94  95 //关闭摄像头，析构函数会自动调用这个函数 96 void CloseCamera(); 97  98 //返回摄像头的数目 99 //可以不用创建CCameraDS实例，采用int c=CCameraDS::CameraCount();得到结果。 100 staticint CameraCount();  101  102 //根据摄像头的编号返回摄像头的名字 103 //nCamID: 摄像头编号 104 //sName: 用于存放摄像头名字的数组 105 //nBufferSize: sName的大小 106 //可以不用创建CCameraDS实例，采用CCameraDS::CameraName();得到结果。 107 staticint CCameraDS::CameraName(int nCamID, char* sName, int nBufferSize); 108  109 //返回图像宽度 110 int GetWidth(){return m_nWidth;}  111  112 //返回图像高度 113 int GetHeight(){return m_nHeight;} 114  115 //抓取一帧，返回的IplImage不可手动释放！ 116 //返回图像数据的为RGB模式的Top-down(第一个字节为左上角像素)，即IplImage::origin=0(IPL_ORIGIN_TL) 117 // IplImage * QueryFrame(); 118 CImage* QueryFrame2();  119 }; 120  121 #endif

camera.cpp

#include "stdafx.h"
#include "CameraDS.h"

#pragma comment(lib,"Strmiids.lib") 
//
// Construction/Destruction
//

CCameraDS::CCameraDS()
{
m_bConnected =false;
m_nWidth =0;
m_nHeight =0;
m_bLock =false;
m_bChanged =false;
// m_pFrame = NULL;
m_nBufferSize =0;

m_pNullFilter = NULL;
m_pMediaEvent = NULL;
m_pSampleGrabberFilter = NULL;
m_pGraph = NULL;


CoInitialize(NULL);
}

CCameraDS::~CCameraDS()
{
CloseCamera();
CoUninitialize();
}

void CCameraDS::CloseCamera()
{
if(m_bConnected)
m_pMediaControl->Stop();

m_pGraph = NULL;
m_pDeviceFilter = NULL;
m_pMediaControl = NULL;
m_pSampleGrabberFilter = NULL;
m_pSampleGrabber = NULL;
m_pGrabberInput = NULL;
m_pGrabberOutput = NULL;
m_pCameraOutput = NULL;
m_pMediaEvent = NULL;
m_pNullFilter = NULL;
m_pNullInputPin = NULL;


//if (m_pFrame)
// cvReleaseImage(&m_pFrame);
if(!this->m_image.IsNull())
{
this->m_image.Destroy();
}

m_bConnected =false;
m_nWidth =0;
m_nHeight =0;
m_bLock =false;
m_bChanged =false;
m_nBufferSize =0;
}

bool CCameraDS::OpenCamera(int nCamID, bool bDisplayProperties, int nWidth, int nHeight)
{

HRESULT hr = S_OK;

CoInitialize(NULL);
// Create the Filter Graph Manager.
hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC,
IID_IGraphBuilder, (void**)&m_pGraph);

hr = CoCreateInstance(CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER, 
IID_IBaseFilter, (LPVOID *)&m_pSampleGrabberFilter);

hr = m_pGraph->QueryInterface(IID_IMediaControl, (void**) &m_pMediaControl);
hr = m_pGraph->QueryInterface(IID_IMediaEvent, (void**) &m_pMediaEvent);

hr = CoCreateInstance(CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER,
IID_IBaseFilter, (LPVOID*) &m_pNullFilter);


hr = m_pGraph->AddFilter(m_pNullFilter, L"NullRenderer");

hr = m_pSampleGrabberFilter->QueryInterface(IID_ISampleGrabber, (void**)&m_pSampleGrabber);

AM_MEDIA_TYPE mt;
ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE));
mt.majortype = MEDIATYPE_Video;
mt.subtype = MEDIASUBTYPE_RGB24;
mt.formattype = FORMAT_VideoInfo; 
hr = m_pSampleGrabber->SetMediaType(&mt);
MYFREEMEDIATYPE(mt);

m_pGraph->AddFilter(m_pSampleGrabberFilter, L"Grabber");

// Bind Device Filter. We know the device because the id was passed in
BindFilter(nCamID, &m_pDeviceFilter);
m_pGraph->AddFilter(m_pDeviceFilter, NULL);

CComPtr<</span>IEnumPins> pEnum;
m_pDeviceFilter->EnumPins(&pEnum);

hr = pEnum->Reset();
hr = pEnum->Next(1, &m_pCameraOutput, NULL); 

pEnum = NULL; 
m_pSampleGrabberFilter->EnumPins(&pEnum);
pEnum->Reset();
hr = pEnum->Next(1, &m_pGrabberInput, NULL); 

pEnum = NULL;
m_pSampleGrabberFilter->EnumPins(&pEnum);
pEnum->Reset();
pEnum->Skip(1);
hr = pEnum->Next(1, &m_pGrabberOutput, NULL); 

pEnum = NULL;
m_pNullFilter->EnumPins(&pEnum);
pEnum->Reset();
hr = pEnum->Next(1, &m_pNullInputPin, NULL);

//SetCrossBar();

if (bDisplayProperties) 
{
CComPtr<</span>ISpecifyPropertyPages> pPages;

HRESULT hr = m_pCameraOutput->QueryInterface(IID_ISpecifyPropertyPages, (void**)&pPages);
if (SUCCEEDED(hr))
{
PIN_INFO PinInfo;
m_pCameraOutput->QueryPinInfo(&PinInfo);

CAUUID caGUID;
pPages->GetPages(&caGUID);

OleCreatePropertyFrame(NULL, 0, 0,
L"Property Sheet", 1,
(IUnknown **)&(m_pCameraOutput.p),
caGUID.cElems,
caGUID.pElems,
0, 0, NULL);
CoTaskMemFree(caGUID.pElems);
PinInfo.pFilter->Release();
}
pPages = NULL;
}
else 
{
//
// 加入由 lWidth和lHeight设置的摄像头的宽和高 的功能，默认320*240
// by flymanbox @2009-01-24
//
int _Width = nWidth, _Height = nHeight;
IAMStreamConfig* iconfig; 
iconfig = NULL;
hr = m_pCameraOutput->QueryInterface(IID_IAMStreamConfig, (void**)&iconfig); 

AM_MEDIA_TYPE* pmt; 
if(iconfig->GetFormat(&pmt) !=S_OK) 
{
//printf("GetFormat Failed ! \n");
returnfalse; 
}

VIDEOINFOHEADER* phead;
if ( pmt->formattype == FORMAT_VideoInfo) 
{ 
phead=( VIDEOINFOHEADER*)pmt->pbFormat; 
phead->bmiHeader.biWidth = _Width; 
phead->bmiHeader.biHeight = _Height; 
if(( hr=iconfig->SetFormat(pmt)) != S_OK ) 
{
returnfalse;
}

} 

iconfig->Release(); 
iconfig=NULL; 
MYFREEMEDIATYPE(*pmt);
}

hr = m_pGraph->Connect(m_pCameraOutput, m_pGrabberInput);
hr = m_pGraph->Connect(m_pGrabberOutput, m_pNullInputPin);

if (FAILED(hr))
{
switch(hr)
{
case VFW_S_NOPREVIEWPIN :
break;
case E_FAIL :
break;
case E_INVALIDARG :
break;
case E_POINTER :
break;
}
}

m_pSampleGrabber->SetBufferSamples(TRUE);
m_pSampleGrabber->SetOneShot(TRUE);

hr = m_pSampleGrabber->GetConnectedMediaType(&mt);
if(FAILED(hr))
returnfalse;

VIDEOINFOHEADER *videoHeader;
videoHeader = reinterpret_cast<</span>VIDEOINFOHEADER*>(mt.pbFormat);
m_nWidth = videoHeader->bmiHeader.biWidth;
m_nHeight = videoHeader->bmiHeader.biHeight;
m_bConnected =true;

pEnum = NULL;
returntrue;
}

bool CCameraDS::BindFilter(int nCamID, IBaseFilter **pFilter)
{
if (nCamID <</span>0)
returnfalse;

// enumerate all video capture devices
CComPtr<</span>ICreateDevEnum> pCreateDevEnum;
HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
IID_ICreateDevEnum, (void**)&pCreateDevEnum);
if (hr != NOERROR)
{
returnfalse;
}

CComPtr<</span>IEnumMoniker> pEm;
hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
&pEm, 0);
if (hr != NOERROR) 
{
returnfalse;
}

pEm->Reset();
ULONG cFetched;
IMoniker *pM;
int index =0;
while(hr = pEm->Next(1, &pM, &cFetched), hr==S_OK, index <= nCamID)
{
IPropertyBag *pBag;
hr = pM->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pBag);
if(SUCCEEDED(hr)) 
{
VARIANT var;
var.vt = VT_BSTR;
hr = pBag->Read(L"FriendlyName", &var, NULL);
if (hr == NOERROR) 
{
if (index == nCamID)
{
pM->BindToObject(0, 0, IID_IBaseFilter, (void**)pFilter);
}
SysFreeString(var.bstrVal);
}
pBag->Release();
}
pM->Release();
index++;
}

pCreateDevEnum = NULL;
returntrue;
}



//将输入crossbar变成PhysConn_Video_Composite
void CCameraDS::SetCrossBar()
{
int i;
IAMCrossbar *pXBar1 = NULL;
ICaptureGraphBuilder2 *pBuilder = NULL;


HRESULT hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL,
CLSCTX_INPROC_SERVER, IID_ICaptureGraphBuilder2, 
(void**)&pBuilder);

if (SUCCEEDED(hr))
{
hr = pBuilder->SetFiltergraph(m_pGraph);
}


hr = pBuilder->FindInterface(&LOOK_UPSTREAM_ONLY, NULL, 
m_pDeviceFilter,IID_IAMCrossbar, (void**)&pXBar1);

if (SUCCEEDED(hr)) 
{
long OutputPinCount;
long InputPinCount;
long PinIndexRelated;
long PhysicalType;
long inPort =0;
long outPort =0;

pXBar1->get_PinCounts(&OutputPinCount,&InputPinCount);
for( i =0;i<</span>InputPinCount;i++)
{
pXBar1->get_CrossbarPinInfo(TRUE,i,&PinIndexRelated,&PhysicalType);
if(PhysConn_Video_Composite==PhysicalType) 
{
inPort = i;
break;
}
}
for( i =0;i<</span>OutputPinCount;i++) { pXBar1->get_CrossbarPinInfo(FALSE,i,&PinIndexRelated,&PhysicalType); if(PhysConn_Video_VideoDecoder==PhysicalType)  { outPort = i; break; } } if(S_OK==pXBar1->CanRoute(outPort,inPort)) { pXBar1->Route(outPort,inPort); } pXBar1->Release();  } pBuilder->Release(); }  //IplImage* CCameraDS::QueryFrame() //{ // // long evCode; // long size = 0; // // m_pMediaControl->Run(); // m_pMediaEvent->WaitForCompletion(INFINITE, &evCode); //  // m_pSampleGrabber->GetCurrentBuffer(&size, NULL); // ////if the buffer size changed // if (size != m_nBufferSize) // { // if (m_pFrame) // cvReleaseImage(&m_pFrame); // // m_nBufferSize = size; // m_pFrame = cvCreateImage(cvSize(m_nWidth, m_nHeight), IPL_DEPTH_8U, 3); // } // if (m_pFrame == NULL) return NULL; // m_pSampleGrabber->GetCurrentBuffer(&m_nBufferSize, (long*)m_pFrame->imageData); // cvFlip(m_pFrame); // // return m_pFrame; //}  CImage* CCameraDS::QueryFrame2() {  long evCode; long size =0; m_pMediaControl->Run(); m_pMediaEvent->WaitForCompletion(INFINITE, &evCode); m_pSampleGrabber->GetCurrentBuffer(&size, NULL); //if the buffer size changed if (size != m_nBufferSize) { //if (m_pImage != NULL )//|| !m_pImage->IsNull()) //{ // m_pImage->Destroy(); //} // cvReleaseImage(&m_pFrame);  m_nBufferSize = size; //m_pFrame = cvCreateImage(cvSize(m_nWidth, m_nHeight), IPL_DEPTH_8U, 3); m_image.Create(m_nWidth,m_nHeight,24); } //if (m_pFrame == NULL) return NULL; if(m_image.IsNull()) { return0; } byte*q; byte*p =newbyte[m_nWidth*m_nHeight*3]; //m_pSampleGrabber->GetCurrentBuffer(&m_nBufferSize, (long*)m_pFrame->imageData); m_pSampleGrabber->GetCurrentBuffer(&m_nBufferSize, (long*)p); // cvFlip(m_pFrame); // for(int y=0, z=m_nHeight-1; y<</span>m_nHeight,z>=0; y++,z--) { q = (byte*)m_image.GetPixelAddress(0,z); memcpy(q,&p[m_nWidth*3*y],m_nWidth*3); } delete []p; return&m_image; } int CCameraDS::CameraCount() { int count =0; CoInitialize(NULL); // enumerate all video capture devices CComPtr<</span>ICreateDevEnum> pCreateDevEnum; HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**)&pCreateDevEnum); CComPtr<</span>IEnumMoniker> pEm; hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEm, 0); if (hr != NOERROR)  { return count; } pEm->Reset(); ULONG cFetched; IMoniker *pM; while(hr = pEm->Next(1, &pM, &cFetched), hr==S_OK) { count++; } pCreateDevEnum = NULL; pEm = NULL; return count; } int CCameraDS::CameraName(int nCamID, char* sName, int nBufferSize) { int count =0; CoInitialize(NULL); // enumerate all video capture devices CComPtr<</span>ICreateDevEnum> pCreateDevEnum; HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (void**)&pCreateDevEnum); CComPtr<</span>IEnumMoniker> pEm; hr = pCreateDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEm, 0); if (hr != NOERROR) return0; pEm->Reset(); ULONG cFetched; IMoniker *pM; while(hr = pEm->Next(1, &pM, &cFetched), hr==S_OK) { if (count == nCamID) { IPropertyBag *pBag=0; hr = pM->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pBag); if(SUCCEEDED(hr)) { VARIANT var; var.vt = VT_BSTR; hr = pBag->Read(L"FriendlyName", &var, NULL); //还有其他属性,像描述信息等等... if(hr == NOERROR) { //获取设备名称  WideCharToMultiByte(CP_ACP,0,var.bstrVal,-1,sName, nBufferSize ,"",NULL); SysFreeString(var.bstrVal);  } pBag->Release(); } pM->Release(); break; } count++; } pCreateDevEnum = NULL; pEm = NULL; return1; }