.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;
}
}
}
希望本文对您有所帮助。
最后，祝您春节愉快～～
