using System;
using System.Runtime.InteropServices;


namespace OpenBildAnlyse {
    public class Falcon {
        private const string IMPORT = "falcon_64.dll";

        [DllImport("kernel32.dll")]
        static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);

        #region Initialization und termination
        /// <summary>
        /// Hardware initialization<para/>
        /// is_InitBoard() opens the driver and establishes contact to the hardware. If the hardware is successfully initialized, this function allocates a handle to the frame grabber. All of the following functions require this as their first parameter. If DirectDraw is not used for image output, hWnd can be set to Null.
        /// To install several EAGLE or FALCON frame grabbers in one computer (multi board operation), you have to decide during initialization of the handle which board is to be initialized. The Board ID is fixed in the EEPROM (see also is_GetBoardInfo()). If a special board is to be addressed, you have to initialize the handle hf with the relevant Board-ID of this board.
        /// If you don’t want multi board operation, handle hf must be initialized with the value zero before calling function is_InitBoard(). Here the value zero means, that the first not used frame grabber will be used.
        /// </summary>
        /// <param name="phf">Pointer to the frame grabber handle. The values have the following meaning: 0: use first unused board, 1-254: use board with this board ID</param>
        /// <param name="hWnd">Handle to the window in which the image is to be displayed(NULL is allowed)</param>
        /// <returns>IS_SUCCESS or a error code</returns>
        [DllImport(IMPORT, EntryPoint = "is_InitBoard")]
        public static extern int InitBoard(ref IntPtr phf, IntPtr hWnd);
        /// <summary>
        /// Closes the card and deallocates memory<para/>
        /// is_ExitBoard() cancels the active device handle hf and deallocates the data structures and memory areas currently associated with the FALCON/EAGLE. 
        /// The image memory which has been allocated by the user (is_AllocImageMem()) and which has not been released, is released with is_ExitBoard().
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_ExitBoard")]
        public static extern int ExitBoard(IntPtr hf);
        #endregion
        #region Image acquisition and memory management
        /// <summary>
        /// Stops live video<para/>
        /// The is_StopLiveVideo() function freezes the image in the VGA card or in the PC’s system memory.
        /// The function is controlled with the parameter Wait. The function has two modes: 
        /// Using the first mode, the function immediately returns to the calling function and grabs the image in the background.
        /// In the second mode the function waits until the image has been completely acquired and only then does the function return.
        /// Note for EAGLE: Being in trigger mode(see is_SetExternalTrigger() (c#:SetExternalTrigger)), the live mode is only ended, if a trigger signal is detected on trigger input.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="wait">IS_SUCCESS, IS_NO_SUCCESS</param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_StopLiveVideo")]
        public static extern int StopLiveVideo(IntPtr hf, int wait);
        /// <summary>
        /// Acquires live video<para/>
        /// digitizes video images in real time and transfers the images to the previously allocated image memory.
        /// Alternatively if you are using DirectDraw the images can be transferred to the graphics board. 
        /// In doing so, the conditions as set out in the is_SetCaptureMode() are taken into account. 
        /// If you are working with ring buffering (is_AddToSequence()) the image acquisition in the sequence runs through all image memories in a loop.
        /// </summary> 
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="wait">IS_DONT_WAIT: This function synchronizes the image acquisition of the next frame and/or V-SYNC field, but returns immediately.<para/>
        /// IS_WAIT: This function synchronizes the image acquisition of the next frame and/or V-SYNC field and only then does return (i.e. waits until image acquisition begins).<para/>
        /// 10 y Wait &lt; 32768 :Wait time in 10 ms steps(Wait = 100 > 1 s)<para/>
        /// A maximum of 328,68 s can be waited. <para/>
        /// (This is approx. 5 min and 20 s). For 1 &lt; Wait &lt; 10 Wait becomes equal to 10.<para/>
        /// (Example: Wait = 100 &gt; 1 s waiting)
        /// </param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS<para/>
        /// IS_TIMED_OUT(only if the IS_WAIT parameter is used in the triggered sequence mode of the EAGLE 
        /// and the trigger is not recognized in the next VSYNC)
        /// </returns>

