ASP.Net Core对USB摄像头进行截图

最近想把之前一个USB摄像头拍照的winform程序迁移到.net 5下，首先找了一下，网上有通过DirectShow.NET读取摄像头的例子，Read Barcode from Webcam Viewer with DirectShow.NET。

这个程序依赖着DirectShow.NET的，虽然它是.net framework版本的。试了一下，迁移到.net 5还是无任何障碍的。但我觉得这些原始api使用起来还是不是很方便，便继续找了一下，找到了一个更加简单的类

class UsbCamera:IDisposable
{
/// <summary>Usb camera image size.</summary>
public Size Size { get; private set; }

/// <summary>Start.</summary>
public Action Start { get; private set; }

/// <summary>Stop.</summary>
public Action Stop { get; private set; }

/// <summary>Release resource.</summary>
public Action Release { get; private set; }

/// <summary>Get image.</summary>
/// <remarks>Immediately after starting, fails because image buffer is not prepared yet.</remarks>
public Func<Bitmap> GetBitmap { get; private set; }

/// <summary>
/// Get available USB camera list.
/// </summary>
/// <returns>Array of camera name, or if no device found, zero length array.</returns>
public static string[] FindDevices()
{
return DirectShow.GetFiltes(DirectShow.DsGuid.CLSID_VideoInputDeviceCategory).ToArray();
}

/// <summary>
/// Get video formats.
/// </summary>
public static VideoFormat[] GetVideoFormat(int cameraIndex)
{
var filter = DirectShow.CreateFilter(DirectShow.DsGuid.CLSID_VideoInputDeviceCategory, cameraIndex);
var pin = DirectShow.FindPin(filter, 0, DirectShow.PIN_DIRECTION.PINDIR_OUTPUT);
return GetVideoOutputFormat(pin);
}

/// <summary>
/// Create USB Camera. If device do not support the size, default size will applied.
/// </summary>
/// <param name=\”cameraIndex\”>Camera index in FindDevices() result.</param>
/// <param name=\”size\”>
/// Size you want to create. Normally use Size property of VideoFormat in GetVideoFormat() result.
/// </param>
public UsbCamera(int cameraIndex, Size size) : this(cameraIndex, new VideoFormat() { Size = size })
{
}

/// <summary>
/// Create USB Camera. If device do not support the format, default format will applied.
/// </summary>
/// <param name=\”cameraIndex\”>Camera index in FindDevices() result.</param>
/// <param name=\”format\”>
/// Normally use GetVideoFormat() result.
/// You can change TimePerFrame value from Caps.MinFrameInterval to Caps.MaxFrameInterval.
/// TimePerFrame = 10,000,000 / frame duration. (ex: 333333 in case 30fps).
/// You can change Size value in case Caps.MaxOutputSize > Caps.MinOutputSize and OutputGranularityX/Y is not zero.
/// Size = any value from Caps.MinOutputSize to Caps.MaxOutputSize step with OutputGranularityX/Y.
/// </param>
public UsbCamera(int cameraIndex, VideoFormat format)
{
var camera_list = FindDevices();
if (cameraIndex >= camera_list.Length) throw new ArgumentException(\”USB camera is not available.\”, \”cameraIndex\”);
Init(cameraIndex, format);
}

private void Init(int index, VideoFormat format)
{
//———————————-
// Create Filter Graph
//———————————-
// +——————–+ +—————-+ +—————+
// |Video Capture Source|→| Sample Grabber |→| Null Renderer |
// +——————–+ +—————-+ +—————+
// ↓GetBitmap()

var graph = DirectShow.CreateGraph();

//———————————-
// VideoCaptureSource
//———————————-
var vcap_source = CreateVideoCaptureSource(index, format);
graph.AddFilter(vcap_source, \”VideoCapture\”);

//——————————
// SampleGrabber
//——————————
var grabber = CreateSampleGrabber();
graph.AddFilter(grabber, \”SampleGrabber\”);
var i_grabber = (DirectShow.ISampleGrabber)grabber;
i_grabber.SetBufferSamples(true);

//—————————————————
// Null Renderer
//—————————————————
var renderer = DirectShow.CoCreateInstance(DirectShow.DsGuid.CLSID_NullRenderer) as DirectShow.IBaseFilter;
graph.AddFilter(renderer, \”NullRenderer\”);

//—————————————————
// Create Filter Graph
//—————————————————
var builder = DirectShow.CoCreateInstance(DirectShow.DsGuid.CLSID_CaptureGraphBuilder2) as DirectShow.ICaptureGraphBuilder2;
builder.SetFiltergraph(graph);
var pinCategory = DirectShow.DsGuid.PIN_CATEGORY_CAPTURE;
var mediaType = DirectShow.DsGuid.MEDIATYPE_Video;
builder.RenderStream(ref pinCategory, ref mediaType, vcap_source, grabber, renderer);

// SampleGrabber Format.
{
var mt = new DirectShow.AM_MEDIA_TYPE();
i_grabber.GetConnectedMediaType(mt);
var header = (DirectShow.VIDEOINFOHEADER)Marshal.PtrToStructure(mt.pbFormat, typeof(DirectShow.VIDEOINFOHEADER));
var width = header.bmiHeader.biWidth;
var height = header.bmiHeader.biHeight;
var stride = width * (header.bmiHeader.biBitCount / 8);
DirectShow.DeleteMediaType(ref mt);

Size = new Size(width, height);

// fix screen tearing problem(issure #2)
// you can use previous method if you swap the comment line below.
// GetBitmap = () => GetBitmapFromSampleGrabberBuffer(i_grabber, width, height, stride);
GetBitmap = GetBitmapFromSampleGrabberCallback(i_grabber, width, height, stride);
}

// Assign Delegates.
Start = () => DirectShow.PlayGraph(graph, DirectShow.FILTER_STATE.Running);
Stop = () => DirectShow.PlayGraph(graph, DirectShow.FILTER_STATE.Stopped);
Release = () =>
{
Stop();

DirectShow.ReleaseInstance(ref i_grabber);
DirectShow.ReleaseInstance(ref builder);
DirectShow.ReleaseInstance(ref graph);
};

// Properties.
Properties = new PropertyItems(vcap_source);
}

public void Dispose()
{
Release?.Invoke();
}

/// <summary>Properties user can adjust.</summary>
public PropertyItems Properties { get; private set; }
public class PropertyItems
{
public PropertyItems(DirectShow.IBaseFilter vcap_source)
{
// Pan, Tilt, Roll, Zoom, Exposure, Iris, Focus
this.CameraControl = Enum.GetValues(typeof(DirectShow.CameraControlProperty)).Cast<DirectShow.CameraControlProperty>()
.Select(item =>
{
PropertyItems.Property prop = null;
try
{
var cam_ctrl = vcap_source as DirectShow.IAMCameraControl;
if (cam_ctrl == null) throw new NotSupportedException(\”no IAMCameraControl Interface.\”); // will catched.
int min = 0, max = 0, step = 0, def = 0, flags = 0;
cam_ctrl.GetRange(item, ref min, ref max, ref step, ref def, ref flags); // COMException if not supports.
prop = new Property(min, max, step, def, flags, (flag, value) => cam_ctrl.Set(item, value, (int)flag));
}
catch (Exception) { prop = new Property(); } // available = false
return new { Key = item, Value = prop };
}).ToDictionary(x => x.Key, x => x.Value);

// Brightness, Contrast, Hue, Saturation, Sharpness, Gamma, ColorEnable, WhiteBalance, BacklightCompensation, Gain
this.VideoProcAmp = Enum.GetValues(typeof(DirectShow.VideoProcAmpProperty)).Cast<DirectShow.VideoProcAmpProperty>()
.Select(item =>
{
PropertyItems.Property prop = null;
try
{
var vid_ctrl = vcap_source as DirectShow.IAMVideoProcAmp;
if (vid_ctrl == null) throw new NotSupportedException(\”no IAMVideoProcAmp Interface.\”); // will catched.
int min = 0, max = 0, step = 0, def = 0, flags = 0;
vid_ctrl.GetRange(item, ref min, ref max, ref step, ref def, ref flags); // COMException if not supports.
prop = new Property(min, max, step, def, flags, (flag, value) => vid_ctrl.Set(item, value, (int)flag));
}
catch (Exception) { prop = new Property(); } // available = false
return new { Key = item, Value = prop };
}).ToDictionary(x => x.Key, x => x.Value);
}

/// <summary>Camera Control properties.</summary>
private Dictionary<DirectShow.CameraControlProperty, Property> CameraControl;

/// <summary>Video Processing Amplifier properties.</summary>
private Dictionary<DirectShow.VideoProcAmpProperty, Property> VideoProcAmp;

/// <summary>Get CameraControl Property. Check Available before use.</summary>
public Property this[DirectShow.CameraControlProperty item] { get { return CameraControl[item]; } }

/// <summary>Get VideoProcAmp Property. Check Available before use.</summary>
public Property this[DirectShow.VideoProcAmpProperty item] { get { return VideoProcAmp[item]; } }

public class Property
{
public int Min { get; private set; }
public int Max { get; private set; }
public int Step { get; private set; }
public int Default { get; private set; }
public DirectShow.CameraControlFlags Flags { get; private set; }
public Action<DirectShow.CameraControlFlags, int> SetValue { get; private set; }
public bool Available { get; private set; }
public bool CanAuto { get; private set; }

public Property()
{
this.SetValue = (flag, value) => { };
this.Available = false;
}

public Property(int min, int max, int step, int @default, int flags, Action<DirectShow.CameraControlFlags, int> set)
{
this.Min = min;
this.Max = max;
this.Step = step;
this.Default = @default;
this.Flags = (DirectShow.CameraControlFlags)flags;
this.CanAuto = (Flags & DirectShow.CameraControlFlags.Auto) == DirectShow.CameraControlFlags.Auto;
this.SetValue = set;
this.Available = true;
}

public override string ToString()
{
return string.Format(\”Available={0}, Min={1}, Max={2}, Step={3}, Default={4}, Flags={5}\”, Available, Min, Max, Step, Default, Flags);
}
}
}

private class SampleGrabberCallback : DirectShow.ISampleGrabberCB
{
private byte[] Buffer;
private object BufferLock = new object();

public Bitmap GetBitmap(int width, int height, int stride)
{
var result = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
if (Buffer == null) return result;

var bmp_data = result.LockBits(new Rectangle(Point.Empty, result.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
lock (BufferLock)
{
// copy from last row.
for (int y = 0; y < height; y++)
{
var src_idx = Buffer.Length – (stride * (y + 1));
var dst = IntPtr.Add(bmp_data.Scan0, stride * y);
Marshal.Copy(Buffer, src_idx, dst, stride);
}
}
result.UnlockBits(bmp_data);

return result;
}

// called when each sample completed.
// The data processing thread blocks until the callback method returns. If the callback does not return quickly, it can interfere with playback.
public int BufferCB(double SampleTime, IntPtr pBuffer, int BufferLen)
{
if (Buffer == null || Buffer.Length != BufferLen)
{
Buffer = new byte[BufferLen];
}

lock (BufferLock)
{
Marshal.Copy(pBuffer, Buffer, 0, BufferLen);
}
return 0;
}

// never called.
public int SampleCB(double SampleTime, DirectShow.IMediaSample pSample)
{
throw new NotImplementedException();
}
}

private Func<Bitmap> GetBitmapFromSampleGrabberCallback(DirectShow.ISampleGrabber i_grabber, int width, int height, int stride)
{
var sampler = new SampleGrabberCallback();
i_grabber.SetCallback(sampler, 1); // WhichMethodToCallback = BufferCB
return () => sampler.GetBitmap(width, height, stride);
}

/// <summary>Get Bitmap from Sample Grabber Current Buffer</summary>
private Bitmap GetBitmapFromSampleGrabberBuffer(DirectShow.ISampleGrabber i_grabber, int width, int height, int stride)
{
try
{
return GetBitmapFromSampleGrabberBufferMain(i_grabber, width, height, stride);
}
catch (COMException ex)
{
const uint VFW_E_WRONG_STATE = 0x80040227;
if ((uint)ex.ErrorCode == VFW_E_WRONG_STATE)
{
// image data is not ready yet. return empty bitmap.
return new Bitmap(width, height);
}

throw;
}
}

/// <summary>Get Bitmap from Sample Grabber Current Buffer</summary>
private Bitmap GetBitmapFromSampleGrabberBufferMain(DirectShow.ISampleGrabber i_grabber, int width, int height, int stride)
{

int sz = 0;
i_grabber.GetCurrentBuffer(ref sz, IntPtr.Zero); // IntPtr.Zeroで呼び出してバッファサイズ取得
if (sz == 0) return null;

var ptr = Marshal.AllocCoTaskMem(sz);
i_grabber.GetCurrentBuffer(ref sz, ptr);

var data = new byte[sz];
Marshal.Copy(ptr, data, 0, sz);

var result = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
var bmp_data = result.LockBits(new Rectangle(Point.Empty, result.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);

for (int y = 0; y < height; y++)
{
var src_idx = sz – (stride * (y + 1));
var dst = IntPtr.Add(bmp_data.Scan0, stride * y);
Marshal.Copy(data, src_idx, dst, stride);
}
result.UnlockBits(bmp_data);
Marshal.FreeCoTaskMem(ptr);

return result;
}

private DirectShow.IBaseFilter CreateSampleGrabber()
{
var filter = DirectShow.CreateFilter(DirectShow.DsGuid.CLSID_SampleGrabber);
var ismp = filter as DirectShow.ISampleGrabber;

var mt = new DirectShow.AM_MEDIA_TYPE();
mt.MajorType = DirectShow.DsGuid.MEDIATYPE_Video;
mt.SubType = DirectShow.DsGuid.MEDIASUBTYPE_RGB24;
ismp.SetMediaType(mt);
return filter;
}

/// <summary>
/// Video Capture Sourceフィルタを作成する
/// </summary>
private DirectShow.IBaseFilter CreateVideoCaptureSource(int index, VideoFormat format)
{
var filter = DirectShow.CreateFilter(DirectShow.DsGuid.CLSID_VideoInputDeviceCategory, index);
var pin = DirectShow.FindPin(filter, 0, DirectShow.PIN_DIRECTION.PINDIR_OUTPUT);
SetVideoOutputFormat(pin, format);
return filter;
}

/// <summary>
/// ビデオキャプチャデバイスの出力形式を選択する。
/// </summary>
private static void SetVideoOutputFormat(DirectShow.IPin pin, VideoFormat format)
{
var formats = GetVideoOutputFormat(pin);

for (int i = 0; i < formats.Length; i++)
{
var item = formats[i];

if (item.MajorType != DirectShow.DsGuid.GetNickname(DirectShow.DsGuid.MEDIATYPE_Video)) continue;
if (string.IsNullOrEmpty(format.SubType) == false && format.SubType != item.SubType) continue;
if (item.Caps.Guid != DirectShow.DsGuid.FORMAT_VideoInfo) continue;

if (item.Size.Width == format.Size.Width && item.Size.Height == format.Size.Height)
{
SetVideoOutputFormat(pin, i, format.Size, format.TimePerFrame);
return;
}
}

// Not found fixed size, search for variable size.
for (int i = 0; i < formats.Length; i++)
{
var item = formats[i];

if (item.Caps.OutputGranularityX == 0) continue;
if (item.Caps.OutputGranularityY == 0) continue;

for (int w = item.Caps.MinOutputSize.cx; w < item.Caps.MaxOutputSize.cx; w += item.Caps.OutputGranularityX)
{
for (int h = item.Caps.MinOutputSize.cy; h < item.Caps.MaxOutputSize.cy; h += item.Caps.OutputGranularityY)
{
if (w == format.Size.Width && h == format.Size.Height)
{
SetVideoOutputFormat(pin, i, format.Size, format.TimePerFrame);
return;
}
}
}
}

// Not found, use default size.
SetVideoOutputFormat(pin, 0, Size.Empty, 0);
}

private static VideoFormat[] GetVideoOutputFormat(DirectShow.IPin pin)
{
var config = pin as DirectShow.IAMStreamConfig;
if (config == null)
{
throw new InvalidOperationException(\”no IAMStreamConfig interface.\”);
}

int cap_count = 0, cap_size = 0;
config.GetNumberOfCapabilities(ref cap_count, ref cap_size);
if (cap_size != Marshal.SizeOf(typeof(DirectShow.VIDEO_STREAM_CONFIG_CAPS)))
{
throw new InvalidOperationException(\”no VIDEO_STREAM_CONFIG_CAPS.\”);
}

var result = new VideoFormat[cap_count];

var cap_data = Marshal.AllocHGlobal(cap_size);

for (int i = 0; i < cap_count; i++)
{
var entry = new VideoFormat();

DirectShow.AM_MEDIA_TYPE mt = null;
config.GetStreamCaps(i, ref mt, cap_data);
entry.Caps = PtrToStructure<DirectShow.VIDEO_STREAM_CONFIG_CAPS>(cap_data);

entry.MajorType = DirectShow.DsGuid.GetNickname(mt.MajorType);
entry.SubType = DirectShow.DsGuid.GetNickname(mt.SubType);

if (mt.FormatType == DirectShow.DsGuid.FORMAT_VideoInfo)
{
var vinfo = PtrToStructure<DirectShow.VIDEOINFOHEADER>(mt.pbFormat);
entry.Size = new Size(vinfo.bmiHeader.biWidth, vinfo.bmiHeader.biHeight);
entry.TimePerFrame = vinfo.AvgTimePerFrame;
}
else if (mt.FormatType == DirectShow.DsGuid.FORMAT_VideoInfo2)
{
var vinfo = PtrToStructure<DirectShow.VIDEOINFOHEADER2>(mt.pbFormat);
entry.Size = new Size(vinfo.bmiHeader.biWidth, vinfo.bmiHeader.biHeight);
entry.TimePerFrame = vinfo.AvgTimePerFrame;
}

// 解放
DirectShow.DeleteMediaType(ref mt);

result[i] = entry;
}

// 解放
Marshal.FreeHGlobal(cap_data);

return result;
}

private static void SetVideoOutputFormat(DirectShow.IPin pin, int index, Size size, long timePerFrame)
{
var config = pin as DirectShow.IAMStreamConfig;
if (config == null)
{
throw new InvalidOperationException(\”no IAMStreamConfig interface.\”);
}

var cap_data = Marshal.AllocHGlobal(cap_size);

DirectShow.AM_MEDIA_TYPE mt = null;
config.GetStreamCaps(index, ref mt, cap_data);
var cap = PtrToStructure<DirectShow.VIDEO_STREAM_CONFIG_CAPS>(cap_data);

if (mt.FormatType == DirectShow.DsGuid.FORMAT_VideoInfo)
{
var vinfo = PtrToStructure<DirectShow.VIDEOINFOHEADER>(mt.pbFormat);
if (!size.IsEmpty) { vinfo.bmiHeader.biWidth = size.Width; vinfo.bmiHeader.biHeight = size.Height; }
if (timePerFrame > 0) { vinfo.AvgTimePerFrame = timePerFrame; }
Marshal.StructureToPtr(vinfo, mt.pbFormat, true);
}
else if (mt.FormatType == DirectShow.DsGuid.FORMAT_VideoInfo2)
{
var vinfo = PtrToStructure<DirectShow.VIDEOINFOHEADER2>(mt.pbFormat);
if (!size.IsEmpty) { vinfo.bmiHeader.biWidth = size.Width; vinfo.bmiHeader.biHeight = size.Height; }
if (timePerFrame > 0) { vinfo.AvgTimePerFrame = timePerFrame; }
Marshal.StructureToPtr(vinfo, mt.pbFormat, true);
}

config.SetFormat(mt);

if (cap_data != System.IntPtr.Zero) Marshal.FreeHGlobal(cap_data);
if (mt != null) DirectShow.DeleteMediaType(ref mt);
}

private static T PtrToStructure<T>(IntPtr ptr)
{
return (T)Marshal.PtrToStructure(ptr, typeof(T));
}

public class VideoFormat
{
public string MajorType { get; set; }
public string SubType { get; set; }
public Size Size { get; set; }
public long TimePerFrame { get; set; }
public DirectShow.VIDEO_STREAM_CONFIG_CAPS Caps { get; set; }

public override string ToString()
{
return string.Format(\”{0}, {1}, {2}, {3}, {4}\”, MajorType, SubType, Size, TimePerFrame, CapsString());
}

private string CapsString()
{
var sb = new StringBuilder();
sb.AppendFormat(\”{0}, \”, DirectShow.DsGuid.GetNickname(Caps.Guid));
foreach (var info in Caps.GetType().GetFields())
{
sb.AppendFormat(\”{0}={1}, \”, info.Name, info.GetValue(Caps));
}
return sb.ToString();
}
}

public static class DirectShow
{
#region Function

public static object CoCreateInstance(Guid clsid)
{
return Activator.CreateInstance(Type.GetTypeFromCLSID(clsid));
}

public static void ReleaseInstance<T>(ref T com) where T : class
{
if (com != null)
{
Marshal.ReleaseComObject(com);
com = null;
}
}

public static IGraphBuilder CreateGraph()
{
return CoCreateInstance(DsGuid.CLSID_FilterGraph) as IGraphBuilder;
}

public static void PlayGraph(IGraphBuilder graph, FILTER_STATE state)
{
var mediaControl = graph as IMediaControl;
if (mediaControl == null) return;

switch (state)
{
case FILTER_STATE.Paused: mediaControl.Pause(); break;
case FILTER_STATE.Stopped: mediaControl.Stop(); break;
default: mediaControl.Run(); break;
}
}

public static List<string> GetFiltes(Guid category)
{
var result = new List<string>();

EnumMonikers(category, (moniker, prop) =>
{
object value = null;
prop.Read(\”FriendlyName\”, ref value, 0);
var name = (string)value;

result.Add(name);

return false; // 継続。
});

return result;
}

public static IBaseFilter CreateFilter(Guid clsid)
{
return CoCreateInstance(clsid) as IBaseFilter;
}

public static IBaseFilter CreateFilter(Guid category, int index)
{
IBaseFilter result = null;

int curr_index = 0;
EnumMonikers(category, (moniker, prop) =>
{
if (index != curr_index++) return false;

{
object value = null;
Guid guid = DirectShow.DsGuid.IID_IBaseFilter;
moniker.BindToObject(null, null, ref guid, out value);
result = value as IBaseFilter;
return true;
}
});

if (result == null) throw new ArgumentException(\”can\’t create filter.\”);
return result;
}

private static void EnumMonikers(Guid category, Func<IMoniker, IPropertyBag, bool> func)
{
IEnumMoniker enumerator = null;
ICreateDevEnum device = null;

try
{
device = (ICreateDevEnum)Activator.CreateInstance(Type.GetTypeFromCLSID(DsGuid.CLSID_SystemDeviceEnum));
device.CreateClassEnumerator(ref category, ref enumerator, 0);

if (enumerator == null) return;

var monikers = new IMoniker[1];
var fetched = IntPtr.Zero;

while (enumerator.Next(monikers.Length, monikers, fetched) == 0)
{
var moniker = monikers[0];

object value = null;
Guid guid = DsGuid.IID_IPropertyBag;
moniker.BindToStorage(null, null, ref guid, out value);
var prop = (IPropertyBag)value;

try
{
var rc = func(moniker, prop);
if (rc == true) break;
}
finally
{
Marshal.ReleaseComObject(prop);
if (moniker != null) Marshal.ReleaseComObject(moniker);
}
}
}
finally
{
if (enumerator != null) Marshal.ReleaseComObject(enumerator);
if (device != null) Marshal.ReleaseComObject(device);
}
}

public static IPin FindPin(IBaseFilter filter, string name)
{
var result = EnumPins(filter, (info) =>
{
return (info.achName == name);
});

if (result == null) throw new ArgumentException(\”can\’t fild pin.\”);
return result;
}
public static IPin FindPin(IBaseFilter filter, int index, PIN_DIRECTION direction)
{
int curr_index = 0;
var result = EnumPins(filter, (info) =>
{
if (info.dir != direction) return false;

return (index == curr_index++);
});

if (result == null) throw new ArgumentException(\”can\’t fild pin.\”);
return result;
}

private static IPin EnumPins(IBaseFilter filter, Func<PIN_INFO, bool> func)
{
IEnumPins pins = null;
IPin ipin = null;

try
{
filter.EnumPins(ref pins);

int fetched = 0;
while (pins.Next(1, ref ipin, ref fetched) == 0)
{
if (fetched == 0) break;

return null;
}

public static void ConnectFilter(IGraphBuilder graph, IBaseFilter out_flt, int out_no, IBaseFilter in_flt, int in_no)
{
var out_pin = FindPin(out_flt, out_no, PIN_DIRECTION.PINDIR_OUTPUT);
var inp_pin = FindPin(in_flt, in_no, PIN_DIRECTION.PINDIR_INPUT);
graph.Connect(out_pin, inp_pin);
}

public static void DeleteMediaType(ref AM_MEDIA_TYPE mt)
{
if (mt.lSampleSize != 0) Marshal.FreeCoTaskMem(mt.pbFormat);
if (mt.pUnk != IntPtr.Zero) Marshal.FreeCoTaskMem(mt.pUnk);
mt = null;
}

#endregion

#region Interface

[ComVisible(true), ComImport(), Guid(\”56a8689f-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IFilterGraph
{
int AddFilter([In] IBaseFilter pFilter, [In, MarshalAs(UnmanagedType.LPWStr)] string pName);
int RemoveFilter([In] IBaseFilter pFilter);
int EnumFilters([In, Out] ref IEnumFilters ppEnum);
int FindFilterByName([In, MarshalAs(UnmanagedType.LPWStr)] string pName, [In, Out] ref IBaseFilter ppFilter);
int ConnectDirect([In] IPin ppinOut, [In] IPin ppinIn, [In, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int Reconnect([In] IPin ppin);
int Disconnect([In] IPin ppin);
int SetDefaultSyncSource();
}

[ComVisible(true), ComImport(), Guid(\”56a868a9-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IGraphBuilder : IFilterGraph
{
int Connect([In] IPin ppinOut, [In] IPin ppinIn);
int Render([In] IPin ppinOut);
int RenderFile([In, MarshalAs(UnmanagedType.LPWStr)] string lpcwstrFile, [In, MarshalAs(UnmanagedType.LPWStr)] string lpcwstrPlayList);
int AddSourceFilter([In, MarshalAs(UnmanagedType.LPWStr)] string lpcwstrFileName, [In, MarshalAs(UnmanagedType.LPWStr)] string lpcwstrFilterName, [In, Out] ref IBaseFilter ppFilter);
int SetLogFile(IntPtr hFile);
int Abort();
int ShouldOperationContinue();
}

[ComVisible(true), ComImport(), Guid(\”56a868b1-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsDual)]
public interface IMediaControl
{
int Run();
int Pause();
int Stop();
int GetState(int msTimeout, out int pfs);
int RenderFile(string strFilename);
int AddSourceFilter([In] string strFilename, [In, Out, MarshalAs(UnmanagedType.IDispatch)] ref object ppUnk);
int get_FilterCollection([In, Out, MarshalAs(UnmanagedType.IDispatch)] ref object ppUnk);
int get_RegFilterCollection([In, Out, MarshalAs(UnmanagedType.IDispatch)] ref object ppUnk);
int StopWhenReady();
}

[ComVisible(true), ComImport(), Guid(\”93E5A4E0-2D50-11d2-ABFA-00A0C9C6E38D\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface ICaptureGraphBuilder2
{
int SetFiltergraph([In] IGraphBuilder pfg);
int GetFiltergraph([In, Out] ref IGraphBuilder ppfg);
int SetOutputFileName([In] ref Guid pType, [In, MarshalAs(UnmanagedType.LPWStr)] string lpstrFile, [In, Out] ref IBaseFilter ppbf, [In, Out] ref IFileSinkFilter ppSink);
int FindInterface([In] ref Guid pCategory, [In] ref Guid pType, [In] IBaseFilter pbf, [In] IntPtr riid, [In, Out, MarshalAs(UnmanagedType.IUnknown)] ref object ppint);
int RenderStream([In] ref Guid pCategory, [In] ref Guid pType, [In, MarshalAs(UnmanagedType.IUnknown)] object pSource, [In] IBaseFilter pfCompressor, [In] IBaseFilter pfRenderer);
int ControlStream([In] ref Guid pCategory, [In] ref Guid pType, [In] IBaseFilter pFilter, [In] IntPtr pstart, [In] IntPtr pstop, [In] short wStartCookie, [In] short wStopCookie);
int AllocCapFile([In, MarshalAs(UnmanagedType.LPWStr)] string lpstrFile, [In] long dwlSize);
int CopyCaptureFile([In, MarshalAs(UnmanagedType.LPWStr)] string lpwstrOld, [In, MarshalAs(UnmanagedType.LPWStr)] string lpwstrNew, [In] int fAllowEscAbort, [In] IAMCopyCaptureFileProgress pFilter);
int FindPin([In] object pSource, [In] int pindir, [In] ref Guid pCategory, [In] ref Guid pType, [In, MarshalAs(UnmanagedType.Bool)] bool fUnconnected, [In] int num, [Out] out IntPtr ppPin);
}

[ComVisible(true), ComImport(), Guid(\”a2104830-7c70-11cf-8bce-00aa00a3f1a6\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IFileSinkFilter
{
int SetFileName([In, MarshalAs(UnmanagedType.LPWStr)] string pszFileName, [In, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int GetCurFile([In, Out, MarshalAs(UnmanagedType.LPWStr)] ref string pszFileName, [Out, MarshalAs(UnmanagedType.LPStruct)] out AM_MEDIA_TYPE pmt);
}

[ComVisible(true), ComImport(), Guid(\”670d1d20-a068-11d0-b3f0-00aa003761c5\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IAMCopyCaptureFileProgress
{
int Progress(int iProgress);
}

[ComVisible(true), ComImport(), Guid(\”C6E13370-30AC-11d0-A18C-00A0C9118956\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IAMCameraControl
{
int GetRange([In] CameraControlProperty Property, [In, Out] ref int pMin, [In, Out] ref int pMax, [In, Out] ref int pSteppingDelta, [In, Out] ref int pDefault, [In, Out] ref int pCapsFlag);
int Set([In] CameraControlProperty Property, [In] int lValue, [In] int Flags);
int Get([In] CameraControlProperty Property, [In, Out] ref int lValue, [In, Out] ref int Flags);
}

[ComVisible(true), ComImport(), Guid(\”C6E13360-30AC-11d0-A18C-00A0C9118956\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IAMVideoProcAmp
{
int GetRange([In] VideoProcAmpProperty Property, [In, Out] ref int pMin, [In, Out] ref int pMax, [In, Out] ref int pSteppingDelta, [In, Out] ref int pDefault, [In, Out] ref int pCapsFlag);
int Set([In] VideoProcAmpProperty Property, [In] int lValue, [In] int Flags);
int Get([In] VideoProcAmpProperty Property, [In, Out] ref int lValue, [In, Out] ref int Flags);
}

[ComVisible(true), ComImport(), Guid(\”6A2E0670-28E4-11D0-A18C-00A0C9118956\”), System.Security.SuppressUnmanagedCodeSecurity, InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IAMVideoControl
{
int GetCaps([In] IPin pPin, [Out] out int pCapsFlags);
int SetMode([In] IPin pPin, [In] int Mode);
int GetMode([In] IPin pPin, [Out] out int Mode);
int GetCurrentActualFrameRate([In] IPin pPin, [Out] out long ActualFrameRate);
int GetMaxAvailableFrameRate([In] IPin pPin, [In] int iIndex, [In] Size Dimensions, [Out] out long MaxAvailableFrameRate);
int GetFrameRateList([In] IPin pPin, [In] int iIndex, [In] Size Dimensions, [Out] out int ListSize, [Out] out IntPtr FrameRates);
}

[ComVisible(true), ComImport(), Guid(\”56a86895-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IBaseFilter
{
// Inherits IPersist
int GetClassID([Out] out Guid pClassID);

// Inherits IMediaControl
int Stop();
int Pause();
int Run(long tStart);
int GetState(int dwMilliSecsTimeout, [In, Out] ref int filtState);
int SetSyncSource([In] IReferenceClock pClock);
int GetSyncSource([In, Out] ref IReferenceClock pClock);

// —–
int EnumPins([In, Out] ref IEnumPins ppEnum);
int FindPin([In, MarshalAs(UnmanagedType.LPWStr)] string Id, [In, Out] ref IPin ppPin);
int QueryFilterInfo([Out] FILTER_INFO pInfo);
int JoinFilterGraph([In] IFilterGraph pGraph, [In, MarshalAs(UnmanagedType.LPWStr)] string pName);
int QueryVendorInfo([In, Out, MarshalAs(UnmanagedType.LPWStr)] ref string pVendorInfo);
}

[ComVisible(true), ComImport(), Guid(\”56a86893-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IEnumFilters
{
int Next([In] int cFilters, [In, Out] ref IBaseFilter ppFilter, [In, Out] ref int pcFetched);
int Skip([In] int cFilters);
void Reset();
void Clone([In, Out] ref IEnumFilters ppEnum);
}

[ComVisible(true), ComImport(), Guid(\”C6E13340-30AC-11d0-A18C-00A0C9118956\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IAMStreamConfig
{
int SetFormat([In, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int GetFormat([In, Out, MarshalAs(UnmanagedType.LPStruct)] ref AM_MEDIA_TYPE ppmt);
int GetNumberOfCapabilities(ref int piCount, ref int piSize);
int GetStreamCaps(int iIndex, [In, Out, MarshalAs(UnmanagedType.LPStruct)] ref AM_MEDIA_TYPE ppmt, IntPtr pSCC);
}

[ComVisible(true), ComImport(), Guid(\”56a8689a-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IMediaSample
{
int GetPointer(ref IntPtr ppBuffer);
int GetSize();
int GetTime(ref long pTimeStart, ref long pTimeEnd);
int SetTime([In, MarshalAs(UnmanagedType.LPStruct)] UInt64 pTimeStart, [In, MarshalAs(UnmanagedType.LPStruct)] UInt64 pTimeEnd);
int IsSyncPoint();
int SetSyncPoint([In, MarshalAs(UnmanagedType.Bool)] bool bIsSyncPoint);
int IsPreroll();
int SetPreroll([In, MarshalAs(UnmanagedType.Bool)] bool bIsPreroll);
int GetActualDataLength();
int SetActualDataLength(int len);
int GetMediaType([In, Out, MarshalAs(UnmanagedType.LPStruct)] ref AM_MEDIA_TYPE ppMediaType);
int SetMediaType([In, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pMediaType);
int IsDiscontinuity();
int SetDiscontinuity([In, MarshalAs(UnmanagedType.Bool)] bool bDiscontinuity);
int GetMediaTime(ref long pTimeStart, ref long pTimeEnd);
int SetMediaTime([In, MarshalAs(UnmanagedType.LPStruct)] UInt64 pTimeStart, [In, MarshalAs(UnmanagedType.LPStruct)] UInt64 pTimeEnd);
}

[ComVisible(true), ComImport(), Guid(\”89c31040-846b-11ce-97d3-00aa0055595a\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IEnumMediaTypes
{
int Next([In] int cMediaTypes, [In, Out, MarshalAs(UnmanagedType.LPStruct)] ref AM_MEDIA_TYPE ppMediaTypes, [In, Out] ref int pcFetched);
int Skip([In] int cMediaTypes);
int Reset();
int Clone([In, Out] ref IEnumMediaTypes ppEnum);
}

[ComVisible(true), ComImport(), Guid(\”56a86891-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IPin
{
int Connect([In] IPin pReceivePin, [In, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int ReceiveConnection([In] IPin pReceivePin, [In, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int Disconnect();
int ConnectedTo([In, Out] ref IPin ppPin);
int ConnectionMediaType([Out, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int QueryPinInfo([Out] PIN_INFO pInfo);
int QueryDirection(ref PIN_DIRECTION pPinDir);
int QueryId([In, Out, MarshalAs(UnmanagedType.LPWStr)] ref string Id);
int QueryAccept([In, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int EnumMediaTypes([In, Out] ref IEnumMediaTypes ppEnum);
int QueryInternalConnections(IntPtr apPin, [In, Out] ref int nPin);
int EndOfStream();
int BeginFlush();
int EndFlush();
int NewSegment(long tStart, long tStop, double dRate);
}

[ComVisible(true), ComImport(), Guid(\”56a86892-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IEnumPins
{
int Next([In] int cPins, [In, Out] ref IPin ppPins, [In, Out] ref int pcFetched);
int Skip([In] int cPins);
void Reset();
void Clone([In, Out] ref IEnumPins ppEnum);
}

[ComVisible(true), ComImport(), Guid(\”56a86897-0ad4-11ce-b03a-0020af0ba770\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IReferenceClock
{
int GetTime(ref long pTime);
int AdviseTime(long baseTime, long streamTime, IntPtr hEvent, ref int pdwAdviseCookie);
int AdvisePeriodic(long startTime, long periodTime, IntPtr hSemaphore, ref int pdwAdviseCookie);
int Unadvise(int dwAdviseCookie);
}

[ComVisible(true), ComImport(), Guid(\”29840822-5B84-11D0-BD3B-00A0C911CE86\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface ICreateDevEnum
{
int CreateClassEnumerator([In] ref Guid pType, [In, Out] ref System.Runtime.InteropServices.ComTypes.IEnumMoniker ppEnumMoniker, [In] int dwFlags);
}

[ComVisible(true), ComImport(), Guid(\”55272A00-42CB-11CE-8135-00AA004BB851\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IPropertyBag
{
int Read([MarshalAs(UnmanagedType.LPWStr)] string PropName, ref object Var, int ErrorLog);
int Write(string PropName, ref object Var);
}

[ComVisible(true), ComImport(), Guid(\”6B652FFF-11FE-4fce-92AD-0266B5D7C78F\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface ISampleGrabber
{
int SetOneShot([In, MarshalAs(UnmanagedType.Bool)] bool OneShot);
int SetMediaType([In, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int GetConnectedMediaType([Out, MarshalAs(UnmanagedType.LPStruct)] AM_MEDIA_TYPE pmt);
int SetBufferSamples([In, MarshalAs(UnmanagedType.Bool)] bool BufferThem);
int GetCurrentBuffer(ref int pBufferSize, IntPtr pBuffer);
int GetCurrentSample(IntPtr ppSample);
int SetCallback(ISampleGrabberCB pCallback, int WhichMethodToCallback);
}

[ComVisible(true), ComImport(), Guid(\”0579154A-2B53-4994-B0D0-E773148EFF85\”), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface ISampleGrabberCB
{
[PreserveSig()]
int SampleCB(double SampleTime, IMediaSample pSample);
[PreserveSig()]
int BufferCB(double SampleTime, IntPtr pBuffer, int BufferLen);
}

#endregion

#region Structure

[Serializable]
[StructLayout(LayoutKind.Sequential), ComVisible(false)]
public class AM_MEDIA_TYPE
{
public Guid MajorType;
public Guid SubType;
[MarshalAs(UnmanagedType.Bool)]
public bool bFixedSizeSamples;
[MarshalAs(UnmanagedType.Bool)]
public bool bTemporalCompression;
public uint lSampleSize;
public Guid FormatType;
public IntPtr pUnk;
public uint cbFormat;
public IntPtr pbFormat;
}

[Serializable]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode), ComVisible(false)]
public class FILTER_INFO
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public string achName;
[MarshalAs(UnmanagedType.IUnknown)]
public object pGraph;
}

[Serializable]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode), ComVisible(false)]
public class PIN_INFO
{
public IBaseFilter pFilter;
public PIN_DIRECTION dir;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public string achName;
}

[Serializable]
[StructLayout(LayoutKind.Sequential, Pack = 8), ComVisible(false)]
public struct VIDEO_STREAM_CONFIG_CAPS
{
public Guid Guid;
public uint VideoStandard;
public SIZE InputSize;
public SIZE MinCroppingSize;
public SIZE MaxCroppingSize;
public int CropGranularityX;
public int CropGranularityY;
public int CropAlignX;
public int CropAlignY;
public SIZE MinOutputSize;
public SIZE MaxOutputSize;
public int OutputGranularityX;
public int OutputGranularityY;
public int StretchTapsX;
public int StretchTapsY;
public int ShrinkTapsX;
public int ShrinkTapsY;
public long MinFrameInterval;
public long MaxFrameInterval;
public int MinBitsPerSecond;
public int MaxBitsPerSecond;
}

[Serializable]
[StructLayout(LayoutKind.Sequential), ComVisible(false)]
public struct VIDEOINFOHEADER
{
public RECT SrcRect;
public RECT TrgRect;
public int BitRate;
public int BitErrorRate;
public long AvgTimePerFrame;
public BITMAPINFOHEADER bmiHeader;
}

[Serializable]
[StructLayout(LayoutKind.Sequential), ComVisible(false)]
public struct VIDEOINFOHEADER2
{
public RECT SrcRect;
public RECT TrgRect;
public int BitRate;
public int BitErrorRate;
public long AvgTimePerFrame;
public int InterlaceFlags;
public int CopyProtectFlags;
public int PictAspectRatioX;
public int PictAspectRatioY;
public int ControlFlags; // or Reserved1
public int Reserved2;
public BITMAPINFOHEADER bmiHeader;
}

[Serializable]
[StructLayout(LayoutKind.Sequential, Pack = 2), ComVisible(false)]
public struct BITMAPINFOHEADER
{
public int biSize;
public int biWidth;
public int biHeight;
public short biPlanes;
public short biBitCount;
public int biCompression;
public int biSizeImage;
public int biXPelsPerMeter;
public int biYPelsPerMeter;
public int biClrUsed;
public int biClrImportant;
}

[Serializable]
[StructLayout(LayoutKind.Sequential), ComVisible(false)]
public struct WAVEFORMATEX
{
public ushort wFormatTag;
public ushort nChannels;
public uint nSamplesPerSec;
public uint nAvgBytesPerSec;
public short nBlockAlign;
public short wBitsPerSample;
public short cbSize;
}

[Serializable]
[StructLayout(LayoutKind.Sequential, Pack = 8), ComVisible(false)]
public struct SIZE
{
public int cx;
public int cy;
public override string ToString() { return string.Format(\”{{{0}, {1}}}\”, cx, cy); } // for debugging.
}

[Serializable]
[StructLayout(LayoutKind.Sequential), ComVisible(false)]
public struct RECT
{
public int Left;
public int Top;
public int Right;
public int Bottom;
public override string ToString() { return string.Format(\”{{{0}, {1}, {2}, {3}}}\”, Left, Top, Right, Bottom); } // for debugging.
}
#endregion

#region Enum

[ComVisible(false)]
public enum PIN_DIRECTION
{
PINDIR_INPUT = 0,
PINDIR_OUTPUT = 1,
}

[ComVisible(false)]
public enum FILTER_STATE : int
{
Stopped = 0,
Paused = 1,
Running = 2,
}

[ComVisible(false)]
public enum CameraControlProperty
{
Pan = 0,
Tilt = 1,
Roll = 2,
Zoom = 3,
Exposure = 4,
Iris = 5,
Focus = 6,
}

[ComVisible(false), Flags()]
public enum CameraControlFlags
{
Auto = 0x0001,
Manual = 0x0002,
}

[ComVisible(false)]
public enum VideoProcAmpProperty
{
Brightness = 0,
Contrast = 1,
Hue = 2,
Saturation = 3,
Sharpness = 4,
Gamma = 5,
ColorEnable = 6,
WhiteBalance = 7,
BacklightCompensation = 8,
Gain = 9
}

#endregion

#region Guid

public static class DsGuid
{
// MediaType
public static readonly Guid MEDIATYPE_Video = new Guid(\”{73646976-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIATYPE_Audio = new Guid(\”{73647561-0000-0010-8000-00AA00389B71}\”);

// SubType
public static readonly Guid MEDIASUBTYPE_None = new Guid(\”{E436EB8E-524F-11CE-9F53-0020AF0BA770}\”);
public static readonly Guid MEDIASUBTYPE_YUYV = new Guid(\”{56595559-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIASUBTYPE_IYUV = new Guid(\”{56555949-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIASUBTYPE_YVU9 = new Guid(\”{39555659-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIASUBTYPE_YUY2 = new Guid(\”{32595559-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIASUBTYPE_YVYU = new Guid(\”{55595659-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIASUBTYPE_UYVY = new Guid(\”{59565955-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIASUBTYPE_MJPG = new Guid(\”{47504A4D-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIASUBTYPE_RGB565 = new Guid(\”{E436EB7B-524F-11CE-9F53-0020AF0BA770}\”);
public static readonly Guid MEDIASUBTYPE_RGB555 = new Guid(\”{E436EB7C-524F-11CE-9F53-0020AF0BA770}\”);
public static readonly Guid MEDIASUBTYPE_RGB24 = new Guid(\”{E436EB7D-524F-11CE-9F53-0020AF0BA770}\”);
public static readonly Guid MEDIASUBTYPE_RGB32 = new Guid(\”{E436EB7E-524F-11CE-9F53-0020AF0BA770}\”);
public static readonly Guid MEDIASUBTYPE_ARGB32 = new Guid(\”{773C9AC0-3274-11D0-B724-00AA006C1A01}\”);
public static readonly Guid MEDIASUBTYPE_PCM = new Guid(\”{00000001-0000-0010-8000-00AA00389B71}\”);
public static readonly Guid MEDIASUBTYPE_WAVE = new Guid(\”{E436EB8B-524F-11CE-9F53-0020AF0BA770}\”);

// FormatType
public static readonly Guid FORMAT_None = new Guid(\”{0F6417D6-C318-11D0-A43F-00A0C9223196}\”);
public static readonly Guid FORMAT_VideoInfo = new Guid(\”{05589F80-C356-11CE-BF01-00AA0055595A}\”);
public static readonly Guid FORMAT_VideoInfo2 = new Guid(\”{F72A76A0-EB0A-11d0-ACE4-0000C0CC16BA}\”);
public static readonly Guid FORMAT_WaveFormatEx = new Guid(\”{05589F81-C356-11CE-BF01-00AA0055595A}\”);

// CLSID
public static readonly Guid CLSID_AudioInputDeviceCategory = new Guid(\”{33D9A762-90C8-11d0-BD43-00A0C911CE86}\”);
public static readonly Guid CLSID_AudioRendererCategory = new Guid(\”{E0F158E1-CB04-11d0-BD4E-00A0C911CE86}\”);
public static readonly Guid CLSID_VideoInputDeviceCategory = new Guid(\”{860BB310-5D01-11d0-BD3B-00A0C911CE86}\”);
public static readonly Guid CLSID_VideoCompressorCategory = new Guid(\”{33D9A760-90C8-11d0-BD43-00A0C911CE86}\”);

public static readonly Guid CLSID_NullRenderer = new Guid(\”{C1F400A4-3F08-11D3-9F0B-006008039E37}\”);
public static readonly Guid CLSID_SampleGrabber = new Guid(\”{C1F400A0-3F08-11D3-9F0B-006008039E37}\”);

public static readonly Guid CLSID_FilterGraph = new Guid(\”{E436EBB3-524F-11CE-9F53-0020AF0BA770}\”);
public static readonly Guid CLSID_SystemDeviceEnum = new Guid(\”{62BE5D10-60EB-11d0-BD3B-00A0C911CE86}\”);
public static readonly Guid CLSID_CaptureGraphBuilder2 = new Guid(\”{BF87B6E1-8C27-11d0-B3F0-00AA003761C5}\”);

public static readonly Guid IID_IPropertyBag = new Guid(\”{55272A00-42CB-11CE-8135-00AA004BB851}\”);
public static readonly Guid IID_IBaseFilter = new Guid(\”{56a86895-0ad4-11ce-b03a-0020af0ba770}\”);
public static readonly Guid IID_IAMStreamConfig = new Guid(\”{C6E13340-30AC-11d0-A18C-00A0C9118956}\”);

public static readonly Guid PIN_CATEGORY_CAPTURE = new Guid(\”{fb6c4281-0353-11d1-905f-0000c0cc16ba}\”);
public static readonly Guid PIN_CATEGORY_PREVIEW = new Guid(\”{fb6c4282-0353-11d1-905f-0000c0cc16ba}\”);
public static readonly Guid PIN_CATEGORY_STILL = new Guid(\”{fb6c428a-0353-11d1-905f-0000c0cc16ba}\”);

private static Dictionary<Guid, string> NicknameCache = null;

public static string GetNickname(Guid guid)
{
if (NicknameCache == null)
{
NicknameCache = typeof(DsGuid).GetFields(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)
.Where(x => x.FieldType == typeof(Guid))
.ToDictionary(x => (Guid)x.GetValue(null), x => x.Name);
}

if (NicknameCache.ContainsKey(guid))
{
var name = NicknameCache[guid];
var elem = name.Split(\’_\’);

if (elem.Length >= 2)
{
var text = string.Join(\”_\”, elem.Skip(1).ToArray());
return string.Format(\”[{0}]\”, text);
}
else
{
return name;
}
}

return guid.ToString();
}
}
#endregion
}
}

使用非常简单：

//获取所有的摄像头
string[] devices = UsbCamera.FindDevices();

//获取摄像头支持的分辨率
int cameraIndex = 0;
UsbCamera.VideoFormat[] formats = UsbCamera.GetVideoFormat(cameraIndex);
for (int i = 0; i < formats.Length; i++)
Console.WriteLine(\”{0}:{1}\”, i, formats[i]);

// create usb camera and start.
using var camera = new UsbCamera(cameraIndex, formats[0]);
camera.Start();

//第一次截图不延迟的话，会出现黑屏
await Task.Delay(100);
var bmp = camera.GetBitmap();
bmp.Save(@$\”r:\\test.jpg\”);

这个代码本身也是封装了direct show，但它只封装了摄像头相关的部分，只有1k多行，可以直接嵌入到项目中。另外，这个截图本身不依赖于STA线程的，可以非常方便的封装成一个远程usb拍照的功能的，也可以供web使用。如果不太要求效果的话，做个远程的摄像头也是可以的。

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对悠久资源网的支持。如果你想了解更多相关内容请查看下面相关链接

您可能感兴趣的文章: