.net中捕获摄像头视频的方式及对比(How to Capture Camera Video via .Net)

作者：王先荣
前言
    随着Windows操作系统的不断演变，用于捕获视频的API接口也在进化，微软提供了VFW、DirectShow和MediaFoundation这三代接口。其中VFW早已被DirectShow取代，而最新的MediaFoundation被Windows Vista和Windows 7所支持。可惜的是，上述接口基于COM技术且灵活性很大，在.net中并不方便直接使用。
.net封装
    老外有很多活雷锋，他们奉献了不少的开源项目，DirectShow.net是对DirectShow的封装，而MediaFoundation.net是对MediaFoundation的封装。它们都能在http://sourceforge.net上找到。这两个封装之后的类库基本上跟原来的COM是一一对应的关系，可以用于视频捕获，但是用起来还是不够简便。
    通过不断的google搜索，我认为以下类库对视频捕获封装得不错，它们是：DirectX.Capture、OpenCv、EmguCv和AForge。
DirectX.Capture
    DirectX.Capture是发表在CodeProject上的一个项目，它能很方便的捕获视频和音频，在窗口预览，并将结果保存到文件。使用DirectX.Capture的示例如下：

DirectX.Capture

Capture capture = new Capture( Filters.VideoInputDevices[ 0 ],
Filters.AudioInputDevices[ 1 ] );
capture.Filename = " C:\MyVideo.avi " ;
capture.Start();
// ...
capture.Stop();

但是，它没有提供单独获取某帧内容的方法。如果您只是需要预览并保存视频，它很好用。
OpenCv
    OpenCv对VFW和DirectShow的视频捕获部分进行了很好的封装，能够很方便的获取到某帧的内容，也可以将结果保存到视频文件中。使用OpenCv的示例如下：

OpenCv

IntPtr ptrCapture = CvInvoke.cvCreateCameraCapture(param.deviceInfo.Index);
while ( ! stop)
{
IntPtr ptrImage = CvInvoke.cvQueryFrame(ptrCapture);
lock (lockObject)
{
stop = stopCapture;
}
}
CvInvoke.cvReleaseCapture( ref ptrCapture);

      不过OpenCv并未对音频捕获进行封装，如果需要同时录制音频，这个搞不定。
值得注意的是，从OpenCv 1.1开始已经实现了对DirectShow的封装，这跟网上很多人所说的OpenCv使用VFW进行视频捕获效率低下这种观点不一致。关于OpenCv使用DirectShow的论据请看本文的附录。
EmguCv
    EmguCv是对OpenCv在.net的封装，继承了OpenCv快速的优点，同时它更加好用。使用EmguCv的示例代码如下：

EmguCv

Capture capture = new Capture(param.deviceInfo.Index);
while ( ! stop)
{
pbCapture.Image = capture.QueryFrame().Bitmap;
lock (lockObject)
{
stop = stopCapture;
}
}
capture.Dispose();

 

 

AForge
    AForge是一套纯正的.net开源图像处理类库，它的视频捕获类也是基于DirectShow的，但更加好用，功能更多，从使用和帮助来看更类似微软的类库。

AForge

captureAForge = new VideoCaptureDevice(cameraDevice.MonikerString);
captureAForge.NewFrame += new NewFrameEventHandler(captureAForge_NewFrame);
captureAForge.Start();
// ...
captureAForge.SignalToStop();
private void captureAForge_NewFrame( object sender, NewFrameEventArgs eventArgs)
{
pbCapture.Image = (Bitmap)eventArgs.Frame.Clone();
}

 

对比
    介绍完它们之后，我们来比较下它们。它们都是基于DirectShow的，所以性能几乎一样。实际上，我个人认为，摄像头所用的硬件和驱动程序的支持对性能影响更大。我的摄像头在Windows 7下没有专门的驱动程序，只能使用Microsoft提供的默认驱动，性能比WindowsXp要差一截。
值得注意的是主要有几点：
    （1）只有DirectX.Capture实现了对音频的捕获；
    （2）只有DirectX.Capture不能获取单独的某帧图像；
    （3）EmguCv的免费版基于商业许可，而其他类库的许可都很宽松；
    （4）AForge的示例和帮助比较好，而且功能多些。

 

