Another class to control the camera

Here is another class to control your PC camera.It also uses the "avicap32.dll" and "User32.dll". 

You can use this class to do something

This article assumes you are familiar with C#.

showVideo.cs:

 

using  System;
using  System.Runtime.InteropServices;
using  System.Collections.Generic;
using  System.Text;

namespace  CameraCapture
... {
    /**//// 
    /// 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_START = WM_USER;
        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_CALLBACK_VIDEOSTREAM = WM_CAP_START + 6;
        public const int WM_CAP_SET_CALLBACK_ERROR = WM_CAP_START + 2;
        public const int WM_CAP_SET_CALLBACK_STATUSA = WM_CAP_START + 3;
        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;
        public const int WM_CAP_SAVEDIB = WM_CAP_START + 25;
        public const int WM_CAP_SET_SCALE = WM_CAP_START + 53;
        public const int WM_CAP_SET_OVERLAY = WM_CAP_START + 51;

       

        // 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);
        }
        
    }

}

 

Nasky