C#.net编写摄像头驱动程序，用avicap32.dll

装了摄像头后一般会有 avicap32.dll文件，没有一样可以用这些代码。

不需要在解决方案里面引用这个.dll文件。

下面有二种写法的例子：

例一：

 

using  System;
using  System.Runtime.InteropServices;
using  System.Drawing;
using  System.Drawing.Imaging;

namespace  WinVideo
... {
    /**//// <summary>
    /// webcam 的摘要说明。
    /// </summary>
    public class webcam
    ...{
        private const int WM_USER=0x400;
        private const int WS_CHILD=0x40000000;
        private const int WS_VISIBLE=0x10000000;
        private const int WM_CAP_START=WM_USER;
        private const int WM_CAP_STOP=WM_CAP_START + 68;
        private const int WM_CAP_DRIVER_CONNECT=WM_CAP_START + 10;
        private const int WM_CAP_DRIVER_DISCONNECT=WM_CAP_START + 11;
        private const int WM_CAP_SAVEDIB=WM_CAP_START + 25;
        private const int WM_CAP_GRAB_FRAME=WM_CAP_START + 60;
        private const int WM_CAP_SEQUENCE=WM_CAP_START + 62;
        private const int WM_CAP_FILE_SET_CAPTURE_FILEA=WM_CAP_START + 20;
        private const int WM_CAP_SEQUENCE_NOFILE=WM_CAP_START+ 63;
        private const int WM_CAP_SET_OVERLAY=WM_CAP_START+ 51;
        private const int WM_CAP_SET_PREVIEW=WM_CAP_START+ 50;
        private const int WM_CAP_SET_CALLBACK_VIDEOSTREAM=WM_CAP_START +6;
        private const int WM_CAP_SET_CALLBACK_ERROR=WM_CAP_START +2;
        private const int WM_CAP_SET_CALLBACK_STATUSA=WM_CAP_START +3;
        private const int WM_CAP_SET_CALLBACK_FRAME=WM_CAP_START +5;
        private const int WM_CAP_SET_SCALE=WM_CAP_START+ 53;
        private const int WM_CAP_SET_PREVIEWRATE=WM_CAP_START+ 52;
        private IntPtr hWndC;
        private bool bStat = false;

        private IntPtr mControlPtr;
        private int mWidth;
        private int mHeight;
        private int mLeft;
        private int mTop;
        private string GrabImagePath="";
        private string KinescopePath="";

        /**//// <summary>
        /// 初始化摄像头
        /// </summary>
        /// <param name="handle">控件的句柄</param>
        /// <param name="left">开始显示的左边距</param>
        /// <param name="top">开始显示的上边距</param>
        /// <param name="width">要显示的宽度</param>
        /// <param name="height">要显示的长度</param>
        public webcam(IntPtr handle,int left,int top,int width,int height)
        ...{
            mControlPtr=handle;
            mWidth=width;
            mHeight=height;
            mLeft=left;
            mTop=top;
        }
        "属性设置"#region "属性设置"
        /**//// <summary>
        /// 视频左边距
        /// </summary>
        public int Left
        ...{
            get ...{return mLeft;}
            set ...{mLeft=value;}
        }

        /**//// <summary>
        /// 视频上边距
        /// </summary>
        public int Top
        ...{
            get ...{return mTop;}
            set ...{mTop=value;}
        }

        /**//// <summary>
        /// 视频宽度
        /// </summary>
        public int Width
        ...{
            get ...{return mWidth;}
            set ...{mWidth=value;}
        }

        /**//// <summary>
        /// 视频高度
        /// </summary>
        public int Height
        ...{
            get ...{return mHeight;}
            set ...{mHeight=value;}
        }

        /**//// <summary>
        /// 抓图文件存放路径
        /// 例：d:/a.bmp
        /// </summary>
        public string grabImagePath
        ...{
            get ...{return GrabImagePath;}
            set ...{GrabImagePath=value;}
        }

        /**//// <summary>
        /// 录像文件存放路径
        /// 例：d:/a.avi
        /// </summary>
        public string kinescopePath
        ...{
            get ...{return KinescopePath;}
            set ...{KinescopePath=value;}
        }
        #endregion

        [DllImport("avicap32.dll")]
        private static extern IntPtr capCreateCaptureWindowA(byte[] lpszWindowName,int dwStyle,int x,int y,int nWidth,int nHeight,IntPtr hWndParent,int nID);

        [DllImport("avicap32.dll")]
        private static extern int capGetVideoFormat(IntPtr hWnd,IntPtr psVideoFormat,int wSize );
        [DllImport("User32.dll")]
        private static extern bool SendMessage(IntPtr hWnd,int wMsg,int wParam,long lParam);

        /**//// <summary>
        /// 开始显示图像
        /// </summary>
        public void Start()
        ...{
            if(bStat)
                return;

            bStat=true;
            byte[] lpszName=new byte[100];

            hWndC=capCreateCaptureWindowA(lpszName,WS_CHILD|WS_VISIBLE ,mLeft,mTop,mWidth,mHeight,mControlPtr,0);

            if (hWndC.ToInt32()!=0)
            ...{
                SendMessage(hWndC,WM_CAP_SET_CALLBACK_VIDEOSTREAM,0,0);
                SendMessage(hWndC,WM_CAP_SET_CALLBACK_ERROR,0,0);
                SendMessage(hWndC,WM_CAP_SET_CALLBACK_STATUSA,0,0);
                SendMessage(hWndC,WM_CAP_DRIVER_CONNECT,0,0);
                SendMessage(hWndC,WM_CAP_SET_SCALE,1,0);
                SendMessage(hWndC,WM_CAP_SET_PREVIEWRATE,66,0);
                SendMessage(hWndC,WM_CAP_SET_OVERLAY,1,0);
                SendMessage(hWndC,WM_CAP_SET_PREVIEW,1,0);
            }
            return;
        }

        /**//// <summary>
        /// 停止显示
        /// </summary>
        public void Stop()
        ...{
            SendMessage(hWndC,WM_CAP_DRIVER_DISCONNECT,0,0);
            bStat=false;
        }

        /**//// <summary>
        /// 抓图
        /// </summary>
        /// <param name="path">要保存bmp文件的路径</param>
        public void GrabImage()
        ...{
            IntPtr hBmp=Marshal.StringToHGlobalAnsi(GrabImagePath);
            SendMessage(hWndC,WM_CAP_SAVEDIB,0,hBmp.ToInt64());

        }

        /**//// <summary>
        /// 录像
        /// </summary>
        /// <param name="path">要保存avi文件的路径</param>
        public void Kinescope()
        ...{
            IntPtr hBmp=Marshal.StringToHGlobalAnsi(KinescopePath);
            SendMessage(hWndC,WM_CAP_FILE_SET_CAPTURE_FILEA,0,hBmp.ToInt64());
            SendMessage(hWndC,WM_CAP_SEQUENCE,0,0);
        }

        /**//// <summary>
        /// 停止录像
        /// </summary>
        public void StopKinescope()
        ...{
            SendMessage(hWndC,WM_CAP_STOP,0,0);
        }
    }
}