附录：OpenCv也用DirectShow来捕获视频
通过分析OpenCv 2.0的源代码，我得出了OpenCv使用DirectShow来捕获视频的结论。证据如下：

DirectShow In OpenCv

（ 1 ）
// _highgui.h line:100
#if (_MSC_VER >= 1400 || defined __GNUC__) && !defined WIN64 && !defined _WIN64

#define HAVE_VIDEOINPUT 1

#endif

（ 2 ）
// cvcap_dshow.cpp line:44
#ifdef HAVE_VIDEOINPUT

#include " videoinput.h "


/* ******************** Capturing video from camera via VFW ******************** */


class CvCaptureCAM_DShow : public CvCapture

（ 3 ）
// cvapp.cpp line:102
CV_IMPL CvCapture * cvCreateCameraCapture ( int index)
{
// .....
// line:140
switch (domains[i])

{

#ifdef HAVE_VIDEOINPUT

case CV_CAP_DSHOW:

capture = cvCreateCameraCapture_DShow (index);

if (capture)

return capture;

break ;

#endif

 

本文完整源代码

完整代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;
using AForge.Video;
using AForge.Video.DirectShow;
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;
using Emgu.CV.UI;
using System.Threading;

namespace ImageProcessLearn
{
public partial class FormCameraCapture : Form
{
private int framesCaptured; // 已经捕获的视频帧数
private int frameCount; // 需要捕获的总帧数
private Stopwatch sw; // 计时器
private VideoCaptureDevice captureAForge = null ; // AForge视频捕获对象
private bool stopCapture; // 是否停止捕获视频
private object lockObject = new object ();

public FormCameraCapture()
{
InitializeComponent();
sw = new Stopwatch();
}

// 窗体加载时，获取视频捕获设备列表
private void FormCameraCapture_Load( object sender, EventArgs e)
{
FilterInfoCollection videoDevices = new FilterInfoCollection(FilterCategory.VideoInputDevice);
if (videoDevices != null && videoDevices.Count > 0 )
{
int idx = 0 ;
foreach (FilterInfo device in videoDevices)
{
cmbCaptureDevice.Items.Add( new DeviceInfo(device.Name, device.MonikerString, idx, FilterCategory.VideoInputDevice));
idx ++ ;
}
cmbCaptureDevice.SelectedIndex = 0 ;
}
}

// 当改变视频设备时，重新填充该设备对应的能力
private void cmbCaptureDevice_SelectedIndexChanged( object sender, EventArgs e)
{
if (cmbCaptureDevice.SelectedItem != null )
{
// 保存原来选择的设备能力
Size oldFrameSize = new Size( 0 , 0 );
int oldMaxFrameRate = 0 ;
if (cmbDeviceCapability.SelectedItem != null )
{
oldFrameSize = ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize;
oldMaxFrameRate = ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).MaxFrameRate;
}
// 清除设备能力
cmbDeviceCapability.Items.Clear();
// 添加新的设备能力
int oldCapIndex = - 1 ; // 原来选择的设备能力的新索引
VideoCaptureDevice video = new VideoCaptureDevice(((DeviceInfo)cmbCaptureDevice.SelectedItem).MonikerString);
for ( int i = 0 ; i < video.VideoCapabilities.Length; i ++ )
{
VideoCapabilities cap = video.VideoCapabilities[i];
DeviceCapabilityInfo capInfo = new DeviceCapabilityInfo(cap.FrameSize, cap.MaxFrameRate);
cmbDeviceCapability.Items.Add(capInfo);
if (oldFrameSize == capInfo.FrameSize && oldMaxFrameRate == capInfo.MaxFrameRate)
oldCapIndex = i;
}
// 重新选择原来的设备能力，或者选一个新的能力
if (oldCapIndex == - 1 )
oldCapIndex = 0 ;
cmbDeviceCapability.SelectedIndex = oldCapIndex;
}
}

// 当改变设备能力时
private void cmbDeviceCapability_SelectedIndexChanged( object sender, EventArgs e)
{
if ( int .Parse(txtRate.Text) >= ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).MaxFrameRate)
txtRate.Text = ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).MaxFrameRate.ToString();
}

// 性能测试：测试获取指定帧数的视频，并将其转换成图像，所需要的时间，然后计算出FPS
private void btnPerformTest_Click( object sender, EventArgs e)
{
int frameCount = int .Parse(txtFrameCount.Text);
if (frameCount <= 0 )
frameCount = 300 ;
DeviceInfo device = (DeviceInfo)cmbCaptureDevice.SelectedItem;
btnPerformTest.Enabled = false ;
btnStart.Enabled = false ;
txtResult.Text += PerformTestWithAForge(device.MonikerString, frameCount);
txtResult.Text += PerformTestWithEmguCv(device.Index, frameCount);
txtResult.Text += PerformTestWithOpenCv(device.Index, frameCount);
btnPerformTest.Enabled = true ;
btnStart.Enabled = true ;
}

// AForge性能测试
private string PerformTestWithAForge( string deviceMonikerString, int frameCount)
{
VideoCaptureDevice video = new VideoCaptureDevice(deviceMonikerString);
video.NewFrame += new NewFrameEventHandler(PerformTest_NewFrame);
video.DesiredFrameSize = ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize;
video.DesiredFrameRate = int .Parse(txtRate.Text);
framesCaptured = 0 ;
this .frameCount = frameCount;
video.Start();
sw.Reset();
sw.Start();
video.WaitForStop();
double time = sw.Elapsed.TotalMilliseconds;
return string .Format( " AForge性能测试，帧数：{0}，耗时：{1:F05}毫秒，FPS:{2:F02}，设定（{3}）\r\n " , frameCount, time, 1000d * frameCount / time, GetSettings());
}

void PerformTest_NewFrame( object sender, NewFrameEventArgs eventArgs)
{
framesCaptured ++ ;
if (framesCaptured > frameCount)
{
sw.Stop();
VideoCaptureDevice video = sender as VideoCaptureDevice;
video.SignalToStop();
}
}

// EmguCv性能测试
private string PerformTestWithEmguCv( int deviceIndex, int frameCount)
{
Capture video = new Capture(deviceIndex);
video.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FRAME_WIDTH, ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize.Width);
video.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FRAME_HEIGHT, ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize.Height);
video.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FPS, double .Parse(txtRate.Text));
sw.Reset();
sw.Start();
for ( int i = 0 ; i < frameCount; i ++ )
video.QueryFrame();
sw.Stop();
video.Dispose();
double time = sw.Elapsed.TotalMilliseconds;
return string .Format( " EmguCv性能测试，帧数：{0}，耗时：{1:F05}毫秒，FPS:{2:F02}，设定（{3}）\r\n " , frameCount, time, 1000d * frameCount / time, GetSettings());
}

