public   class  WebCameraEngine
    {
         //   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  WM_CAP_DRIVER_CONNECT  =  WM_USER  +   10 ;
         public   const   int  WM_CAP_DRIVER_DISCONNECT  =  WM_USER  +   11 ;

public   const   int  WM_CAP_START  =  WM_USER;
         public   const   int  WM_CAP_STOP  =  WM_CAP_START  +   68 ;

public   const   int  WM_CAP_SAVEDIB  =  WM_CAP_START  +   25 ;
         public   const   int  WM_CAP_GRAB_FRAME  =  WM_CAP_START  +   60 ;
         public   const   int  WM_CAP_FILE_SET_CAPTURE_FILEA  =  WM_CAP_START  +   20 ;
         public   const   int  WM_CAP_SEQUENCE  =  WM_CAP_START  +   62 ;
         public   const   int  WM_CAP_SEQUENCE_NOFILE  =  WM_CAP_START  +   63 ;

public   const   int  WM_CAP_SET_OVERLAY  =  WM_CAP_START  +   51 ;
         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_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_SCALE  =  WM_CAP_START  +   53 ;
         public   const   int  WM_CAP_SET_VIDEOFORMAT  =  WM_USER  +   45 ;

public   const   int  SWP_NOMOVE  =   0x2 ;
         public   const   int  SWP_NOZORDER  =   0x4 ;

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

hWndC  =  capCreateCaptureWindow (
    (LPSTR)  " My Capture Window " ,  //  window name if pop-up 
    WS_CHILD  |  WS_VISIBLE,        //  window style 
     0 ,  0 ,  160 ,  120 ,               //  window position and dimensions
    (HWND) hwndParent, 
    ( int ) nID  /*  child ID *

fOK  =  SendMessage (hWndC, WM_CAP_DRIVER_CONNECT,  0 ,  0L ); 
//  
//  Or, use the macro to connect to the MSVIDEO driver: 
//  fOK = capDriverConnect(hWndC, 0); 
//  
//  Place code to set up and capture video here. 
//  
capDriverDisconnect (hWndC); 

CAPDRIVERCAPS CapDrvCaps;

SendMessage (hWndC, WM_CAP_DRIVER_GET_CAPS, 
     sizeof  (CAPDRIVERCAPS), (LONG) (LPVOID)  & CapDrvCaps);

//  Or, use the macro to retrieve the driver capabilities. 
//  capDriverGetCaps(hWndC, &CapDrvCaps, sizeof (CAPDRIVERCAPS));

WAVEFORMATEX wfex;

wfex.wFormatTag  =  WAVE_FORMAT_PCM;
wfex.nChannels  =   2 ;                 //  Use stereo
wfex.nSamplesPerSec  =   11025 ;
wfex.nAvgBytesPerSec  =   22050 ;
wfex.nBlockAlign  =   2 ;
wfex.wBitsPerSample  =   8 ;
wfex.cbSize  =   0 ;

capSetAudioFormat(hWndC,  & wfex,  sizeof (WAVEFORMATEX));

CAPTUREPARMS CaptureParms;
float  FramesPerSec  =   10.0 ;

capCaptureGetSetup(hWndC,  & CaptureParms,  sizeof (CAPTUREPARMS));

CaptureParms.dwRequestMicroSecPerFrame  =  (DWORD) ( 1.0e6   /  
    FramesPerSec);
capCaptureSetSetup(hWndC,  & CaptureParms,  sizeof  (CAPTUREPARMS));

//   This example assumes the application controls 
//   the video source for preroll and postroll. 
CAPINFOCHUNK cic;
//  . 
//  . 
//  . 
cic.fccInfoID  =  infotypeSMPTE_TIME;
cic.lpData  =   " 00:20:30:12 " ; 
cic.cbData  =  strlen (cic.lpData)  +   1 ;
capFileSetInfoChunk (hwndC,  & cic); 

TCHAR gachBuffer[ 100 ];   //  Global buffer.

DWORD gdwFrameNum  =   0 ;

//  FrameCallbackProc: frame callback function.

//  hWnd:              capture window handle.

//  lpVHdr:            pointer to structure containing captured

//                         frame information.

//

LRESULT PASCAL FrameCallbackProc(HWND hWnd, LPVIDEOHDR lpVHdr)

{

if  ( ! hWnd)

return  FALSE;

_stprintf_s(gachBuffer, TEXT( " Preview frame# %ld  " ), gdwFrameNum ++ );

SetWindowText(hWnd, gachBuffer);

return  (LRESULT) TRUE ;

}