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.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.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.");
    }

    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 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;

var info = new PIN_INFO();
try
{
    ipin.QueryPinInfo(info);
    var rc = func(info);
    if (rc) return ipin;
}
finally
{
    if (info.pFilter != null) Marshal.ReleaseComObject(info.pFilter);
}
    }
}
catch
{
    if (ipin != null) Marshal.ReleaseComObject(ipin);
    throw;
}
finally
{
    if (pins != null) Marshal.ReleaseComObject(pins);
}

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使用。 如果不太要求效果的话，做个远程的摄像头也是可以的。

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