对该类的调用：

 

         public  webcam wcam = null ;
         private   void  Form1_Load( object  sender, System.EventArgs e)
         ... {    
            start();
            this.btnKinescopeStop.Enabled=false;
        }

         private   void  btnStar_Click( object  sender, System.EventArgs e)
         ... {        
            wcam.Start();
        }

         private   void  btnStop_Click( object  sender, System.EventArgs e)
         ... {
            wcam.Stop();
        }

         private   void  btnSnapPic_Click( object  sender, System.EventArgs e)
         ... {
            //得到路径。例：d:/a.bmp
            string myPath=this.txtPath.Text;
            if(myPath=="")
            ...{
                MessageBox.Show("必须填写路径！");
                return;
            }
            else
            ...{
                wcam.grabImagePath=myPath;
                wcam.GrabImage();
                MessageBox.Show("截图成功！");
            }
        }
         public   void  start()
         ... {
            //以panel1为容器显示视频内容
            wcam=new webcam(panel1.Handle,0,0,this.panel1.Width,this.panel1.Height);        
            wcam.Start();
        }

         private   void  panel1_SizeChanged( object  sender, System.EventArgs e)
         ... {
            wcam.Stop();
            wcam.Height=this.panel1.Height;
            wcam.Width=this.panel1.Width;
            wcam.Start();
        }
        
         private   delegate   void  delegateKinescope();
         private   void  btnKinescopeBegin_Click( object  sender, System.EventArgs e)
         ... {
            //得到路径。例：d:/a.avi
            string myPath=this.txtPath.Text;
            if(myPath=="")
            ...{
                MessageBox.Show("必须填写路径！");
                return;
            }
            else
            ...{
                wcam.kinescopePath=myPath;
                delegateKinescope myK=new delegateKinescope(wcam.Kinescope);
                Thread threadKinescope=new Thread(new ThreadStart(myK));
                threadKinescope.Start();
                this.btnKinescopeBegin.Enabled=false;
                this.btnKinescopeStop.Enabled=true;
            }        
        }
         public   void  starKinescope()
         ... {
            delegateKinescope myK=new delegateKinescope(wcam.Kinescope);
        }

         private   void  btnKinescopeStop_Click( object  sender, System.EventArgs e)
         ... {
            wcam.StopKinescope();
            this.btnKinescopeBegin.Enabled=true;
            this.btnKinescopeStop.Enabled=false;            
        }

