.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;
}
}
}
希望本文对您有所帮助。
最后，祝您春节愉快～～
184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