// OpenCv性能测试
private string PerformTestWithOpenCv( int deviceIndex, int frameCount)
{
IntPtr ptrVideo = CvInvoke.cvCreateCameraCapture(deviceIndex);
CvInvoke.cvSetCaptureProperty(ptrVideo, CAP_PROP.CV_CAP_PROP_FRAME_WIDTH, ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize.Width);
CvInvoke.cvSetCaptureProperty(ptrVideo, CAP_PROP.CV_CAP_PROP_FRAME_HEIGHT, ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize.Height);
CvInvoke.cvSetCaptureProperty(ptrVideo, CAP_PROP.CV_CAP_PROP_FPS, double .Parse(txtRate.Text));
sw.Reset();
sw.Start();
for ( int i = 0 ; i < frameCount; i ++ )
CvInvoke.cvQueryFrame(ptrVideo);
sw.Stop();
CvInvoke.cvReleaseCapture( ref ptrVideo);
double time = sw.Elapsed.TotalMilliseconds;
return string .Format( " OpenCv性能测试，帧数：{0}，耗时：{1:F05}毫秒，FPS:{2:F02}，设定（{3}）\r\n " , frameCount, time, 1000d * frameCount / time, GetSettings());
}

// 得到设置所对应的字符串
private string GetSettings()
{
return string .Format( " 摄像头：{0}，尺寸：{1}x{2}，FPS：{3} " , ((DeviceInfo)cmbCaptureDevice.SelectedItem).Name,
((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize.Width,
((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize.Height,
txtRate.Text);
}

// 开始捕获视频
private void btnStart_Click( object sender, EventArgs e)
{
// 得到设置项
DeviceInfo cameraDevice = (DeviceInfo)cmbCaptureDevice.SelectedItem;
Size frameSize = ((DeviceCapabilityInfo)cmbDeviceCapability.SelectedItem).FrameSize;
int rate = int .Parse(txtRate.Text);
ThreadParam param = new ThreadParam(cameraDevice, new DeviceCapabilityInfo(frameSize, rate));
if (rbAForge.Checked)
{
captureAForge = new VideoCaptureDevice(cameraDevice.MonikerString);
captureAForge.DesiredFrameSize = frameSize;
captureAForge.DesiredFrameRate = rate;
captureAForge.NewFrame += new NewFrameEventHandler(captureAForge_NewFrame);
txtResult.Text += string .Format( " 开始捕获视频（方式：AForge，开始时间：{0}）......\r\n " , DateTime.Now.ToLongTimeString());
framesCaptured = 0 ;
sw.Reset();
sw.Start();
captureAForge.Start();
}
else if (rbEmguCv.Checked)
{
stopCapture = false ;
Thread captureThread = new Thread( new ParameterizedThreadStart(CaptureWithEmguCv));
captureThread.Start(param);
}
else if (rbOpenCv.Checked)
{
stopCapture = false ;
Thread captureThread = new Thread( new ParameterizedThreadStart(CaptureWithOpenCv));
captureThread.Start(param);
}
btnStart.Enabled = false ;
btnStop.Enabled = true ;
btnPerformTest.Enabled = false ;
}

private void captureAForge_NewFrame( object sender, NewFrameEventArgs eventArgs)
{
pbCapture.Image = (Bitmap)eventArgs.Frame.Clone();
lock (lockObject)
{
framesCaptured ++ ;
}
}

// EmguCv视频捕获
private void CaptureWithEmguCv( object objParam)
{
bool stop = false ;
int framesCaptured = 0 ;
Stopwatch sw = new Stopwatch();
txtResult.Invoke( new AddResultDelegate(AddResultMethod), string .Format( " 开始捕获视频（方式：EmguCv，开始时间：{0}）......\r\n " , DateTime.Now.ToLongTimeString()));
ThreadParam param = (ThreadParam)objParam;
Capture capture = new Capture(param.deviceInfo.Index);
capture.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FRAME_WIDTH, param.deviceCapability.FrameSize.Width);
capture.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FRAME_HEIGHT, param.deviceCapability.FrameSize.Height);
capture.SetCaptureProperty(CAP_PROP.CV_CAP_PROP_FPS, param.deviceCapability.MaxFrameRate);
sw.Start();
while ( ! stop)
{
pbCapture.Image = capture.QueryFrame().Bitmap;
framesCaptured ++ ;
lock (lockObject)
{
stop = stopCapture;
}
}
sw.Stop();
txtResult.Invoke( new AddResultDelegate(AddResultMethod), string .Format( " 捕获视频结束（方式：EmguCv，结束时间：{0}，用时：{1:F05}毫秒，帧数：{2}，FPS：{3:F02}）\r\n " ,
DateTime.Now.ToLongTimeString(), sw.Elapsed.TotalMilliseconds, framesCaptured, framesCaptured / sw.Elapsed.TotalSeconds));
capture.Dispose();
}

// OpenCv视频捕获
private void CaptureWithOpenCv( object objParam)
{
bool stop = false ;
int framesCaptured = 0 ;
Stopwatch sw = new Stopwatch();
txtResult.Invoke( new AddResultDelegate(AddResultMethod), string .Format( " 开始捕获视频（方式：OpenCv，开始时间：{0}）......\r\n " , DateTime.Now.ToLongTimeString()));
ThreadParam param = (ThreadParam)objParam;
IntPtr ptrCapture = CvInvoke.cvCreateCameraCapture(param.deviceInfo.Index);
CvInvoke.cvSetCaptureProperty(ptrCapture, CAP_PROP.CV_CAP_PROP_FRAME_WIDTH, param.deviceCapability.FrameSize.Width);
CvInvoke.cvSetCaptureProperty(ptrCapture, CAP_PROP.CV_CAP_PROP_FRAME_HEIGHT, param.deviceCapability.FrameSize.Height);
CvInvoke.cvSetCaptureProperty(ptrCapture, CAP_PROP.CV_CAP_PROP_FPS, param.deviceCapability.MaxFrameRate);
sw.Start();
while ( ! stop)
{
IntPtr ptrImage = CvInvoke.cvQueryFrame(ptrCapture);
MIplImage iplImage = (MIplImage)Marshal.PtrToStructure(ptrImage, typeof (MIplImage));
Image < Bgr, byte > image = new Image < Bgr, byte > (iplImage.width, iplImage.height, iplImage.widthStep, iplImage.imageData);
pbCapture.Image = image.Bitmap;
// pbCapture.Image = ImageConverter.IplImagePointerToBitmap(ptrImage);
framesCaptured ++ ;
lock (lockObject)
{
stop = stopCapture;
}
}
sw.Stop();
txtResult.Invoke( new AddResultDelegate(AddResultMethod), string .Format( " 捕获视频结束（方式：OpenCv，结束时间：{0}，用时：{1:F05}毫秒，帧数：{2}，FPS：{3:F02}）\r\n " ,
DateTime.Now.ToLongTimeString(), sw.Elapsed.TotalMilliseconds, framesCaptured, framesCaptured / sw.Elapsed.TotalSeconds));
CvInvoke.cvReleaseCapture( ref ptrCapture);
}

// 停止捕获视频
private void btnStop_Click( object sender, EventArgs e)
{
if (captureAForge != null )
{
sw.Stop();
if (captureAForge.IsRunning)
captureAForge.SignalToStop();
captureAForge = null ;
txtResult.Text += string .Format( " 捕获视频结束（方式：AForge，结束时间：{0}，用时：{1:F05}毫秒，帧数：{2}，FPS：{3:F02}）\r\n " ,
DateTime.Now.ToLongTimeString(), sw.Elapsed.TotalMilliseconds, framesCaptured, framesCaptured / sw.Elapsed.TotalSeconds);
}
lock (lockObject)
{
stopCapture = true ;
}
btnStart.Enabled = true ;
btnStop.Enabled = false ;
btnPerformTest.Enabled = true ;
}

// 用于在工作线程中更新结果的委托及方法
public delegate void AddResultDelegate( string result);
public void AddResultMethod( string result)
{
txtResult.Text += result;
}
}

// 设备信息
public struct DeviceInfo
{
public string Name;
public string MonikerString;
public int Index;
Guid Category;

public DeviceInfo( string name, string monikerString, int index) :
this (name, monikerString, index, Guid.Empty)
{
}

public DeviceInfo( string name, string monikerString, int index, Guid category)
{
Name = name;
MonikerString = monikerString;
Index = index;
Category = category;
}

public override string ToString()
{
return Name;
}
}

// 设备能力
public struct DeviceCapabilityInfo
{
public Size FrameSize;
public int MaxFrameRate;

public DeviceCapabilityInfo(Size frameSize, int maxFrameRate)
{
FrameSize = frameSize;
MaxFrameRate = maxFrameRate;
}

public override string ToString()
{
return string .Format( " {0}x{1} {2}fps " , FrameSize.Width, FrameSize.Height, MaxFrameRate);
}
}

// 传递到捕获视频工作线程的参数
public struct ThreadParam
{
public DeviceInfo deviceInfo;
public DeviceCapabilityInfo deviceCapability;

public ThreadParam(DeviceInfo deviceInfo, DeviceCapabilityInfo deviceCapability)
{
this .deviceInfo = deviceInfo;
this .deviceCapability = deviceCapability;
}
}
}

 

希望本文对您有所帮助。

最后，祝您春节愉快～～