例二：

 

using  System;
using  System.Runtime.InteropServices;

namespace  webcam
... {
    /**//**//**//// 
    /// avicap 的摘要说明。
    /// 
    public class showVideo
    ...{
        // showVideo calls
        [DllImport("avicap32.dll")] public static extern IntPtr capCreateCaptureWindowA(byte[] lpszWindowName, int dwStyle, int x, int y, int nWidth, int nHeight, IntPtr hWndParent, int nID);
        [DllImport("avicap32.dll")] public static extern bool capGetDriverDescriptionA(short wDriver, byte[] lpszName, int cbName, byte[] lpszVer, int cbVer);
        [DllImport("User32.dll")] public static extern bool SendMessage(IntPtr hWnd, int wMsg, bool wParam, int lParam); 
        [DllImport("User32.dll")] public static extern bool SendMessage(IntPtr hWnd, int wMsg, short wParam, int lParam); 
        [DllImport("User32.dll")] public static extern bool SendMessage(IntPtr hWnd, int wMsg, short wParam, FrameEventHandler lParam); 
        [DllImport("User32.dll")] public static extern bool SendMessage(IntPtr hWnd, int wMsg, int wParam, ref BITMAPINFO lParam);
        [DllImport("User32.dll")] public static extern int SetWindowPos(IntPtr hWnd, int hWndInsertAfter, int x, int y, int cx, int cy, int wFlags);
        [DllImport("avicap32.dll")]public static extern int capGetVideoFormat(IntPtr hWnd, IntPtr psVideoFormat, int wSize );

        // Constants
        public const int WM_USER = 0x400;
        public const int WS_CHILD = 0x40000000;
        public const int WS_VISIBLE = 0x10000000;
        public const int SWP_NOMOVE = 0x2;
        public const int SWP_NOZORDER = 0x4;
        public const int WM_CAP_DRIVER_CONNECT = WM_USER + 10;
        public const int WM_CAP_DRIVER_DISCONNECT = WM_USER + 11;
        public const int WM_CAP_SET_CALLBACK_FRAME = WM_USER + 5;
        public const int WM_CAP_SET_PREVIEW = WM_USER + 50;
        public const int WM_CAP_SET_PREVIEWRATE = WM_USER + 52;
        public const int WM_CAP_SET_VIDEOFORMAT = WM_USER + 45;
 
        // Structures
        [StructLayout(LayoutKind.Sequential)] public struct VIDEOHDR
        ...{
            [MarshalAs(UnmanagedType.I4)] public int lpData;
            [MarshalAs(UnmanagedType.I4)] public int dwBufferLength;
            [MarshalAs(UnmanagedType.I4)] public int dwBytesUsed;
            [MarshalAs(UnmanagedType.I4)] public int dwTimeCaptured;
            [MarshalAs(UnmanagedType.I4)] public int dwUser;
            [MarshalAs(UnmanagedType.I4)] public int dwFlags;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst=4)] public int[] dwReserved;
        }

        [StructLayout(LayoutKind.Sequential)] public struct BITMAPINFOHEADER
        ...{
            [MarshalAs(UnmanagedType.I4)] public Int32 biSize ;
            [MarshalAs(UnmanagedType.I4)] public Int32 biWidth ;
            [MarshalAs(UnmanagedType.I4)] public Int32 biHeight ;
            [MarshalAs(UnmanagedType.I2)] public short biPlanes;
            [MarshalAs(UnmanagedType.I2)] public short biBitCount ;
            [MarshalAs(UnmanagedType.I4)] public Int32 biCompression;
            [MarshalAs(UnmanagedType.I4)] public Int32 biSizeImage;
            [MarshalAs(UnmanagedType.I4)] public Int32 biXPelsPerMeter;
            [MarshalAs(UnmanagedType.I4)] public Int32 biYPelsPerMeter;
            [MarshalAs(UnmanagedType.I4)] public Int32 biClrUsed;
            [MarshalAs(UnmanagedType.I4)] public Int32 biClrImportant;
        } 

        [StructLayout(LayoutKind.Sequential)] public struct BITMAPINFO
        ...{
            [MarshalAs(UnmanagedType.Struct, SizeConst=40)] public BITMAPINFOHEADER bmiHeader;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst=1024)] public Int32[] bmiColors;
        }
 
        public delegate void FrameEventHandler(IntPtr lwnd, IntPtr lpVHdr);
 
        // Public methods
        public static object GetStructure(IntPtr ptr,ValueType structure)
        ...{
            return Marshal.PtrToStructure(ptr,structure.GetType());
        }
 
        public static object GetStructure(int ptr,ValueType structure)
        ...{
            return GetStructure(new IntPtr(ptr),structure);
        }
 
        public static void Copy(IntPtr ptr,byte[] data)
        ...{
            Marshal.Copy(ptr,data,0,data.Length);
        }
 
        public static void Copy(int ptr,byte[] data)
        ...{
            Copy(new IntPtr(ptr),data);
        }
 
        public static int SizeOf(object structure)
        ...{
            return Marshal.SizeOf(structure); 
        }
    }

    //Web Camera Class
    public class WebCamera
    ...{
        // Constructur
        public WebCamera(IntPtr handle, int width,int height)
        ...{
            mControlPtr = handle;
            mWidth = width;
            mHeight = height;
        } 
        // delegate for frame callback
        public delegate void RecievedFrameEventHandler(byte[] data);
        public event RecievedFrameEventHandler RecievedFrame;
 
        private IntPtr lwndC; // Holds the unmanaged handle of the control
        private IntPtr mControlPtr; // Holds the managed pointer of the control
        private int mWidth;
        private int mHeight;
 
        private showVideo.FrameEventHandler mFrameEventHandler; // Delegate instance for the frame callback - must keep alive! gc should NOT collect it
        // Close the web camera
        public void CloseWebcam()
        ...{
            this.capDriverDisconnect(this.lwndC);
        }
 
        // start the web camera
        public void StartWebCam()
        ...{
            byte[] lpszName = new byte[100];
            byte[] lpszVer = new byte[100];
 
            showVideo.capGetDriverDescriptionA(0, lpszName, 100,lpszVer, 100);
            this.lwndC = showVideo.capCreateCaptureWindowA(lpszName, showVideo.WS_VISIBLE + showVideo.WS_CHILD, 0, 0, mWidth, mHeight, mControlPtr, 0);
 
            if (this.capDriverConnect(this.lwndC, 0))
            ...{
                this.capPreviewRate(this.lwndC, 66);
                this.capPreview(this.lwndC, true);
                showVideo.BITMAPINFO bitmapinfo = new showVideo.BITMAPINFO(); 
                bitmapinfo.bmiHeader.biSize = showVideo.SizeOf(bitmapinfo.bmiHeader);
                bitmapinfo.bmiHeader.biWidth = 352;
                bitmapinfo.bmiHeader.biHeight = 288;
                bitmapinfo.bmiHeader.biPlanes = 1;
                bitmapinfo.bmiHeader.biBitCount = 24;
                this.capSetVideoFormat(this.lwndC, ref bitmapinfo, showVideo.SizeOf(bitmapinfo));
                this.mFrameEventHandler = new showVideo.FrameEventHandler(FrameCallBack);
                this.capSetCallbackOnFrame(this.lwndC, this.mFrameEventHandler);
                showVideo.SetWindowPos(this.lwndC, 0, 0, 0, mWidth , mHeight , 6);
            } 
        }

        // private functions
        private bool capDriverConnect(IntPtr lwnd, short i)
        ...{
            return showVideo.SendMessage(lwnd, showVideo.WM_CAP_DRIVER_CONNECT, i, 0);
        }
        private bool capDriverDisconnect(IntPtr lwnd)
        ...{
            return showVideo.SendMessage(lwnd, showVideo.WM_CAP_DRIVER_DISCONNECT, 0, 0);
        }
        private bool capPreview(IntPtr lwnd, bool f)
        ...{return showVideo.SendMessage(lwnd, showVideo.WM_CAP_SET_PREVIEW , f, 0);}

        private bool capPreviewRate(IntPtr lwnd, short wMS)
        ...{
            return showVideo.SendMessage(lwnd, showVideo.WM_CAP_SET_PREVIEWRATE, wMS, 0);
        }
 
        private bool capSetCallbackOnFrame(IntPtr lwnd, showVideo.FrameEventHandler lpProc)
        ...{
            return showVideo.SendMessage(lwnd, showVideo.WM_CAP_SET_CALLBACK_FRAME, 0, lpProc);
        }

        private bool capSetVideoFormat(IntPtr hCapWnd, ref showVideo.BITMAPINFO BmpFormat, int CapFormatSize)
        ...{
            return showVideo.SendMessage(hCapWnd, showVideo.WM_CAP_SET_VIDEOFORMAT, CapFormatSize, ref BmpFormat);
        }

        private void FrameCallBack(IntPtr lwnd, IntPtr lpVHdr)
        ...{
            showVideo.VIDEOHDR videoHeader = new showVideo.VIDEOHDR();
            byte[] VideoData;
            videoHeader = (showVideo.VIDEOHDR)showVideo.GetStructure(lpVHdr,videoHeader);
            VideoData = new byte[videoHeader.dwBytesUsed];
            showVideo.Copy(videoHeader.lpData ,VideoData);
            if (this.RecievedFrame != null)
                this.RecievedFrame (VideoData);
        }
    }

}

调用代码：

 

        WebCamera wc;

         private   void  Form1_Load( object  sender, System.EventArgs e)
         ... {
            b_play.Enabled = false;
            b_stop.Enabled = true;
            panelPreview.Size = new Size(330,330);
            wc = new WebCamera( panelPreview.Handle,panelPreview.Width,panelPreview.Height);
            wc.StartWebCam();
        }

         private   void  button1_Click( object  sender, System.EventArgs e)
         ... {
            b_play.Enabled = false;
            b_stop.Enabled = true;
            panelPreview.Size = new Size(330,330);
            wc = new WebCamera( panelPreview.Handle,panelPreview.Width,panelPreview.Height);
            wc.StartWebCam();
        }

         private   void  b_stop_Click( object  sender, System.EventArgs e)
         ... {
            b_play.Enabled = true;
            b_stop.Enabled = false;
            wc.CloseWebcam();
        }