        [DllImport(IMPORT, EntryPoint = "is_CaptureVideo")]
        public static extern int CaptureVideo(IntPtr hf, int wait);
        /// <summary>
        /// CopyImageMem() copies the contents of the image memory, as described is pcSource and nID to the area in memory, which pcDest points to.<para/>
        /// Copies image to memory as defined by programmer
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="pcSource">Pointer to image memory</param>
        /// <param name="nID">ID of image memory</param>
        /// <param name="pcDest">Pointer to destination memory to which the image should be copied</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_CopyImageMem")]
        public static extern int CopyImageMem(IntPtr hf, string pcSource, int nID, ref byte[] pcDest);
        /// <summary>
        /// Copies single lines to memory as defined by programmer<para/>
        /// is_CopyImageMem() copies the contents of the image memory, as described is pcSource and nID to the area in memory, which pcDest points to.<para/>
        /// Note: The user must make sure that the allocated memory pcDest is large enough to store the whole image (not just the area of interest) in the current format (bits per pixel).
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="pcSource">Pointer to image memory</param>
        /// <param name="nID">ID of image memory</param>
        /// <param name="nLines">Number of lines which are copied</param>
        /// <param name="pcDest">Pointer to destination memory to which the image should be copied</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_CopyImageMemLines")]
        public static extern int CopyImageMemLines(IntPtr hf, string pcSource, int nID, int nLines, ref byte[] pcDest);
        /// <summary>
        /// Acquires image and writes to destination address<para/>
        /// is_FreezeVideo() digitizes an image and transfers it to the active image memory. In DirectDraw mode the image is digitized in the DirectDraw buffer (either on the VGA card or in a back buffer). When working with ring buffering, image acquisition only takes place in the first image memory of the sequence.<para/>
        /// Note to EAGLE:  If the frame grabber is in trigger mode(see also is_SetExternalTrigger()), an image is only digitized, when a trigger signal occurs.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="wait">IS_DONT_WAIT: This function synchronizes the image acquisition of the next frame and/or V-SYNC field, but returns immediately.<para/>
        /// IS_WAIT: This function synchronizes the image acquisition of the next frame and/or V-SYNC field and only then does return (i.e. waits until image acquisition begins).<para/>
        /// 10 y Wait &lt; 32768 :Wait time in 10 ms steps(Wait = 100 > 1 s)<para/>
        /// A maximum of 328,68 s can be waited. <para/>
        /// (This is approx. 5 min and 20 s). For 1 &lt; Wait &lt; 10 Wait becomes equal to 10.<para/>
        /// (Example: Wait = 100 &gt; 1 s waiting)
        /// </param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_FreezeVideo")]
        public static extern int FreezeVideo(IntPtr hf, int wait);
        /// <summary>
        /// <para>Allocates image memory</para>
        ///
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="width">Width of image</param>
        /// <param name="height">Height of image</param>
        /// <param name="bitspixel">Color depth of image (bits per pixel)</param>
        /// <param name="ppcImgMem">Contains pointer to start of image memory</param>
        /// <param name="pid">Contains the ID for image memory</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_AllocImageMem")]
        public static unsafe extern int AllocImageMem(IntPtr hf, int width, int height, PixelFormat bitspixel, ref IntPtr ppcImgMem, ref int pid);
        /// <summary>
        /// <para>Frees allocated image memory</para>
        /// 
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pcMem"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_FreeImageMem")]
        public static extern int FreeImageMem(IntPtr hf, string pcMem, int id);
        /// <summary>
        /// <para>Makes image memory active</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pcMem"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetImageMem")]
        public static extern int SetImageMem(IntPtr hf, IntPtr pcMem, int id);
        /// <summary>
        /// <para>Reduces the number of images over PCI bus</para>
        /// 
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nMode"></param>
        /// <param name="nDecimate"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetDecimationMode")]
        public static extern int SetDecimationMode(IntPtr hf, int nMode, int nDecimate);
        /// <summary>
        /// <para>Returns pointer to image memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pMem"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetImageMem")]
        public unsafe static extern int GetImageMem(IntPtr hf, ref void* pMem);
        /// <summary>
        /// <para>Returns line offset (n) to (n+1)</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pPitch"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetImageMemPitch")]
        public static extern int GetImageMemPitch(IntPtr hf, ref int pPitch);
        /// <summary>
        /// <para>Returns number of active image memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="ppcMem"></param>
        /// <param name="pnID"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetActiveImageMem")]
        public static extern int GetActiveImageMem(IntPtr hf, ref string ppcMem, ref int pnID);
        /// <summary>
        /// <para>Returns image memory’s properties</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pcMem"></param>
        /// <param name="nID"></param>
        /// <param name="pnX"></param>
        /// <param name="pnY"></param>
        /// <param name="pnBits"></param>
        /// <param name="pnPitch"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_InquireImageMem")]
        public static extern int InquireImageMem(IntPtr hf, string pcMem, int nID, ref int pnX, ref int pnY, ref int pnBits, ref int pnPitch);

        /// <summary>
        /// <para>Has the image acquisition started?</para>
        /// is_HasVideoStarted() can check whether the digitizing of an image has started or not. This function is useful when used together with is_FreezeVideo() and the parameter IS_DONT_WAIT.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="pbo">Contains the digitization status:0 = not started,1 = image acquisition started</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_HasVideoStarted")]
        public static extern int HasVideoStarted(IntPtr hf, ref bool pbo);
        /// <summary>
        /// <para>Has the image acquisition finished?</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pbo"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_IsVideoFinish")]
        public static extern int IsVideoFinish(IntPtr hf, ref bool pbo);
        /// <summary>
        /// <para>Makes external memory to image memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="bitspixel"></param>
        /// <param name="pcImgMem"></param>
        /// <param name="pid"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetAllocatedImageMem")]
        public static extern int SetAllocatedImageMem(IntPtr hf, int width, int height, int bitspixel, string pcImgMem, ref int pid);

        #endregion
        #region Double and multiple buffering

        /// <summary>
        /// <para>Records image memory in sequence list</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pcMem"></param>
        /// <param name="nID"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_AddToSequence")]
        public static extern int AddToSequence(IntPtr hf, string pcMem, int nID);

        /// <summary>
        /// <para>Deletes sequence list</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_ClearSequence")]
        public static extern int ClearSequence(IntPtr hf);
        /// <summary>
        /// <para>Determines the image memory which is currently being used for the sequence.</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pnNum"></param>
        /// <param name="ppcMem"></param>
        /// <param name="ppcMemLast"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetActSeqBuf")]
        public static extern int GetActSeqBuf(IntPtr hf, ref int pnNum, ref string ppcMem, ref string ppcMemLast);
        /// <summary>
        /// <para>Protects image memory of the sequence from being overwritten.</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nNum"></param>
        /// <param name="pcMem"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_LockSeqBuf")]
        public static extern int LockSeqBuf(IntPtr hf, int nNum, string pcMem);
        /// <summary>
        /// <para>Allows image memory of the sequence to be overwritten.</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nNum"></param>
        /// <param name="pcMem"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_UnlockSeqBuf")]
        public static extern int UnlockSeqBuf(IntPtr hf, int nNum, string pcMem);
        #endregion
        #region Selection of operating modes and return of properties
        /// <summary>
        /// <para>Gets event counter and counter value</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nInfo"></param>
        /// <param name="ulValue"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_BoardStatus")]
        public static extern uint BoardStatus(IntPtr hf, int nInfo, uint ulValue);
        /// <summary>
        /// <para>Selection of video input signal</para>
        /// is_SetVideoInput() selects the video input to which a video source is connected for digitization. If the video sources are not synchronized to one another, the time it takes the multiplexer to switch and then to resynchronize to the new video source, can result in several lost or distorted frames. We therefore recommend that the cameras are operated in sync mode.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="Source"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetVideoInput")]
        public static extern int SetVideoInput(IntPtr hf, VideoSource Source);
        /// <summary>
        /// <para>Sets brightness</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Bright"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetBrightness")]
        public static extern int SetBrightness(IntPtr hf, int Bright);
        /// <summary>
        /// <para>Sets contrast</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Cont"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetContrast")]
        public static extern int SetContrast(IntPtr hf, int Cont);
        /// <summary>
        /// Gets type of board (FALCON, FALCONplus, FALCONquattro, EAGLE)<para/>
        /// If the FALCON and EAGLE are both installed in the same machine, it is important to be able to differentiate between the two cards. is_GetBoardType() returns the result of which type of board is installed.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <returns>Falcon = 1, Eagle = 2, FalconPlus = 7, FalconQuattro = 9</returns>
        [DllImport(IMPORT, EntryPoint = "is_GetBoardType")]
        public static extern BoardType GetBoardType(IntPtr hf);
        /// <summary>
        /// <para>Sets color saturation</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="ChromU"></param>
        /// <param name="ChromV"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetSaturation")]
        public static extern int SetSaturation(IntPtr hf, int ChromU, int ChromV);
        /// <summary>
        /// <para>Sets hue value</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Hue"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetHue")]
        public static extern int SetHue(IntPtr hf, int Hue);
        /// <summary>
        /// <para>Selection of video standard</para>
        /// is_SetVideoMode() selects the video standard for the connected video source. Color and monochrome signal standards with 50 Hz and 60 Hz are supported. With the IS_SET_VM_AUTO parameter, the video standard of the connected video source can automatically be set. All the other required settings can be carried out with the driver. The automatic video standard detection lasts approximate 1 s.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="Mode">Video mode setting</param>
        /// <returns>Current setting when called wih IS_GET_VIDEO_MODE, else IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_SetVideoMode")]
        public static extern int SetVideoMode(IntPtr hf, VideoMode Mode);
        /// <summary>
        /// <para>Selects image display mode</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetDisplayMode")]
        public static extern int SetDisplayMode(IntPtr hf, DisplayMode Mode);
        /// <summary>
        /// <para>Activates/deactivates gamma correction</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetGamma")]
        public static extern int SetGamma(IntPtr hf, int Mode);
        /// <summary>
        /// <para>Sets sync level for critical video sources (VCR)</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Level"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetSyncLevel")]
        public static extern int SetSyncLevel(IntPtr hf, int Level);
        /// <summary>
        /// <para>Selects color mode</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetColorMode")]
        public static extern int SetColorMode(IntPtr hf, ColorMode Mode);
        /// <summary>
        /// <para>Toggles scaler on and off; sets scaling ratio</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Scalex"></param>
        /// <param name="Scaley"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetScaler")]
        public static extern int SetScaler(IntPtr hf, float Scalex, float Scaley);
        /// <summary>
        /// <para>Sets the size of the image</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetImageSize")]
        public static extern int SetImageSize(IntPtr hf, int x, int y);
        /// <summary>
        /// <para>Sets image position within image window</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetImagePos")]
        public static extern int SetImagePos(IntPtr hf, int x, int y);
        /// <summary>
        /// <para>Sets acquisition mode</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetCaptureMode")]
        public static extern int SetCaptureMode(IntPtr hf, CaptureModeType Mode);
        /// <summary>
        /// <para>Activates/deactivates error output</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetErrorReport")]
        public static extern int SetErrorReport(IntPtr hf, int Mode);
        /// <summary>
        /// <para>Sets horizontal interpolation filter</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetHorFilter")]
        public static extern int SetHorFilter(IntPtr hf, int Mode);
        /// <summary>
        /// <para>Sets vertical interpolation filter</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetVertFilter")]
        public static extern int SetVertFilter(IntPtr hf, int Mode);
        /// <summary>
        /// <para>Calls error message</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pErr"></param>
        /// <param name="ppcErr"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetError")]
        public static unsafe extern int GetError(IntPtr hf, ref int pErr, ref byte[] ppcErr);
        /// <summary>
        /// <para>Returns currently active field (odd or even)</para>
        /// is_GetCurrentField() returns which field was captured as last field (odd or even). The function can be called inside an event (e.g. Bothfields).
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="pField">Field type: 1 = odd, 0 = even</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_GetCurrentField")]
        public static extern int GetCurrentField(IntPtr hf, out FieldType pField);
        /// <summary>
        /// <para>Gets the interrupt used from the card</para>
        /// is_GetIRQ() returns the interrupt of the board.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="pnIRQ">Pointer to variable, which contains number of interrupt.</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_GetIRQ")]
        public static extern int GetIRQ(IntPtr hf, ref int pnIRQ);
        /// <summary>
        /// <para>Returns the number of the PCI slot the board is plugged in</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pnSlot"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetPciSlot")]
        public static extern int GetPciSlot(IntPtr hf, ref int pnSlot);
        /// <summary>
        /// <para>Calls operating system type</para>
        ///
        /// </summary>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetOsVersion")]
        public static extern int GetOsVersion();
        /// <summary>
        /// <para>Output of VSYNC counter</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pIntr"></param>
        /// <param name="pActIntr"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetVsyncCount")]
        public static extern int GetVsyncCount(IntPtr hf, ref int pIntr, ref int pActIntr);
        /// <summary>
        /// <para>Sets the digital area of interest on the image</para>
        ///
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="xpos">x offset of left boarder (see following table for value range)<para/>
        /// has to be an even value
        /// </param>
        /// <param name="ypos">y offset of the upper boarder<para/>
        /// has to be an odd value
        /// </param>
        /// <param name="xsize">Image width</param>
        /// <param name="ysize">Image height</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_SetVideoSize")]
        public static extern int SetVideoSize(IntPtr hf, int xpos, int ypos, int xsize, int ysize);
        /// <summary>
        /// <para>Resets handle to output window</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="hwnd"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetHwnd")]
        public static extern int SetHwnd(IntPtr hf, IntPtr hwnd);
        /// <summary>
        /// <para>Set the handle of the parent or main window</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="hwnd"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetParentHwnd")]
        public static extern int SetParentHwnd(IntPtr hf, IntPtr hwnd);
        /// <summary>
        /// <para>Gets current color mode from VGA card</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pnCol"></param>
        /// <param name="pnColMode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetColorDepth")]
        public static extern int GetColorDepth(IntPtr hf, ref int pnCol, ref int pnColMode);
        /// <summary>
        /// <para>Changing the input after every frame</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nInput1"></param>
        /// <param name="nInput2"></param>
        /// <param name="nInput3"></param>
        /// <param name="nInput4"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetToggleMode")]
        public static extern int SetToggleMode(IntPtr hf, int nInput1, int nInput2, int nInput3, int nInput4);
        /// <summary>
        /// <para>Sets real time ROP effects</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="effect"></param>
        /// <param name="param"></param>
        /// <param name="reserved"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetRopEffect")]
        public static extern int SetRopEffect(IntPtr hf, int effect, int param, int reserved);
        /// <summary>
        /// <para>Returns the version of IMPORT</para>
        ///
        /// </summary>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetDLLVersion")]
        public static extern int GetDLLVersion();
        /// <summary>
        /// Returns the number of installed boards<para/>
        /// Function is_GetNumberOfDevices() delivers the number of FALCON/EAGLE devices in the PC. With a FALCONquattro/FALCONquattro Express the number of DEVICEs e.g. is 4.
        /// </summary>
        /// <returns>Number of detected boards</returns>
        [DllImport(IMPORT, EntryPoint = "is_GetNumberOfDevices")]
        public static extern int GetNumberOfDevices();
        /// <summary>
        /// <para>Rules one of the video inputs to the video output</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Source"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetPassthrough")]
        public static extern int SetPassthrough(IntPtr hf, int Source);
        /// <summary>
        /// <para>Controls the hardware watchdog</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="lMode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_Watchdog")]
        public static extern int Watchdog(IntPtr hf, long lMode);
        /// <summary>
        /// <para>Sets the time of the hardware watchdog</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="lTime"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_WatchdogTime")]
        public static extern int WatchdogTime(IntPtr hf, long lTime);
        #endregion
        #region Reading from and writing to EEPROMS
        /// <summary>
        /// <para>Writes own data to EEPROM</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Adr"></param>
        /// <param name="pcString"></param>
        /// <param name="Count"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_WriteEEPROM")]
        public static extern int WriteEEPROM(IntPtr hf, int Adr, string pcString, int Count);
        /// <summary>
        /// <para>Reads own data from EEPROM</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Adr"></param>
        /// <param name="pcString"></param>
        /// <param name="Count"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_ReadEEPROM")]
        public static extern int ReadEEPROM(IntPtr hf, int Adr, string pcString, int Count);
        /// <summary>
        /// <para>Reads reprogrammed manufacturer's information</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="pInfo"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetBoardInfo")]
        public static extern int GetBoardInfo(IntPtr hf, BordInfo pInfo);
        #endregion
        #region Saving and loading images
        /// <summary>
        /// <para>Saves video image as a bitmap (BMP)</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="File"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SaveImage")]
        public static extern int SaveImage(IntPtr hf, string File);
        /// <summary>
        /// <para>Saves image memory as a bitmap (BMP)</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="File"></param>
        /// <param name="pcMem"></param>
        /// <param name="nID"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SaveImageMem")]
        public static extern int SaveImageMem(IntPtr hf, string File, string pcMem, int nID);
        /// <summary>
        /// <para>Loads a bitmap image</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="File"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_LoadImage")]
        public static extern int LoadImage(IntPtr hf, string File);
        #endregion
        #region Image output
        /// <summary>
        /// <para>Displays images in a window</para>
        /// is_SetRenderBitmap() displays images from an image memory in the defined window. For displaying the images Win32 Bitmap functions are used.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="nMemID">ID of the image memory which should be displayed</param>
        /// <param name="hwnd">Window handle of the display window</param>
        /// <param name="nMode">Render mode</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_RenderBitmap")]
        public static extern int RenderBitmap(IntPtr hf, int nMemID, IntPtr hwnd, RenderMode nMode);
        /// <summary>
        /// <para>Displays refresh with DirectDraw</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_UpdateDisplay")]
        public static extern int UpdateDisplay(IntPtr hf);
        /// <summary>
        /// <para>Displays color bars from pattern generator</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_ShowColorBars")]
        public static extern int ShowColorBars(IntPtr hf, int Mode);
        /// <summary>
        /// <para>Sets the mode for the display refresh</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="mode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetUpdateMode")]
        public static extern int SetUpdateMode(IntPtr hf, int mode);

        #endregion
        #region Supplementary DirectDraw functions
        /// <summary>
        /// <para>Toggles DirectDraw overlay memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_EnableDDOverlay")]
        public static extern int EnableDDOverlay(IntPtr hf);
        /// <summary>
        /// <para>Switches off DirectDraw overlay memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_DisableDDOverlay")]
        public static extern int DisableDDOverlay(IntPtr hf);
        /// <summary>
        /// <para>Displays overlay memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_ShowDDOverlay")]
        public static extern int ShowDDOverlay(IntPtr hf);
        /// <summary>
        /// <para>Hides overlay memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_HideDDOverlay")]
        public static extern int HideDDOverlay(IntPtr hf);
        /// <summary>
        /// <para>Returns pointer to DirectDraw surface</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="ppDDSurf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetDDOvlSurface")]
        public unsafe static extern int GetDDOvlSurface(IntPtr hf, ref void* ppDDSurf);
        /// <summary>
        /// <para>Retrieves the device context handle’s overlay memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="phDC"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_GetDC")]
        public static extern int GetDC(IntPtr hf, ref IntPtr phDC);
        /// <summary>
        /// <para>Releases the device context handle’s overlay memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="hDC"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_ReleaseDC")]
        public static extern int ReleaseDC(IntPtr hf, IntPtr hDC);
        /// <summary>
        /// <para>Update cycle of image output with DirectDraw</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="ms"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetDDUpdateTime")]
        public static extern int SetDDUpdateTime(IntPtr hf, int ms);
        /// <summary>
        /// <para>Enables access to overlay memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="ppMem"></param>
        /// <param name="pPitch"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_LockDDOverlayMem")]
        public unsafe static extern int LockDDOverlayMem(IntPtr hf, ref void* ppMem, ref int pPitch);
        /// <summary>
        /// <para>Disables access to overlay memory</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_UnlockDDOverlayMem")]
        public static extern int UnlockDDOverlayMem(IntPtr hf);
        /// <summary>
        /// Enables VGA card to access the back buffer<para/> 
        /// In DirectDraw mode is_LockDDMem() gives access to the image memory and returns the address pointer to the beginning of the image memory.<para/> 
        /// In most cases the image memory is on the VGA card. Using the pointer the image memory can be accessed directly. Access is disabled with is_UnlockDDMem() – this must be done as soon as possible.<para/> 
        /// Digitizing to memory cannot be terminated with is_LockDDMem().<para/> 
        /// When in DirectDraw back buffer mode, within a LockDDMem –UnlockDDMem block there are no updates of the back buffer on the display.<para/> 
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="ppMem">Pointer to variable, which will contain address pointer</param>
        /// <param name="pPitch">Pointer to variable, which will contain the pitch value</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_LockDDMem")]
        public unsafe static extern int LockDDMem(IntPtr hf, ref void* ppMem, ref int pPitch);
        /// <summary>
        /// <para>Disables VGA card to access the back buffer</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_UnlockDDMem")]
        public static extern int UnlockDDMem(IntPtr hf);
        /// <summary>
        /// <para>Sets the keying colour for the overlay display.</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="r"></param>
        /// <param name="g"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetKeyColor")]
        public static extern int SetKeyColor(IntPtr hf, int r, int g, int b);
        /// <summary>
        /// <para>Changes position of overlay display.</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nOffsetX"></param>
        /// <param name="nOffsetY"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetKeyOffset")]
        public static extern int SetKeyOffset(IntPtr hf, int nOffsetX, int nOffsetY);
        /// <summary>
        /// <para>Switches off overlay surface when the window is moved</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="boMode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_OvlSurfaceOffWhileMove")]
        public static extern int OvlSurfaceOffWhileMove(IntPtr hf, bool boMode);
        /// <summary>
        /// <para>Initializes image stealing</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Mode"></param>
        /// <param name="StealColorMode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_PrepareStealVideo")]
        public static extern int PrepareStealVideo(IntPtr hf, int Mode, uint StealColorMode);
        /// <summary>
        /// <para>Steals image from a DirectDraw live mode</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="Wait"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_StealVideo")]
        public static extern int StealVideo(IntPtr hf, int Wait);
        /// <summary>
        /// <para>Scales overlay if video image becomes scaled</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="boScale"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_ScaleDDOverlay")]
        public static extern int ScaleDDOverlay(IntPtr hf, bool boScale);
        #endregion
        #region Event Handling
        /// <summary>
        /// <para>Sets up event handler</para>
        /// Initializes the event handler by registering the event object in the central driver.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="hEv">Event handle of the C/C++ function CreateEvent()</param>
        /// <param name="which">Event ID to be initialized</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>        
        [DllImport(IMPORT, EntryPoint = "is_InitEvent")]
        public static extern int InitEvent(IntPtr hf, IntPtr hEv, EventType which);
        /// <summary>
        /// <para>Exits event handler</para>
        /// Deletes set event object. After deleting it can not be activated with is_EnableEvent().
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="which">ID of event that should be deleted</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_ExitEvent")]
        public static extern int ExitEvent(IntPtr hf, EventType which);
        /// <summary>
        /// <para>Enable object event</para>
        /// Release of set up event object. After the release, the event signalling of the current event object is allowed. Calling is_FreezeVideo() signals the event. See also is_InitEvent().
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="which">ID of the event to release</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_EnableEvent")]
        public static extern int EnableEvent(IntPtr hf, EventType which);
        /// <summary>
        /// <para>Disable object event</para>
        /// is_DisableEvent() locks the event specified here. The event (e.g. a VSYNC) still normally occurs, however, but does not trigger within the interrupt service routine an event signal. After calling this function the application software does not get the blocked events. With is_EnableEvent() the desired event become activated again. See also is_InitEvent().
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="which">ID of the event to be locked</param>
        /// <returns>IS_SUCCESS, IS_NO_SUCCESS</returns>
        [DllImport(IMPORT, EntryPoint = "is_DisableEvent")]
        public static extern int DisableEvent(IntPtr hf, int which);
        #endregion
        #region Control of sync generator and input/outputs
        /// <summary>
        /// <para>Activates external trigger input</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nTriggerMode"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetExternalTrigger")]
        public static extern int SetExternalTrigger(IntPtr hf, int nTriggerMode);
        /// <summary>
        /// <para>Sets the flash/strobe output</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nField"></param>
        /// <param name="nLine"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetFlashStrobe")]
        public static extern int SetFlashStrobe(IntPtr hf, int nField, int nLine);
        /// <summary>
        /// <para>Activates the internal sync generator for the synchronization of more than one camera</para>
        ///
        /// </summary>
        /// <param name="hf"></param>
        /// <param name="nSync"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetSync")]
        public static extern int SetSync(IntPtr hf, int nSync);
        /// <summary>
        /// <para>Sets digital output or reads digital input</para>
        ///
        /// </summary>
        /// <param name="hr"></param>
        /// <param name="nIO"></param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_SetIO")]
        public static extern int SetIO(IntPtr hr, int nIO);
        /// <summary>
        /// 
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <param name="nMode">Direct3D function mode</param>
        /// <param name="pParam">Void-type pointer to a data object or an array of objects (depending on the mode selected using nMode).</param>
        /// <param name="SizeOfParam">Size (in bytes) of the data object in array</param>
        /// <returns></returns>
        [DllImport(IMPORT, EntryPoint = "is_DirectRenderer")]
        public static unsafe extern int DirectRenderer(IntPtr hf, DirectRendererMode nMode, void* pParam, int SizeOfParam);

        #endregion
        [StructLayout(LayoutKind.Explicit, Size = 64)]
        public struct BordInfo {
            // 0 1 2 3 4 5 6 7 8 9 0 1 | 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 | 2 3 4 5 6 7 8 9 0 1 | 2 3 4 5 6 7 8 9 0 1 2 3 | 4 | 5 | 6 7 8 9 0 1 2 3 
            // 1 2 3 4 5 6 7 8 9 0 1 2 | 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 | 1 2 3 4 5 6 7 8 9 0 | 1 2 3 4 5 6 7 8 9 0 1 2 | 1 | 1 | 1 2 3 4 5 6 7 8 
            // SerNo  0 - 11           | ID  12 - 31                             | Version 32 - 41     | Date 42 - 53            |Sel|Typ| Reserved 56 - 63
            [FieldOffset(0)]
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
            public byte[] SerNo; // e.g. "12345-1234"  (11 char)

        }


        public struct FalconImage {
            public byte[] Memory;
            public int ImageID;
        }

        #region Constants
        public enum ErrorCodes {
            NO_SUCCESS = -0x1,
            SUCCESS = 0x0,


            INVALID_FALCON_HANDLE = 0x1,
            INVALID_HANDLE = 0x1,
            IO_REQUEST_FAILED = 0x2,
            CANT_OPEN_DEVICE = 0x3,
            CANT_CLOSE_DEVICE = 0x4,
            CANT_SETUP_MEMORY = 0x5,
            NO_IntPtr_FOR_ERROR_REPORT = 0x6,
            ERROR_MESSAGE_NOT_CREATED = 0x7,
            ERROR_STRING_NOT_FOUND = 0x8,
            HOOK_NOT_CREATED = 0x9,
            TIMER_NOT_CREATED = 0x000A,
            CANT_OPEN_REGISTRY = 0xB,
            CANT_READ_REGISTRY = 0xC,
            CANT_VALIDATE_BOARD = 0xD,
            CANT_GIVE_BOARD_ACCESS = 0xE,
            NO_IMAGE_MEM_ALLOCATED = 0xF,
            CANT_CLEANUP_MEMORY = 0x10,
            CANT_COMMUNICATE_WITH_DRIVER = 0x11,
            FUNCTION_NOT_SUPPORTED_YET = 0x12,
            OPERATING_SYSTEM_NOT_SUPPORTED = 0x13,

            INVALID_VIDEO_IN = 0x14,
            INVALID_IMG_SIZE = 0x15,
            INVALID_ADDRESS = 0x16,
            INVALID_VIDEO_MODE = 0x17,
            INVALID_AGC_MODE = 0x18,
            INVALID_GAMMA_MODE = 0x19,
            INVALID_SYNC_LEVEL = 0x1A,
            INVALID_CBARS_MODE = 0x1B,
            INVALID_COLOR_MODE = 0x1C,
            INVALID_SCALE_FACTOR = 0x1D,
            INVALID_IMAGE_SIZE = 0x1E,
            INVALID_IMAGE_POS = 0x1F,
            INVALID_CAPTURE_MODE = 0x20,
            INVALID_RISC_PROGRAM = 0x21,
            INVALID_BRIGHTNESS = 0x22,
            INVALID_CONTRAST = 0x23,
            INVALID_SATURATION_U = 0x24,
            INVALID_SATURATION_V = 0x25,
            INVALID_HUE = 0x26,
            INVALID_HOR_FILTER_STEP = 0x27,
            INVALID_VERT_FILTER_STEP = 0x28,
            INVALID_EEPROM_READ_ADDRESS = 0x29,
            INVALID_EEPROM_WRITE_ADDRESS = 0x2A,
            INVALID_EEPROM_READ_LENGTH = 0x2B,
            INVALID_EEPROM_WRITE_LENGTH = 0x2C,
            INVALID_BOARD_INFO_POINTER = 0x2D,
            INVALID_DISPLAY_MODE = 0x2E,
            INVALID_ERR_REP_MODE = 0x2F,
            INVALID_BITS_PIXEL = 0x30,
            INVALID_MEMORY_POINTER = 0x31,

            FILE_WRITE_OPEN_ERROR = 0x32,
            FILE_READ_OPEN_ERROR = 0x33,
            FILE_READ_INVALID_BMP_ID = 0x34,
            FILE_READ_INVALID_BMP_SIZE = 0x35,
            FILE_READ_INVALID_BIT_COUNT = 0x36,
            WRONG_KERNEL_VERSION = 0x37,

            RISC_INVALID_XLENGTH = 0x3C,
            RISC_INVALID_YLENGTH = 0x3D,
            RISC_EXCEED_IMG_SIZE = 0x3E,

            DD_MAIN_FAILED = 0x46,
            DD_PRIMSURFACE_FAILED = 0x47,
            DD_SCRN_SIZE_NOT_SUPPORTED = 0x48,
            DD_CLIPPER_FAILED = 0x49,
            DD_CLIPPER_IntPtr_FAILED = 0x4A,
            DD_CLIPPER_CONNECT_FAILED = 0x4B,
            DD_BACKSURFACE_FAILED = 0x4C,
            DD_BACKSURFACE_IN_SYSMEM = 0x4D,
            DD_MDL_MALLOC_ERR = 0x4E,
            DD_MDL_SIZE_ERR = 0x4F,
            DD_CLIP_NO_CHANGE = 0x50,
            DD_PRIMMEM_NULL = 0x51,
            DD_BACKMEM_NULL = 0x52,
            DD_BACKOVLMEM_NULL = 0x53,
            DD_OVERLAYSURFACE_FAILED = 0x54,
            DD_OVERLAYSURFACE_IN_SYSMEM = 0x55,
            DD_OVERLAY_NOT_ALLOWED = 0x56,
            DD_OVERLAY_COLKEY_ERR = 0x57,
            DD_OVERLAY_NOT_ENABLED = 0x58,
            DD_GET_DC_ERROR = 0x59,
            DD_DDRAW_DLL_NOT_LOADED = 0x5A,
            DD_THREAD_NOT_CREATED = 0x5B,
            DD_CANT_GET_CAPS = 0x5C,
            DD_NO_OVERLAYSURFACE = 0x5D,
            DD_NO_OVERLAYSTRETCH = 0x5E,
            DD_CANT_CREATE_OVERLAYSURFACE = 0x5F,
            DD_CANT_UPDATE_OVERLAYSURFACE = 0x60,
            DD_INVALID_STRETCH = 0x61,

            EV_INVALID_EVENT_NUMBER = 0x64,
            INVALID_MODE = 0x65,
            CANT_FIND_FALCHOOK = 0x66,
            CANT_FIND_HOOK = 0x66,
            CANT_GET_HOOK_PROC_ADDR = 0x67,
            CANT_CHAIN_HOOK_PROC = 0x68,
            CANT_SETUP_WND_PROC = 0x69,
            IntPtr_NULL = 0x6A,
            INVALID_UPDATE_MODE = 0x6B,
            NO_ACTIVE_IMG_MEM = 0x6C,
            CANT_INIT_EVENT = 0x6D,
            FUNC_NOT_AVAIL_IN_OS = 0x6E,
            CAMERA_NOT_CONNECTED = 0x6F,
            SEQUENCE_LIST_EMPTY = 0x70,
            CANT_ADD_TO_SEQUENCE = 0x71,
            LOW_OF_SEQUENCE_RISC_MEM = 0x72,
            IMGMEM2FREE_USED_IN_SEQ = 0x73,
            IMGMEM_NOT_IN_SEQUENCE_LIST = 0x74,
            SEQUENCE_BUF_ALREADY_LOCKED = 0x75,
            INVALID_DEVICE_ID = 0x76,
            INVALID_BOARD_ID = 0x77,
            ALL_DEVICES_BUSY = 0x78,
            HOOK_BUSY = 0x79,
            TIMED_OUT = 0x7A,
            NULL_POINTER = 0x7B,
            WRONG_HOOK_VERSION = 0x7C,
            INVALID_PARAMETER = 0x7D,
            NOT_ALLOWED = 0x7E,
            OUT_OF_MEMORY = 0x7F,
            INVALID_WHILE_LIVE = 0x80,
            ACCESS_VIOLATION = 0x81,
            UNKNOWN_ROP_EFFECT = 0x82,
            INVALID_RENDER_MODE = 0x83,
            INVALID_THREAD_CONTEXT = 0x84,
            NO_HARDWARE_INSTALLED = 0x85,
            INVALID_WATCHDOG_TIME = 0x86,
            INVALID_WATCHDOG_MODE = 0x87,
            INVALID_PASSTHROUGH_IN = 0x88,
            ERROR_SETTING_PASSTHROUGH_IN = 0x89,
            FAILURE_ON_SETTING_WATCHDOG = 0x8A,
            ERROR_SETTING_DIGITAL_OUT = 0x8B,
            ERROR_NOT_SUPPORTED_BY_HARDWARE = 0x8C,
            PROCESS_ACCESS_DENIED = 0x8D,
            VIDEO_PROCESS_ALREADY_ATTACHED = 0x8E,
            IMG_SIZE_FOR_IMG_MEM_NOT_SET = 0x8F,

            WRONG_KEY = 0x96,

            DR_LIBRARY_NOT_FOUND = 0xA0,  // the DirectRender library could not be found
            DR_DEVICE_OUT_OF_MEMORY = 0xA1,  // insufficient graphics adapter video memory
            DR_CANNOT_CREATE_SURFACE = 0xA2,  // the image or overlay surface could not be created
            DR_CANNOT_CREATE_VERTEX_BUFFER = 0xA3,  // the vertex buffer could not be created
            DR_CANNOT_CREATE_TEXTURE = 0xA4,  // the texture could not be created  
            DR_CANNOT_LOCK_OVERLAY_SURFACE = 0xA5,  // the overlay surface could not be locked
            DR_CANNOT_UNLOCK_OVERLAY_SURFACE = 0xA6,  // the overlay surface could not be unlocked
            DR_CANNOT_GET_OVERLAY_DC = 0xA7,  // cannot get the overlay surface DC 
            DR_CANNOT_RELEASE_OVERLAY_DC = 0xA8,  // cannot release the overlay surface DC
            DR_DEVICE_CAPS_INSUFFICIENT = 0xA9,  // insufficient graphics adapter capabilities
            DR_SURFACE_LOST = 0xAA,  // created surfaces were lost and recreated
            DR_CANNOT_LOCK_IMAGE_SURFACE = 0xAB,  // the image surface could not be locked
            DR_CANNOT_UNLOCK_IMAGE_SURFACE = 0xAC,  // the image surface could not be unlocked
            DR_NOT_ALLOWED_WHILE_DC_IS_ACTIVE = 0xAD,    // not allowed between GetDC/ReleaseDC block
        }

        public const int IS_WAIT = 0x1;
        public const int IS_DONT_WAIT = 0x0;
        public const int IS_FORCE_VIDEO_STOP = 0x4000;
        public const int IS_FORCE_VIDEO_START = 0x4000;

        public const int RESET = 0x0000;
        public const int SET = 0x0001;
        public const int GET_ERR_REP_MODE = 0x8000;
        public const int GET_VIDEO_IN = 0x8000;
        public const int GET_VIDEO_IN_TOGGLE = 0x8001;
        public const int GET_LIVE = 0x8000;
        public const int GET_BRIGHTNESS = 0x8000;
        public const int GET_CONTRAST = 0x8000;
        public const int GET_SATURATION_U = 0x8000;
        public const int GET_SATURATION_V = 0x8001;
        public const int GET_HUE = 0x8000;
        public const int GET_VIDEO_MODE = 0x8000;
        public const int GET_DISPLAY_MODE = 0x8000;
        public const int GET_AGC_MODE = 0x8000;
        public const int GET_GAMMA_MODE = 0x8000;
        public const int GET_SYNC_LEVEL = 0x8000;
        public const int GET_CBARS_MODE = 0x8000;
        public const int GET_COLOR_MODE = 0x8000;
        public const int GET_CAPTURE_MODE = 0x8000;
        public const int GET_IMAGE_SIZE_X = 0x8000;
        public const int GET_IMAGE_SIZE_Y = 0x8001;
        public const int GET_IMAGE_POS_X = 0x8000;
        public const int GET_IMAGE_POS_Y = 0x8001;
        public const int GET_HOR_FILTER_MODE = 0x8000;
        public const int GET_HOR_FILTER_STEP = 0x8001;
        public const int GET_VERT_FILTER_MODE = 0x8000;
        public const int GET_VERT_FILTER_STEP = 0x8001;
        public const int GET_SCALER_MODE = 0x3E8;
        public const int GET_KC_RED = 0x8000;
        public const int GET_KC_GREEN = 0x8001;
        public const int GET_KC_BLUE = 0x8002;
        public const int GET_KC_RGB = 0x8003;
        public const int GET_KC_INDEX = 0x8004;
        public const int GET_KEYOFFSET_X = 0x8000;
        public const int GET_KEYOFFSET_Y = 0x8001;
        public const int GET_UPDATE_MODE = 0x8000;
        public const int GET_SYNC_GEN = 0x8000;
        public const int GET_IO = 0x8000;
        public const int GET_DIGOUT = 0x8001;
        public const int GET_FLASHSTROBE_FIELD = 0x8000;
        public const int GET_FLASHSTROBE_LINE = 0x8001;
        public const int GET_EXTERNALTRIGGER = 0x8000;
        public const int GET_TRIGGER_STATUS = 0x8001;
        public const int GET_TRIGGER_MASK = 0x8002;
        public const int GET_TRIGGER_INPUTS = 0x8003;
        public const int GET_STATUS = 0x8000;
        public const int GET_TOGGLE_INPUT_1 = 0x8000;
        public const int GET_TOGGLE_INPUT_2 = 0x8001;
        public const int GET_TOGGLE_INPUT_3 = 0x8002;
        public const int GET_TOGGLE_INPUT_4 = 0x8003;
        public const int GET_CROSSBAR = 0x8000;
        public const int GET_DD_OVERLAY_SCALE = 0x8000;
        public const int GET_VIDEO_PASSTHROUGH = 0x8000;


        #endregion

        public enum CaptureModeType : int {
            /// <summary>
            /// Acquires odd half images
            /// </summary>
            ODD = 0x0001,
            /// <summary>
            /// Acquires even half images
            /// </summary>
            Even = 0x0002,
            /// <summary>
            /// Acquires interlaced video (first the odd field, then the even field)
            /// </summary>
            Frame = 0x0004,
            /// <summary>
            /// Acquires non-interlaced video. Software solution, non interlaced cameras cannot be used.<para/>
            /// The first field is written in top of the memory and the second field into the lower part of the memory.
            /// </summary>
            NextFrame = 0x0010,
            /// <summary>
            /// Acquires next interlaced video beginning with next field (odd or even)
            /// </summary>
            NextField = 0x0020,
            /// <summary>
            /// Acquires next half image (odd or even)
            /// </summary>
            NonInterlaced = 0x0008,
            /// <summary>
            /// Acquires both fields with double field rate.Odd- and even-fields are acquired in the same memory area.Image size e.g.. 768x288 pixel, frame rate 50Hz.
            /// </summary>
            BothFields = ODD | Even | NonInterlaced,
            /// <summary>
            /// Acquires stereo video. Before the video channel IS_SET_VIDEO_IN_1 must have been set with is_SetVideoInput().
            /// </summary>
            FrameStereo = 0x2004,
            /// <summary>
            /// Returns the current setting
            /// </summary>
            Mode = 0x8000
        }
        public enum VideoSource : int {
            /// <summary>
            /// Video input 1 (composite video)
            /// </summary>
            VideoIn1 = 0x00,
            /// <summary>
            /// Video input 2 (composite video)
            /// </summary>
            VideoIn2 = 0x01,
            /// <summary>
            /// Video input 3 (composite video)
            /// </summary>
            VideoIn3 = 0x03,
            /// <summary>
            /// Video input 4 (composite video)
            /// </summary>
            VideoIn4 = 0x04,
            /// <summary>
            /// Video input 3 (S-Video; SVHS)
            /// </summary>
            VideoInS = 0x02,
            /// <summary>
            /// Video input 1 (S-Video)
            /// </summary>
            VideoIn1S = 0x10,
            /// <summary>
            /// Video input 2 (S-Video)
            /// </summary>
            VideoIn2S = 0x11,
            /// <summary>
            /// Video input 2 (S-Video)
            /// </summary>
            VideoIn3S = 0x13,
            /// <summary>
            /// Video input 1 (S-Video)
            /// </summary>
            VideoIn4S = 0x14,
            /// <summary>
            /// Return of current setting
            /// </summary>
            GetVideoIn = 0x8000
        }
        public enum BoardType : int {
            Falcon = 1,
            Eagle = 2,
            FalconPlus = 7,
            FalconQuattro = 9
        }
        public enum BoardStatusType : int {
            /// <summary>
            ///  Number of FIFO Overruns. Will be increased each time image data are lost during the transmission via PCI bus from PC to frame grabber.
            /// </summary>
            IsFifoOverCNT = 1,
            /// <summary>
            /// Number of images in a sequence. The counter is set to zero with function is_CaptureVideo() and increased with each change of the sequence buffer.
            /// </summary>
            IsSequenceCNT = 2,
            /// <summary>
            /// Has a Fifo-Overrun happen in last frame?
            /// </summary>
            IsLastFrameFifoOVR = 3,
            /// <summary>
            /// Number of sequence buffer (read only)
            /// </summary>
            IsSequenceSize = 4,
            /// <summary>
            ///Trigger interrupt counter (only FALCONquattro/FALCONquattro Express)
            /// </summary>
            IsExtTriggerEventCNT = 0,
            /// <summary>
            /// Returns whether a video signal is present at the selected video input. (read only)<para/>
            /// 0 = no signal present<para/>
            /// 1 = signal present<para/>
            /// After the start of is_CaptureVideo() approx. 0,1 s must be waited before this function may be queried.
            /// </summary>
            IsVideoPresent = 5,
            /// <summary>
            /// Flag which indicates whether the steal process has finished (read only):<para/>
            /// 0 = still active<para/>
            /// 1 = finished
            /// </summary>
            IsStealFinished = 6,
            /// <summary>
            /// Option to keep the selected file path of the file open or file save dialog box of is_SaveImage()/is_LoadImage().<para/>
            /// value = 0: don’t keep file path (default)<para/>
            /// value  = 1: keep file path
            /// </summary>
            IsStoreFilePath = 7,
            /// <summary>
            /// Enables or disables the luma notch filter:<para/>
            /// 0 = disabled<para/>
            /// 1 = enabled
            /// </summary>
            IsLumaBandwidthFilter = 8,
            /// <summary>
            /// Returns the hardware revision of the board (read only).
            /// </summary>
            IsBoardRevision = 9,
            /// <summary>
            /// Horizontal mirroring with is_SaveImage() and is_SaveImageMem()<para/>
            /// 0 = mirroring off<para/>
            /// 1 = mirroring on
            /// </summary>
            IsMirrorBitmapUpDown = 10,
            /// <summary>
            /// Number of PCI bus overruns. The number is incremented if data were lost because of bus overload.
            /// </summary>
            IsBusOverCNT = 11,
            /// <summary>
            /// 0 = color processing always on
            /// 1 = Switch off color processing in the case of bad signals. (default)
            /// </summary>
            IsLowColorRemoval = 13,
            /// <summary>
            /// Enable/Disable ChromaComb filter<para/>
            /// 0 = filter off<para/>
            /// 1 = filter on
            /// </summary>
            IsCHROMA_COMB_FILTER = 14,
            /// <summary>
            /// Enable/Disable the automatic gain control (AGC):<para/>
            /// 0 = Chroma AGC off<para/>
            /// 1 = Chroma AGC on (default)
            /// </summary>
            IschromaAGC = 15,
            /// <summary>
            /// Display double height images in DirectDraw mode.<para/>
            /// 0 = single height<para/>
            /// 1 = double height
            /// </summary>
            IsRenderDoubleHeight = 128,
            /// <summary>
            /// Switching off the internal reference signal and expects an external one (Vref).<para/>
            /// 0 = internal AGC mode<para/>
            /// 1 = external Vref mode
            /// </summary>
            IsExternalVREFMode = 18,
            /// <summary>
            /// Returns the presence of a hardware watchdog (read only):<para/>
            /// 0 = no watchdog available<para/>
            /// 1 = watchdog available
            /// </summary>
            IsWatchdogOnBoard = 16,
            /// <summary>
            /// Returns the presence of a video output (read only):<para/>
            /// 0 = no video output available<para/>
            /// 1 = video output available
            /// </summary>
            IsPassthroughOnBoard = 17
        }
        public enum VideoMode : int {
            /// <summary>
            /// PAL standard color 50 Hz
            /// </summary>
            PAL = 0x00,
            /// <summary>
            /// NTSC standard color 60 Hz
            /// </summary>
            NTSC = 0x01,
            /// <summary>
            /// SECAM standard 50 Hz
            /// </summary>
            SECAM = 0x02,
            /// <summary>
            /// Automatic video standard detection<para/>
            /// If no video signal is present then IS_NO_SUCCESS is returned.
            /// </summary>
            AUTO = 0x03,
            /// <summary>
            /// Returns the current setting
            /// </summary>
            Mode = 0x8000
        }
        public enum FieldType : int {
            Odd = 0,
            Even = 1
        }
        public enum EventType : int {
            /// <summary>
            /// Event is signalized in odd field (in connection with is_FreezeVideo())
            /// </summary>
            Odd = 0x00,
            /// <summary>
            /// Event is signalized in even field (in connection with is_FreezeVideo())
            /// </summary>
            Even = 0x01,
            /// <summary>
            /// Event is signalized after a complete frame (in connection with is_FreezeVideo())
            /// </summary>
            Frame = 0x02,
            /// <summary>
            /// Trigger event
            /// </summary>
            ExtTrigger = 0x03,
            /// <summary>
            /// Event is signalized at every VSYNC
            /// </summary>
            VSync = 0x04,
            /// <summary>
            /// Event is signalized at change of sequence buffer<para/>
            /// Attention: If the video signal is lost, the event is still set
            /// </summary>
            Sequence = 0x05,
            /// <summary>
            /// Event is signalized when is_StealVideo() has finished
            /// </summary>
            Steal = 0x06,
            /// <summary>
            /// Event is signalized when the analogous video signal of the active input is turned on or off. See also is_BoardStatus() parameter IS_VIDEO_PRESENT.
            /// </summary>
            VideoPresent = 0x07,
        }
        public enum RenderMode {
            /// <summary>
            /// Image output 1:1 from the memory
            /// </summary>
            Normal,
            /// <summary>
            /// Fit the image into the size of the window
            /// </summary>
            FitToWindow,
            /// <summary>
            /// Display the image with a size of 50 % of the original size.
            /// </summary>
            Downscale1To2,
            /// <summary>
            /// Horizontal mirroring of the image (upside down)
            /// </summary>
            MirrorUpDown,
            /// <summary>
            /// Display of the image with half height without scaling. The is been clipped.
            /// </summary>
            HalfHeight,
            /// <summary>
            /// Uses the color setting of the allocated image memory, not the current setting of is_SetColorMode().
            /// </summary>
            UseMemoryColor
        }
        public enum DirectRendererMode {
            /// <summary>
            /// Returns the device context (DC) handle to the overlay area of the graphics card.<para/>
            /// In Direct3D mode, the DR_GET_OVERLAY_DC mode returns the device context (DC) handle of the overlay area. Using this handle, it is possible to access the overlay using the Windows GDI functionality. Thus, all Windows graphics commands (e.g. Line, Circle, Rectangle, TextOut) are available. To transfer the drawn elements to the overlay, release the DC handle by calling DR_RELEASE_OVERLAY_DC.
            /// </summary>
            GetOverlayDC = 1,
            /// <summary>
            /// Releases the device context (DC) handle.<para/>
            /// Using DR_RELEASE_OVERLAY_DC, you can release the DC handle and update the overlay data
            /// </summary>
            ReleaseOverlayDC = 4,
            /// <summary>
            /// Reurns the width x and height y of the maximum overlay area supported by the graphics card.
            /// </summary>
            GetMaxOverlaySize = 2,
            /// <summary>
            /// Defines the size of the overlay area (default: current camera image size).
            /// </summary>
            SetOverlaySize = 7,
            /// <summary>
            /// Defines the position of the overlay area.
            /// </summary>
            SetOverlayPosition = 8,
            /// <summary>
            /// Returns the RGB values of the current key color (default: black).
            /// </summary>
            GetOverlayColorKey = 3,
            /// <summary>
            /// Defines the RGB values of the key color.
            /// </summary>
            SetOverlayColorKey = 9,
            /// <summary>
            /// Enables overlay display on top of the current camera image
            /// </summary>
            ShowOverlay = 5,
            /// <summary>
            /// Disables overlay display.
            /// </summary>
            HideOverlay = 6,
            /// <summary>
            /// Enables real-time scaling of the image to the size of the display window.
            /// </summary>
            EnableScaling = 11,
            /// <summary>
            /// Disables real-time scaling.
            /// </summary>
            DisableScaling = 12,
            /// <summary>
            /// Enables a semi-transparent display of the overlay area.<para/>
            /// In semi-transparent mode, the values of the camera image and the overlay data are added up for each pixel. Since black has the value 0, the complete camera image will be visible if the overlay is black; if the overlay is white, only the overlay will be visible. With all other colors, the camera image will be visible with the overlay superimposed.<para/>
            /// The key color has no effect in semi-transparent mode!
            /// </summary>
            EnableSemiTransparentOverlay = 14,
            /// <summary>
            /// Disables the semi-transparent display of the overlay area.
            /// </summary>
            DisableSemiTransparentOverlay = 15,
            /// <summary>
            /// Enables synchronization of the image display with the monitor's image rendering. The image is displayed upon the monitor's next VSYNC signal.
            /// </summary>
            SetVSyncAuto = 18,
            /// <summary>
            /// Disables image display synchronization. The image is displayed immediately.
            /// </summary>            
            SetVSyncOff = 17,
            /// <summary>
            /// Enables synchronization of the image display with a monitor pixel row specified by the user.<para/>
            /// Note that the auto-VSYNC function might not always optimally synchronize image rendering. In this case, you can eliminate flicker by manually setting a suitable position for synchronization. The position needs to be determined individually, based on the camera type and the graphics card.
            /// </summary>            
            SetUserSync = 19,
            /// <summary>
            /// Returns the minimum and maximum row position for DR_SET_USER_SYNC.
            /// </summary>            
            GetUSerSyncPositionRange = 20,
            /// <summary>
            /// Loads a bitmap image (*.BMP file) into the overlay area. If the bitmap image is larger than the overlay area, the bitmap image is clipped.
            /// </summary>            
            OverlayFromFile = 21,
            /// <summary>
            /// Deletes the data of the overlay area by filling it with black color.
            /// </summary>            
            ClearOverlay = 13,
            /// <summary>
            /// Copies the next image to the active user memory which was set with is_SetImageMem() (Steal function).<para/>
            /// Using the pParam parameter, you specify when the function should return: IS_WAIT: The function waits until the image save is complete.,IS_DONT_WAIT: The function returns immediately.
            /// </summary>            
            StealNextFrame = 22,
            /// <summary>
            /// Defines the color format identical to is_Prepare StealVideo().<para/>
            /// For a list of all available color formats, see the function description for is_SetColorMode(). The default is IS_CM_RGB32. A value of 0xFFFFFFFF (-1) deactivates the steal mode (same as is_StealVideo(h, IS_EXIT_STEAL_VIDEO)).
            /// </summary>            
            SetStealFormat = 23,
            /// <summary>
            /// Returns the color format setting for the Steal function.
            /// </summary>            
            GetStealFormat = 24,
            /// <summary>
            /// Sets a new window handle for image output in Direct3D. This requires the Direct3D interface to be re-initialized internally. All overlay data will be discarded and has to be redrawn by the application. The Overlay-Lost message signals to the application in this case (see also description above).
            /// </summary>            
            SetHWND = 10,
            /// <summary>
            /// Returns whether the graphics card supports the Direct3D functions.
            /// </summary>            
            CheckCompatibility = 16,
            /// <summary>
            /// Checks whether the specified color modes can be used for display. The FALCON color mode has to be passed as source mode and the desired VGA mode as target mode.
            /// </summary>
            CheckColorModeSupport = 27,
        }
        public enum PixelFormat {
            Y8 = 8,
            RGB8 = 8,
            RGB15 = 15,
            RGB16 = 16,
            RGB24 = 24,
            RGB32 = 32,
        }
        public enum ColorMode {
            /// <summary>
            /// 8 bit monochrome images
            /// </summary>
            Y8 = 0x06,
            /// <summary>
            /// 8 bit color images; 2 R - 3 G - 2 B
            /// </summary>            
            RGB8 = 0x07,
            /// <summary>
            /// Hi-color mode; 5 R - 5 G - 5 B
            /// </summary>            
            RGB15 = 0x03,
            /// <summary>
            /// Hi-color mode; 5 R - 6 G - 5 B
            /// </summary>            
            RGB16 = 0x2,
            /// <summary>
            /// 24 bit true color mode; R-G-B
            /// </summary>            
            RGB24 = 0x1,
            /// <summary>
            /// 32 bit true color mode, R-G-B dummy
            /// </summary>
            RGB32 = 0x00,
            /// <summary>
            /// YUV color images
            /// </summary>
            YUV422Planar,
            /// <summary>
            ///  Returns the current setting
            /// </summary>            
            Mode = 0x8000,
        }
        public enum DisplayMode {
            /// <summary>
            /// Acquire image in image memory
            /// </summary>
            Bitmap = 1,
            /// <summary>
            /// DirectDraw mode (back buffer mode)
            /// </summary>            
            DirectDraw = 2,
            /// <summary>
            /// Direct3D mode
            /// </summary>            
            Direct3d = 4,
            //DirectDraw Back Buffer Erweiterung
            /// <summary>
            /// DirectDraw buffer can be set in PC, if the VGA memory is not large enough
            /// </summary>            
            AllowSysmem = 0x40,
            //DirectDraw Primary Surface Erweiterung
            /// <summary>
            /// Primary surface mode (no overlay possible)
            /// </summary>            
            AllowPrimary = 0x80,
            //DirectDraw Overlay Surface Erweiterung
            /// <summary>
            /// Overlay surface mode
            /// </summary>            
            AllowOverlay = 0x100,
            /// <summary>
            /// Real time scaling in overlay surface mode
            /// </summary>            
            AllowScaling = 0x200,
            /// <summary>
            /// Field representation at ysize ≤ PAL/2 (288)
            /// </summary>            
            AllowFieldskip = 0x400,
            /// <summary>
            /// Returns the current setting
            /// </summary>            
            Mode = 0x800,
        }

        #region Custom Methodes
        public const uint IS_GET_STATUS = 0x8000;
        /// <summary>
        /// Returns whether a video signal is present at the selected video input.
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <returns>false = no signal present, true = signal present</returns>
        public static bool IsSignalAvailable(in IntPtr hf) => 0 != BoardStatus(hf, (int)BoardStatusType.IsVideoPresent, IS_GET_STATUS);
        /// <summary>
        /// Returns the presence of a hardware watchdog
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <returns>false = no watchdog available, true = watchdog available</returns>
        public static bool IsWatchdogAvailable(in IntPtr hf) => 0 != BoardStatus(hf, (int)BoardStatusType.IsWatchdogOnBoard, IS_GET_STATUS);
        /// <summary>
        /// Returns the presence of a video output
        /// </summary>
        /// <param name="hf">Frame grabber handle</param>
        /// <returns>false = no video output available, true = video output available</returns>
        public static bool IsVideoAvailable(in IntPtr hf) => 0 != BoardStatus(hf, (int)BoardStatusType.IsPassthroughOnBoard, IS_GET_STATUS);



        #endregion
    }
}