FlyCapture2Defs_C.h

//=============================================================================
// Copyright © 2017 FLIR Integrated Imaging Solutions, Inc. All Rights Reserved.
//
// This software is the confidential and proprietary information of FLIR
// Integrated Imaging Solutions, Inc. ("Confidential Information"). You
// shall not disclose such Confidential Information and shall use it only in
// accordance with the terms of the license agreement you entered into
// with FLIR Integrated Imaging Solutions, Inc. (FLIR).
//
// FLIR MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
// SOFTWARE, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE, OR NON-INFRINGEMENT. FLIR SHALL NOT BE LIABLE FOR ANY DAMAGES
// SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
// THIS SOFTWARE OR ITS DERIVATIVES.
//=============================================================================
//=============================================================================
// $Id: FlyCapture2Defs_C.h,v 1.74 2010-12-13 23:58:00 mgara Exp $
//=============================================================================

#ifndef PGR_FC2_FLYCAPTURE2DEFS_C_H
#define PGR_FC2_FLYCAPTURE2DEFS_C_H

#include <stdlib.h>

//=============================================================================
// Definitions header file for FlyCapture2 C API.
//
// Holds enumerations, typedefs and structures that are used across the
// FlyCapture2 C API wrapper.
//
// Please see FlyCapture2Defs.h or the API documentation for full details
// of the various enumerations and structures.
//=============================================================================

#ifdef __cplusplus
extern "C"
{
#endif

	/**
	 * @defgroup CTypeDefs TypeDefs
	 */

	/*@{*/

	typedef int BOOL;

#ifndef FALSE
#define FALSE               0
#endif

#ifndef TRUE
#define TRUE                1
#endif

#ifndef FULL_32BIT_VALUE
#define FULL_32BIT_VALUE 0x7FFFFFFF
#endif

#define MAX_STRING_LENGTH   512

	/**
	 * A context to the FlyCapture2 C library. It must be created before
	 * performing any calls to the library.
	 */
	typedef void* fc2Context;

	/**
	 * A context to the FlyCapture2 C GUI library. It must be created before
	 * performing any calls to the library.
	 */
	typedef void* fc2GuiContext;

	/**
	 * An internal pointer used in the fc2Image structure.
	 */
	typedef void* fc2ImageImpl;

	/**
	 * A context referring to the AVI recorder object.
	 */
	typedef void* fc2AVIContext;

	/**
	 * A context referring to the ImageStatistics object.
	 */
	typedef void* fc2ImageStatisticsContext;

	/**
	 * A context referring to the TopologyNode object.
	 */
	typedef void* fc2TopologyNodeContext;

	/**
	 * A GUID to the camera.  It is used to uniquely identify a camera.
	 */
	typedef struct _fc2PGRGuid
	{
		unsigned int value[4];

	} fc2PGRGuid;

	/*@}*/

	/**
	 * @defgroup CEnumerations Enumerations
	 */

	/*@{*/

	/** The error types returned by functions. */
	typedef enum _fc2Error
	{
		FC2_ERROR_UNDEFINED = -1, /**< Undefined */
		FC2_ERROR_OK, /**< Function returned with no errors. */
		FC2_ERROR_FAILED, /**< General failure. */
		FC2_ERROR_NOT_IMPLEMENTED, /**< Function has not been implemented. */
		FC2_ERROR_FAILED_BUS_MASTER_CONNECTION, /**< Could not connect to Bus Master. */
		FC2_ERROR_NOT_CONNECTED, /**< Camera has not been connected. */
		FC2_ERROR_INIT_FAILED, /**< Initialization failed. */
		FC2_ERROR_NOT_INTITIALIZED, /**< Camera has not been initialized. */
		FC2_ERROR_INVALID_PARAMETER, /**< Invalid parameter passed to function. */
		FC2_ERROR_INVALID_SETTINGS, /**< Setting set to camera is invalid. */
		FC2_ERROR_INVALID_BUS_MANAGER, /**< Invalid Bus Manager object. */
		FC2_ERROR_MEMORY_ALLOCATION_FAILED, /**< Could not allocate memory. */
		FC2_ERROR_LOW_LEVEL_FAILURE, /**< Low level error. */
		FC2_ERROR_NOT_FOUND, /**< Device not found. */
		FC2_ERROR_FAILED_GUID, /**< GUID failure. */
		FC2_ERROR_INVALID_PACKET_SIZE, /**< Packet size set to camera is invalid. */
		FC2_ERROR_INVALID_MODE, /**< Invalid mode has been passed to function. */
		FC2_ERROR_NOT_IN_FORMAT7, /**< Error due to not being in Format7. */
		FC2_ERROR_NOT_SUPPORTED, /**< This feature is unsupported. */
		FC2_ERROR_TIMEOUT, /**< Timeout error. */
		FC2_ERROR_BUS_MASTER_FAILED, /**< Bus Master Failure. */
		FC2_ERROR_INVALID_GENERATION, /**< Generation Count Mismatch. */
		FC2_ERROR_LUT_FAILED, /**< Look Up Table failure. */
		FC2_ERROR_IIDC_FAILED, /**< IIDC failure. */
		FC2_ERROR_STROBE_FAILED, /**< Strobe failure. */
		FC2_ERROR_TRIGGER_FAILED, /**< Trigger failure. */
		FC2_ERROR_PROPERTY_FAILED, /**< Property failure. */
		FC2_ERROR_PROPERTY_NOT_PRESENT, /**< Property is not present. */
		FC2_ERROR_REGISTER_FAILED, /**< Register access failed. */
		FC2_ERROR_READ_REGISTER_FAILED, /**< Register read failed. */
		FC2_ERROR_WRITE_REGISTER_FAILED, /**< Register write failed. */
		FC2_ERROR_ISOCH_FAILED, /**< Isochronous failure. */
		FC2_ERROR_ISOCH_ALREADY_STARTED, /**< Isochronous transfer has already been started. */
		FC2_ERROR_ISOCH_NOT_STARTED, /**< Isochronous transfer has not been started. */
		FC2_ERROR_ISOCH_START_FAILED, /**< Isochronous start failed. */
		FC2_ERROR_ISOCH_RETRIEVE_BUFFER_FAILED, /**< Isochronous retrieve buffer failed. */
		FC2_ERROR_ISOCH_STOP_FAILED, /**< Isochronous stop failed. */
		FC2_ERROR_ISOCH_SYNC_FAILED, /**< Isochronous image synchronization failed. */
		FC2_ERROR_ISOCH_BANDWIDTH_EXCEEDED, /**< Isochronous bandwidth exceeded. */
		FC2_ERROR_IMAGE_CONVERSION_FAILED, /**< Image conversion failed. */
		FC2_ERROR_IMAGE_LIBRARY_FAILURE, /**< Image library failure. */
		FC2_ERROR_BUFFER_TOO_SMALL, /**< Buffer is too small. */
		FC2_ERROR_IMAGE_CONSISTENCY_ERROR, /**< There is an image consistency error. */
		FC2_ERROR_INCOMPATIBLE_DRIVER, /**< The installed driver is not compatible with the library. */
		FC2_ERROR_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2Error;

	/** The type of bus callback to register a callback function for. */
	typedef enum _fc2BusCallbackType
	{
		FC2_BUS_RESET, /**< Register for all bus events. */
		FC2_ARRIVAL, /**< Register for arrivals only. */
		FC2_REMOVAL, /**< Register for removals only. */
		FC2_CALLBACK_TYPE_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2BusCallbackType;

	/**
	 * The grab strategy employed during image transfer. This type controls
	 * how images that stream off the camera accumulate in a user buffer
	 * for handling.
	 */
	/*
	   @remark Unlike earlier versions of the FlyCapture SDK, it is no longer
	 * necessary to explicitly start the image grabbing process before
	 * specifying an image grabbing mode.
	 */
	typedef enum _fc2GrabMode
	{
		/**
		 * Grabs the newest image in the user buffer each time the
		 * RetrieveBuffer() function is called. Older images are dropped
		 * instead of accumulating in the user buffer. Grabbing blocks if the
		 * camera has not finished transmitting the next available image. If
		 * the camera is transmitting images faster than the application can
		 * grab them, images may be dropped and only the most recent image
		 * is stored for grabbing. Note that this mode is the equivalent of
		 * flycaptureLockLatest in earlier versions of the FlyCapture SDK.
		 */
		FC2_DROP_FRAMES,

		/**
		 * Images accumulate in the user buffer, and the oldest image is
		 * grabbed for handling before being discarded. This member can be
		 * used to guarantee that each image is seen. However, image processing
		 * time must not exceed transmission time from the camera to the
		 * buffer. Grabbing blocks if the camera has not finished transmitting
		 * the next available image. The buffer size is controlled by the
		 * numBuffers parameter in the FC2Config struct. Note that this mode is
		 * the equivalent of flycaptureLockNext in earlier versions of the
		 * FlyCapture SDK.
		 */
		FC2_BUFFER_FRAMES,

		/**
		 * Unspecified grab mode.
		 */
		FC2_UNSPECIFIED_GRAB_MODE,
		FC2_GRAB_MODE_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2GrabMode;

	/** Timeout options for grabbing images. */
	typedef enum _fc2GrabTimeout
	{
		FC2_TIMEOUT_NONE = 0, /**< Non-blocking wait. */
		FC2_TIMEOUT_INFINITE = -1, /**< Wait indefinitely. */
		FC2_TIMEOUT_UNSPECIFIED = -2, /**< Unspecified timeout setting. */
		FC2_GRAB_TIMEOUT_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2GrabTimeout;

	/** Bandwidth allocation options for 1394 devices. */
	typedef enum _fc2BandwidthAllocation
	{
		/** Do not allocate bandwidth. */
		FC2_BANDWIDTH_ALLOCATION_OFF = 0,
		/** Allocate bandwidth. This is the default setting. */
		FC2_BANDWIDTH_ALLOCATION_ON = 1,
		/**
		 * Bandwidth allocation is not supported by either the camera or
		 * operating system.
		 */
		FC2_BANDWIDTH_ALLOCATION_UNSUPPORTED = 2,
		/** Not specified. This leaves the current setting unchanged. */
		FC2_BANDWIDTH_ALLOCATION_UNSPECIFIED = 3,
		FC2_BANDWIDTH_ALLOCATION_FORCE_32BITS = FULL_32BIT_VALUE

	}fc2BandwidthAllocation;

	/** Interfaces that a camera may use to communicate with a host. */
	typedef enum _fc2InterfaceType
	{
		FC2_INTERFACE_IEEE1394, /**< IEEE-1394 (Includes 1394a and 1394b). */
		FC2_INTERFACE_USB_2, /**< USB 2.0. */
		FC2_INTERFACE_USB_3, /**< USB 3.0. */
		FC2_INTERFACE_GIGE, /**< GigE. */
		FC2_INTERFACE_UNKNOWN, /**< Unknown interface. */
		FC2_INTERFACE_TYPE_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2InterfaceType;

	/**
	 * Camera properties. Not all properties may be supported, depending
	 * on the camera model.
	 */
	typedef enum _fc2PropertyType
	{
		FC2_BRIGHTNESS,
		FC2_AUTO_EXPOSURE,
		FC2_SHARPNESS,
		FC2_WHITE_BALANCE,
		FC2_HUE,
		FC2_SATURATION,
		FC2_GAMMA,
		FC2_IRIS,
		FC2_FOCUS,
		FC2_ZOOM,
		FC2_PAN,
		FC2_TILT,
		FC2_SHUTTER,
		FC2_GAIN,
		FC2_TRIGGER_MODE,
		FC2_TRIGGER_DELAY,
		FC2_FRAME_RATE,
		FC2_TEMPERATURE,
		FC2_UNSPECIFIED_PROPERTY_TYPE,
		FC2_PROPERTY_TYPE_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2PropertyType;

	/** Frame rates in frames per second. */
	typedef enum _fc2FrameRate
	{
		FC2_FRAMERATE_1_875, /**< 1.875 fps. */
		FC2_FRAMERATE_3_75, /**< 3.75 fps. */
		FC2_FRAMERATE_7_5, /**< 7.5 fps. */
		FC2_FRAMERATE_15, /**< 15 fps. */
		FC2_FRAMERATE_30, /**< 30 fps. */
		FC2_FRAMERATE_60, /**< 60 fps. */
		FC2_FRAMERATE_120, /**< 120 fps. */
		FC2_FRAMERATE_240, /**< 240 fps. */
		FC2_FRAMERATE_FORMAT7, /**< Custom frame rate for Format7 functionality. */
		FC2_NUM_FRAMERATES, /**< Number of possible camera frame rates. */
		FC2_FRAMERATE_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2FrameRate;

	/** DCAM video modes. */
	typedef enum _fc2VideoMode
	{
		FC2_VIDEOMODE_160x120YUV444, /**< 160x120 YUV444. */
		FC2_VIDEOMODE_320x240YUV422, /**< 320x240 YUV422. */
		FC2_VIDEOMODE_640x480YUV411, /**< 640x480 YUV411. */
		FC2_VIDEOMODE_640x480YUV422, /**< 640x480 YUV422. */
		FC2_VIDEOMODE_640x480RGB, /**< 640x480 24-bit RGB. */
		FC2_VIDEOMODE_640x480Y8, /**< 640x480 8-bit. */
		FC2_VIDEOMODE_640x480Y16, /**< 640x480 16-bit. */
		FC2_VIDEOMODE_800x600YUV422, /**< 800x600 YUV422. */
		FC2_VIDEOMODE_800x600RGB, /**< 800x600 RGB. */
		FC2_VIDEOMODE_800x600Y8, /**< 800x600 8-bit. */
		FC2_VIDEOMODE_800x600Y16, /**< 800x600 16-bit. */
		FC2_VIDEOMODE_1024x768YUV422, /**< 1024x768 YUV422. */
		FC2_VIDEOMODE_1024x768RGB, /**< 1024x768 RGB. */
		FC2_VIDEOMODE_1024x768Y8, /**< 1024x768 8-bit. */
		FC2_VIDEOMODE_1024x768Y16, /**< 1024x768 16-bit. */
		FC2_VIDEOMODE_1280x960YUV422, /**< 1280x960 YUV422. */
		FC2_VIDEOMODE_1280x960RGB, /**< 1280x960 RGB. */
		FC2_VIDEOMODE_1280x960Y8, /**< 1280x960 8-bit. */
		FC2_VIDEOMODE_1280x960Y16, /**< 1280x960 16-bit. */
		FC2_VIDEOMODE_1600x1200YUV422, /**< 1600x1200 YUV422. */
		FC2_VIDEOMODE_1600x1200RGB, /**< 1600x1200 RGB. */
		FC2_VIDEOMODE_1600x1200Y8, /**< 1600x1200 8-bit. */
		FC2_VIDEOMODE_1600x1200Y16, /**< 1600x1200 16-bit. */
		FC2_VIDEOMODE_FORMAT7, /**< Custom video mode for Format7 functionality. */
		FC2_NUM_VIDEOMODES, /**< Number of possible video modes. */
		FC2_VIDEOMODE_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2VideoMode;

	/** Camera modes for DCAM formats as well as Format7. */
	typedef enum _fc2Mode
	{
		FC2_MODE_0 = 0,
		FC2_MODE_1,
		FC2_MODE_2,
		FC2_MODE_3,
		FC2_MODE_4,
		FC2_MODE_5,
		FC2_MODE_6,
		FC2_MODE_7,
		FC2_MODE_8,
		FC2_MODE_9,
		FC2_MODE_10,
		FC2_MODE_11,
		FC2_MODE_12,
		FC2_MODE_13,
		FC2_MODE_14,
		FC2_MODE_15,
		FC2_MODE_16,
		FC2_MODE_17,
		FC2_MODE_18,
		FC2_MODE_19,
		FC2_MODE_20,
		FC2_MODE_21,
		FC2_MODE_22,
		FC2_MODE_23,
		FC2_MODE_24,
		FC2_MODE_25,
		FC2_MODE_26,
		FC2_MODE_27,
		FC2_MODE_28,
		FC2_MODE_29,
		FC2_MODE_30,
		FC2_MODE_31,
		FC2_NUM_MODES, /**< Number of modes */
		FC2_MODE_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2Mode;

	/** Pixel formats available for Format7 modes. */
	typedef enum _fc2PixelFormat
	{
		FC2_PIXEL_FORMAT_MONO8			= 0x80000000, /**< 8 bits of mono information. */
		FC2_PIXEL_FORMAT_411YUV8		= 0x40000000, /**< YUV 4:1:1. */
		FC2_PIXEL_FORMAT_422YUV8		= 0x20000000, /**< YUV 4:2:2. */
		FC2_PIXEL_FORMAT_444YUV8		= 0x10000000, /**< YUV 4:4:4. */
		FC2_PIXEL_FORMAT_RGB8			= 0x08000000, /**< R = G = B = 8 bits. */
		FC2_PIXEL_FORMAT_MONO16			= 0x04000000, /**< 16 bits of mono information. */
		FC2_PIXEL_FORMAT_RGB16			= 0x02000000, /**< R = G = B = 16 bits. */
		FC2_PIXEL_FORMAT_S_MONO16		= 0x01000000, /**< 16 bits of signed mono information. */
		FC2_PIXEL_FORMAT_S_RGB16		= 0x00800000, /**< R = G = B = 16 bits signed. */
		FC2_PIXEL_FORMAT_RAW8			= 0x00400000, /**< 8 bit raw data output of sensor. */
		FC2_PIXEL_FORMAT_RAW16			= 0x00200000, /**< 16 bit raw data output of sensor. */
		FC2_PIXEL_FORMAT_MONO12			= 0x00100000, /**< 12 bits of mono information. */
		FC2_PIXEL_FORMAT_RAW12			= 0x00080000, /**< 12 bit raw data output of sensor. */
		FC2_PIXEL_FORMAT_BGR			= 0x80000008, /**< 24 bit BGR. */
		FC2_PIXEL_FORMAT_BGRU			= 0x40000008, /**< 32 bit BGRU. */
		FC2_PIXEL_FORMAT_RGB			= FC2_PIXEL_FORMAT_RGB8, /**< 24 bit RGB. */
		FC2_PIXEL_FORMAT_RGBU			= 0x40000002, /**< 32 bit RGBU. */
		FC2_PIXEL_FORMAT_BGR16			= 0x02000001, /**< R = G = B = 16 bits. */
		FC2_PIXEL_FORMAT_BGRU16			= 0x02000002, /**< 64 bit BGRU. */
		FC2_PIXEL_FORMAT_422YUV8_JPEG	= 0x40000001, /**< JPEG compressed stream. */
		FC2_NUM_PIXEL_FORMATS			=  20, /**< Number of pixel formats. */
		FC2_UNSPECIFIED_PIXEL_FORMAT	= 0 /**< Unspecified pixel format. */

	} fc2PixelFormat;

	/** Bus speeds. */
	typedef enum _fc2BusSpeed
	{
		FC2_BUSSPEED_S100, /**< 100Mbits/sec. */
		FC2_BUSSPEED_S200, /**< 200Mbits/sec. */
		FC2_BUSSPEED_S400, /**< 400Mbits/sec. */
		FC2_BUSSPEED_S480, /**< 480Mbits/sec. Only for USB2 cameras. */
		FC2_BUSSPEED_S800, /**< 800Mbits/sec. */
		FC2_BUSSPEED_S1600, /**< 1600Mbits/sec. */
		FC2_BUSSPEED_S3200, /**< 3200Mbits/sec. */
		FC2_BUSSPEED_S5000, /**< 5000Mbits/sec. Only for USB3 cameras. */
		FC2_BUSSPEED_10BASE_T, /**< 10Base-T. Only for GigE cameras. */
		FC2_BUSSPEED_100BASE_T, /**< 100Base-T.  Only for GigE cameras.*/
		FC2_BUSSPEED_1000BASE_T, /**< 1000Base-T (Gigabit Ethernet).  Only for GigE cameras. */
		FC2_BUSSPEED_10000BASE_T, /**< 10000Base-T.  Only for GigE cameras. */
		FC2_BUSSPEED_S_FASTEST, /**< The fastest speed available. */
		FC2_BUSSPEED_ANY, /**< Any speed that is available. */
		FC2_BUSSPEED_SPEED_UNKNOWN = -1, /**< Unknown bus speed. */
		FC2_BUSSPEED_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2BusSpeed;

	typedef enum _fc2PCIeBusSpeed
	{
		FC2_PCIE_BUSSPEED_2_5, /** 2.5 Gb/s */
		FC2_PCIE_BUSSPEED_5_0, /** 5.0 Gb/s */
		FC2_PCIE_BUSSPEED_UNKNOWN = -1, /** Speed is unknown */
		FC2_PCIE_BUSSPEED_FORCE_32BITS = FULL_32BIT_VALUE
	} fc2PCIeBusSpeed;

	/** Types of low level drivers that FlyCapture uses. */
	typedef enum _fc2DriverType
	{
		FC2_DRIVER_1394_CAM, /**< PGRCam.sys. */
		FC2_DRIVER_1394_PRO, /**< PGR1394.sys. */
		FC2_DRIVER_1394_JUJU, /**< firewire_core. */
		FC2_DRIVER_1394_VIDEO1394, /**< video1394. */
		FC2_DRIVER_1394_RAW1394, /**< raw1394. */
		FC2_DRIVER_USB_NONE, /**< No usb driver used just BSD stack. (Linux only) */
		FC2_DRIVER_USB_CAM, /**< PGRUsbCam.sys. */
		FC2_DRIVER_USB3_PRO, /**< PGRXHCI.sys. */
		FC2_DRIVER_GIGE_NONE, /**< no GigE drivers used, MS/BSD stack. */
		FC2_DRIVER_GIGE_FILTER, /**< PGRGigE.sys. */
		FC2_DRIVER_GIGE_PRO, /**< PGRGigEPro.sys. */
		FC2_DRIVER_GIGE_LWF, /**< PgrLwf.sys. */
		FC2_DRIVER_UNKNOWN = -1, /**< Unknown driver type. */
		FC2_DRIVER_FORCE_32BITS = FULL_32BIT_VALUE
	} fc2DriverType;

	/**
	 * Color processing algorithms. Please refer to our knowledge base at
	 * article at http://www.ptgrey.com/support/kb/index.asp?a=4&q=33 for
	 * complete details for each algorithm.
	 */
	typedef enum _fc2ColorProcessingAlgorithm
	{
		/** Default method. */
		FC2_DEFAULT,
		/** No color processing. */
		FC2_NO_COLOR_PROCESSING,
		/**
		 * Fastest but lowest quality. Equivalent to
		 * FLYCAPTURE_NEAREST_NEIGHBOR_FAST in FlyCapture.
		 */
		FC2_NEAREST_NEIGHBOR_FAST,
		/** Weights surrounding pixels based on localized edge orientation. */
		FC2_EDGE_SENSING,
		/** Well-balanced speed and quality. */
		FC2_HQ_LINEAR,
		/** Slowest but produces good results. */
		FC2_RIGOROUS,
		/** Multithreaded with similar results to edge sensing. */
		FC2_IPP,
		/** Best quality but much faster than rigorous. */
		FC2_DIRECTIONAL,
		/** Weighted pixel average from different directions*/
		FC2_WEIGHTED_DIRECTIONAL,
		FC2_COLOR_PROCESSING_ALGORITHM_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2ColorProcessingAlgorithm;

	/** Bayer tile formats. */
	typedef enum _fc2BayerTileFormat
	{
		FC2_BT_NONE, /**< No bayer tile format. */
		FC2_BT_RGGB, /**< Red-Green-Green-Blue. */
		FC2_BT_GRBG, /**< Green-Red-Blue-Green. */
		FC2_BT_GBRG, /**< Green-Blue-Red-Green. */
		FC2_BT_BGGR, /**< Blue-Green-Green-Red. */
		FC2_BT_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2BayerTileFormat;

	/** File formats to be used for saving images to disk. */
	typedef enum _fc2ImageFileFormat
	{
		FC2_FROM_FILE_EXT = -1, /**< Determine file format from file extension. */
		FC2_PGM, /**< Portable gray map. */
		FC2_PPM, /**< Portable pixmap. */
		FC2_BMP, /**< Bitmap. */
		FC2_JPEG, /**< JPEG. */
		FC2_JPEG2000, /**< JPEG 2000. */
		FC2_TIFF, /**< Tagged image file format. */
		FC2_PNG, /**< Portable network graphics. */
		FC2_RAW, /**< Raw data. */
		FC2_IMAGE_FILE_FORMAT_FORCE_32BITS = FULL_32BIT_VALUE

	} fc2ImageFileFormat;

	/*@}*/

	/**
	 * @defgroup CGigEEnums GigE specific enumerations
	 *
	 * These enumerations are specific to GigE camera operation only.
	 */

	/*@{*/

	/** Possible properties that can be queried from the camera. */
	typedef enum _fc2GigEPropertyType
	{
		FC2_HEARTBEAT,
		FC2_HEARTBEAT_TIMEOUT,
		PACKET_SIZE,
		PACKET_DELAY

	} fc2GigEPropertyType;

	/*@}*/

	/**
	 * Channels that allow statistics to be calculated.
	 */
	typedef enum _fc2StatisticsChannel
	{
		FC2_STATISTICS_GREY,
		FC2_STATISTICS_RED,
		FC2_STATISTICS_GREEN,
		FC2_STATISTICS_BLUE,
		FC2_STATISTICS_HUE,
		FC2_STATISTICS_SATURATION,
		FC2_STATISTICS_LIGHTNESS,
		FC2_STATISTICS_FORCE_32BITS = FULL_32BIT_VALUE
	} fc2StatisticsChannel;

	/** Possible operating systems. */
	typedef enum _fc2OSType
	{
		FC2_WINDOWS_X86, /**< All Windows 32-bit variants. */
		FC2_WINDOWS_X64, /**< All Windows 64-bit variants. */
		FC2_LINUX_X86, /**< All Linux 32-bit variants. */
		FC2_LINUX_X64, /**< All Linux 32-bit variants. */
		FC2_MAC, /**< Mac OSX. */
		FC2_UNKNOWN_OS, /**< Unknown operating system. */
		FC2_OSTYPE_FORCE_32BITS = FULL_32BIT_VALUE
	} fc2OSType;

	/** Possible byte orders. */
	typedef enum _fc2ByteOrder
	{
		FC2_BYTE_ORDER_LITTLE_ENDIAN,
		FC2_BYTE_ORDER_BIG_ENDIAN,
		FC2_BYTE_ORDER_FORCE_32BITS = FULL_32BIT_VALUE
	} fc2ByteOrder;

	/**
	 * Possible states of a port on a node.
	 */
	typedef enum _fc2PortType
	{
		NOT_CONNECTED = 1,
		CONNECTED_TO_PARENT,
		CONNECTED_TO_CHILD
	} fc2PortType;

	/**
	 * Type of node.
	 */
	typedef enum _fc2NodeType
	{
		COMPUTER,
		BUS,
		CAMERA,
		NODE
	} fc2NodeType;

	/**
	 * @defgroup CStructures Structures
	 */

	/*@{*/

	//
	// Description:
	//	 An image. It is comparable to the Image class in the C++ library.
	//   The fields in this structure should be considered read only.
	//
	typedef struct _fc2Image
	{
		unsigned int rows;
		unsigned int cols;
		unsigned int stride;
		unsigned char* pData;
		unsigned int dataSize;
		unsigned int receivedDataSize;
		fc2PixelFormat format;
		fc2BayerTileFormat bayerFormat;

		fc2ImageImpl imageImpl;

	} fc2Image;

	/** Description of the system. */
	typedef struct _fc2SystemInfo
	{
		/** Operating system type as described by OSType. */
		fc2OSType osType;

		/** Detailed description of the operating system. */
		char osDescription[ MAX_STRING_LENGTH];

		/** Byte order of the system. */
		fc2ByteOrder byteOrder;

		/** Amount of memory available on the system. */
		size_t	sysMemSize;

		/** Detailed description of the CPU. */
		char cpuDescription[ MAX_STRING_LENGTH];

		/** Number of cores on all CPUs on the system. */
		size_t	numCpuCores;

		/** List of drivers used. */
		char driverList[ MAX_STRING_LENGTH];

		/** List of libraries used. */
		char libraryList[ MAX_STRING_LENGTH];

		/** Detailed description of the GPU. */
		char gpuDescription[ MAX_STRING_LENGTH];

		/** Screen resolution width in pixels. */
		size_t screenWidth;

		/** Screen resolution height in pixels. */
		size_t screenHeight;

		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2SystemInfo;

	/** The current version of the library. */
	typedef struct _fc2Version
	{
		unsigned int major; /**< Major version number. */
		unsigned int minor; /**< Minor version number. */
		unsigned int type; /**< Type version number. */
		unsigned int build; /**< Build version number. */
	} fc2Version;

	/**
	 * @defgroup CGigEStructures GigE specific structures
	 *
	 * These structures are specific to GigE camera operation only.
	 */

	/*@{*/

	/** IPv4 address. */
	typedef struct _fc2IPAddress
	{
		unsigned char octets[4];
	} fc2IPAddress;

	/** MAC address. */
	typedef struct _fc2MACAddress
	{
		unsigned char octets[6];
	} fc2MACAddress;

	/** A GigE property. */
	typedef struct _fc2GigEProperty
	{
		/** The type of property. */
		fc2GigEPropertyType propType;
		/**
		 * Whether the property is readable. If this is false, then
		 * no other value in this structure is valid.
		 */
		BOOL isReadable;
		/** Whether the property is writable. */
		BOOL isWritable;
		/** Minimum value. */
		unsigned int min;
		/** Maximum value. */
		unsigned int max;
		/** Current value. */
		unsigned int value;

		unsigned int reserved[8];
	} fc2GigEProperty;

	/** Information about a single GigE stream channel. */
	typedef struct _fc2GigEStreamChannel
	{
		/** Network interface index used (or to use). */
		unsigned int networkInterfaceIndex;
		/** Host port on the PC where the camera will send the data stream. */
		unsigned int hostPort;
		/** Disable IP fragmentation of packets. */
		BOOL doNotFragment;
		/** Packet size, in bytes. */
		unsigned int packetSize;
		/** Inter packet delay, in timestamp counter units. */
		unsigned int interPacketDelay;
		/** Destination IP address. It can be a multicast or unicast address. */
		fc2IPAddress destinationIpAddress;
		/** Source UDP port of the stream channel. Read only. */
		unsigned int sourcePort;

		unsigned int reserved[8];
	} fc2GigEStreamChannel;

	/**
	 * Configuration for a GigE camera.  These options are options that are
	 * generally should be set before starting isochronous transfer.
	 */
	typedef struct _fc2GigEConfig
	{
		/** Turn on/off packet resend functionality */
		BOOL enablePacketResend;

		/**
		 * Number of retries to perform when a register read/write timeout
		 * is received by the library. The default value is 0.
		 */
		unsigned int registerTimeoutRetries;

		/**
		 * Register read/write timeout value, in microseconds.
		 * The default value is dependent on the interface type.
		 */
		unsigned int registerTimeout;

		unsigned int reserved[8];
	} fc2GigEConfig;

	/** Format 7 information for a single mode. */
	typedef struct _fc2GigEImageSettingsInfo
	{
		/** Maximum image width. */
		unsigned int maxWidth;
		/** Maximum image height. */
		unsigned int maxHeight;
		/** Horizontal step size for the offset. */
		unsigned int offsetHStepSize;
		/** Vertical step size for the offset. */
		unsigned int offsetVStepSize;
		/** Horizontal step size for the image. */
		unsigned int imageHStepSize;
		/** Vertical step size for the image. */
		unsigned int imageVStepSize;
		/** Supported pixel formats in a bit field. */
		unsigned int pixelFormatBitField;
		/** Vendor unique pixel formats in a bit field. */
		unsigned int vendorPixelFormatBitField;
		/** Reserved for future use. */
		unsigned int reserved[16];
	} fc2GigEImageSettingsInfo;

	/** Image settings for a GigE camera. */
	typedef struct _fc2GigEImageSettings
	{
		/** Horizontal image offset. */
		unsigned int offsetX;
		/** Vertical image offset. */
		unsigned int offsetY;
		/** Width of image. */
		unsigned int width;
		/** Height of image. */
		unsigned int height;
		/** Pixel format of image. */
		fc2PixelFormat pixelFormat;
		/** Reserved for future use. */
		unsigned int reserved[8];
	} fc2GigEImageSettings;

	/*@}*/

	/**
	 * @defgroup CIIDCStructures IIDC specific structures
	 *
	 * These structures are specific to IIDC camera operation only.
	 */

	/*@{*/

	/** Format 7 image settings. */
	typedef struct _fc2Format7ImageSettings
	{
		/** Format 7 mode. */
		fc2Mode mode;
		/** Horizontal image offset. */
		unsigned int offsetX;
		/** Vertical image offset. */
		unsigned int offsetY;
		/** Width of image. */
		unsigned int width;
		/** Height of image. */
		unsigned int height;
		/** Pixel format of image. */
		fc2PixelFormat pixelFormat;
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2Format7ImageSettings;

	/** Format 7 information for a single mode. */
	typedef struct _fc2Format7Info
	{
		/** Format 7 mode. */
		fc2Mode         mode;

		/** Maximum image width. */
		unsigned int maxWidth;
		/** Maximum image height. */
		unsigned int maxHeight;
		/** Horizontal step size for the offset. */
		unsigned int offsetHStepSize;
		/** Vertical step size for the offset. */
		unsigned int offsetVStepSize;
		/** Horizontal step size for the image. */
		unsigned int imageHStepSize;
		/** Vertical step size for the image. */
		unsigned int imageVStepSize;
		/** Supported pixel formats in a bit field. */
		unsigned int pixelFormatBitField;
		/** Vendor unique pixel formats in a bit field. */
		unsigned int vendorPixelFormatBitField;
		/** Current packet size in bytes. */
		unsigned int packetSize;
		/** Minimum packet size in bytes for current mode. */
		unsigned int minPacketSize;
		/** Maximum packet size in bytes for current mode. */
		unsigned int maxPacketSize;
		/** Current packet size as a percentage of maximum packet size. */
		float percentage;
		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2Format7Info;

	/** Format 7 packet information. */
	typedef struct _fc2Format7PacketInfo
	{
		/** Recommended bytes per packet. */
		unsigned int recommendedBytesPerPacket;
		/** Maximum bytes per packet. */
		unsigned int maxBytesPerPacket;
		/** Minimum bytes per packet. */
		unsigned int unitBytesPerPacket;
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2Format7PacketInfo;

	/*@}*/

	/**
	 * Configuration for a camera. These options are options that are
	 * generally should be set before starting isochronous transfer.
	 */
	typedef struct _fc2Config
	{
		/** Number of buffers used by the FlyCapture2 library to grab images. */
		unsigned int numBuffers;

		/**
		 * Number of notifications per image. This value should only be set
		 * after the image settings to be used is set to the camera.
		 * The default number of notifications is 1.
		 *
		 * There are 4 general scenarios:
		 * - 1 notification - End of image
		 * - 2 notifications - After first packet and end of image
		 * - 3 notifications - After first packet, middle of image, end of image
		 * - x notifications - After first packet, (x -2) spread evenly, end of image
		 *
		 * Specifying zero for the number of notifications will be ignored (the current value
		 * will not be modified).
		 *
		 * Note that the event numbers start at 0. Ex. when 3 notifications are
		 * used, the three events will be 0, 1 and 2.
		 */
		unsigned int numImageNotifications;

		/**
		 *  Minimum number of notifications needed for the current image
		 *  settings on the camera. Read-only value.
		 */
		unsigned int minNumImageNotifications;

		/**
		 * Time in milliseconds that RetrieveBuffer() and WaitForBufferEvent()
		 * will wait for an image before timing out and returning.
		 */
		int grabTimeout;

		/** Grab mode for the camera. The default is DROP_FRAMES. */
		fc2GrabMode grabMode;

		/** This parameter enables RetrieveBuffer to run in high
		 *	performance mode.  This means that any interaction
		 *  with the camera, other than grabbing the image is disabled.
		 *	Currently Retrieve buffer reads registers on the camera to
		 *	determine which embedded image information settings have been
		 *	enabled, and it reads what the bayer tile is currently set to.
		 *	When High Performance mode is on, these reads are disabled.  This
		 *	means that any changes to the Bayer Tile or to the Embedded image
		 *	info after StartCapture() will not be tracked when made using
		 *	direct register writes.  If the corresponding SetEmbededImageInfo()
		 *	and GetEmbededImageInfo() calls are used then the changes will be
		 *	appropriately reflected.  This also means that changes to embedded
		 *	image info from other processes will not be updated either. */
		BOOL highPerformanceRetrieveBuffer;

		/** Isochronous bus speed. */
		fc2BusSpeed isochBusSpeed;

		/** Asynchronous bus speed. */
		fc2BusSpeed asyncBusSpeed;

		/**
		 * Bandwidth allocation flag that tells the camera the bandwidth
		 * allocation strategy to employ.
		 */
		fc2BandwidthAllocation bandwidthAllocation;

		/**
		 * Number of retries to perform when a register read/write timeout
		 * is received by the library. The default value is 0.
		 */
		unsigned int registerTimeoutRetries;

		/**
		 * Register read/write timeout value, in microseconds.
		 * The default value is dependent on the interface type.
		 */
		unsigned int registerTimeout;

		/** Reserved for future use */
		unsigned int reserved[16];

	} fc2Config;

	/**
	 * Information about a specific camera property. This structure is also
	 * also used as the TriggerDelayInfo structure.
	 */
	typedef struct _fc2PropertyInfo
	{
		/** Property info type. */
		fc2PropertyType type;
		/** Flag indicating if the property is present. */
		BOOL present;
		/** Flag indicating if auto is supported. */
		BOOL autoSupported;
		/** Flag indicating if manual is supported. */
		BOOL manualSupported;
		/** Flag indicating if on/off is supported. */
		BOOL onOffSupported;
		/** Flag indicating if one push is supported. */
		BOOL onePushSupported;
		/** Flag indicating if absolute mode is supported. */
		BOOL absValSupported;
		/** Flag indicating if property value can be read out. */
		BOOL readOutSupported;
		/** Minimum value (as an integer). */
		unsigned int min;
		/** Maximum value (as an integer). */
		unsigned int max;
		/** Minimum value (as a floating point value). */
		float absMin;
		/** Maximum value (as a floating point value). */
		float absMax;
		/** Textual description of units. */
		char pUnits[MAX_STRING_LENGTH];
		/** Abbreviated textual description of units. */
		char pUnitAbbr[MAX_STRING_LENGTH];
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2PropertyInfo, fc2TriggerDelayInfo;

	/**
	 * A specific camera property. \n
	 * For example, to set the gain to 12dB, set the following values:
	 * - \a type - \c GAIN
	 * - \a absControl - \c true
	 * - \a onePush - \c false
	 * - \a onOff - \c true
	 * - \a autoManualMode - \c false
	 * - \a absValue - \c 12.0
	 */
	typedef struct _Property
	{
		/** Property info type. */
		fc2PropertyType   type;
		/** Flag indicating if the property is present. */
		BOOL present;
		/**
         * Flag controlling absolute mode (real world units)
         * or non-absolute mode (camera internal units).
         */
		BOOL absControl;
		/** Flag controlling one push. */
		BOOL onePush;
		/** Flag controlling on/off. */
		BOOL onOff;
		/** Flag controlling auto. */
		BOOL autoManualMode;
		/**
         * Value A (integer).
         * Used to configure properties in non-absolute mode.
         */
		unsigned int valueA;
		/**
         * Value B (integer). For white balance, value B applies to the blue value and
         * value A applies to the red value.
         */
		unsigned int valueB;
		/**
		* Floating point value.
		* Used to configure properties in absolute mode.
		*/
		float absValue;
		/** Reserved for future use. */
		unsigned int reserved[8];

		// For convenience, trigger delay is the same structure
		// used in a separate function along with trigger mode.

	} fc2Property, fc2TriggerDelay;

	/** Information about a camera trigger property. */
	typedef struct _fc2TriggerModeInfo
	{
		/** Presence of trigger mode. */
		BOOL present;
		/** Flag indicating if trigger value can be read out. */
		BOOL readOutSupported;
		/** Flag indicating if on/off is supported. */
		BOOL onOffSupported;
		/** Flag indicating if polarity is supported. */
		BOOL polaritySupported;
		/** Flag indicating if the value is readable. */
		BOOL valueReadable;
		/** Source mask. */
		unsigned int sourceMask;
		/** Flag indicating if software trigger is supported. */
		BOOL softwareTriggerSupported;
		/** Mode mask. */
		unsigned int modeMask;
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2TriggerModeInfo;

	/** A camera trigger. */
	typedef struct _fc2TriggerMode
	{
		/** Flag controlling on/off. */
		BOOL onOff;
		/** Polarity value. */
		unsigned int polarity;
		/** Source value. */
		unsigned int source;
		/** Mode value. */
		unsigned int mode;
		/** Parameter value. */
		unsigned int parameter;
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2TriggerMode;

	/** A camera strobe property. */
	typedef struct _fc2StrobeInfo
	{
		/** Source value. */
		unsigned int source;
		/** Presence of strobe. */
		BOOL present;
		/** Flag indicating if strobe value can be read out. */
		BOOL readOutSupported;
		/** Flag indicating if on/off is supported. */
		BOOL onOffSupported;
		/** Flag indicating if polarity is supported. */
		BOOL polaritySupported;
		/** Minimum value. */
		float minValue;
		/** Maximum value. */
		float maxValue;
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2StrobeInfo;

	/** A camera strobe. */
	typedef struct _fc2StrobeControl
	{
		/** Source value. */
		unsigned int source;
		/** Flag controlling on/off. */
		BOOL onOff;
		/** Signal polarity. */
		unsigned int polarity;
		/** Signal delay (in ms). */
		float delay;
		/** Signal duration (in ms). */
		float duration;
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2StrobeControl;

	/** Timestamp information. */
	typedef struct _fc2TimeStamp
	{
		/** Seconds. */
		long long seconds;
		/** Microseconds. */
		unsigned int microSeconds;
		/** 1394 cycle time seconds. */
		unsigned int cycleSeconds;
		/** 1394 cycle time count. */
		unsigned int cycleCount;
		/** 1394 cycle time offset. */
		unsigned int cycleOffset;
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2TimeStamp;

	/** Camera configuration ROM. */
	typedef struct _fc2ConfigROM
	{
		/** Vendor ID of a node. */
		unsigned int nodeVendorId;
		/** Chip ID (high part). */
		unsigned int chipIdHi;
		/** Chip ID (low part). */
		unsigned int chipIdLo;
		/** Unit Spec ID, usually 0xa02d. */
		unsigned int unitSpecId;
		/** Unit software version. */
		unsigned int unitSWVer;
		/** Unit sub software version. */
		unsigned int unitSubSWVer;
		/** Vendor unique info 0. */
		unsigned int vendorUniqueInfo_0;
		/** Vendor unique info 1. */
		unsigned int vendorUniqueInfo_1;
		/** Vendor unique info 2. */
		unsigned int vendorUniqueInfo_2;
		/** Vendor unique info 3. */
		unsigned int vendorUniqueInfo_3;
		/** Keyword. */
		char pszKeyword[ MAX_STRING_LENGTH ];
		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2ConfigROM;

	/** Camera information. */
	typedef struct _fc2CameraInfo
	{
		/** Device serial number. */
		unsigned int serialNumber;
		/** Interface type. */
		fc2InterfaceType interfaceType;
		/** Driver type. */
		fc2DriverType driverType;
		/** Flag indicating if this is a color camera. */
		BOOL isColorCamera;
		/** Device model name. */
		char modelName[ MAX_STRING_LENGTH];
		/** Device vendor name. */
		char vendorName[ MAX_STRING_LENGTH];
		/** String detailing the sensor information. */
		char sensorInfo[ MAX_STRING_LENGTH];
		/** String providing the sensor resolution. */
		char sensorResolution[ MAX_STRING_LENGTH];
		/** Driver name of driver being used. */
		char driverName[ MAX_STRING_LENGTH];
		/** Firmware version of camera. */
		char firmwareVersion[ MAX_STRING_LENGTH];
		/** Firmware build time. */
		char firmwareBuildTime[ MAX_STRING_LENGTH];
		/** Maximum bus speed. */
		fc2BusSpeed maximumBusSpeed;
		/** Bayer tile format. */
		fc2BayerTileFormat bayerTileFormat;
		/** Bus number, set to 0 for GigE and USB cameras **/
		fc2PCIeBusSpeed pcieBusSpeed;
		/** ieee1394 Node number, set to 0 for GigE and USB cameras **/
		unsigned short nodeNumber;
		/** PCIe Bus Speed, set to PCIE_BUSSPEED_UNKNOWN for unsupported drivers **/
		unsigned short busNumber;

		/** @name IIDC specific information */
		/*@{*/
		/** DCAM version. */
		unsigned int iidcVer;
		/** Configuration ROM data. */
		fc2ConfigROM configROM;
		/*@}*/

		/** @name GigE specific information */
		/*@{*/
		/** GigE Vision version. */
		unsigned int gigEMajorVersion;
		/** GigE Vision minor version. */
		unsigned int gigEMinorVersion;
		/** User defined name. */
		char userDefinedName[ MAX_STRING_LENGTH];
		/** XML URL 1. */
		char xmlURL1[ MAX_STRING_LENGTH];
		/** XML URL 2. */
		char xmlURL2[ MAX_STRING_LENGTH];
		/** MAC address */
		fc2MACAddress macAddress;
		/** IP address. */
		fc2IPAddress ipAddress;
		/** Subnet mask. */
		fc2IPAddress subnetMask;
		/** Default gateway. */
		fc2IPAddress defaultGateway;
		/** Status/Content of CCP register */
		unsigned int ccpStatus;
		/** Local Application IP Address. */
		unsigned int applicationIPAddress;
		/** Local Application port. */
		unsigned int applicationPort;
		/*@}*/

		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2CameraInfo;

	/** Properties of a single embedded image info property. */
	typedef struct _fc2EmbeddedImageInfoProperty
	{
		/** Whether this property is available. */
		BOOL available;
		/** Whether this property is on or off. */
		BOOL onOff;

	} fc2EmbeddedImageInfoProperty;

	/** Properties of the possible embedded image information. */
	typedef struct _fc2EmbeddedImageInfo
	{
		fc2EmbeddedImageInfoProperty timestamp;
		fc2EmbeddedImageInfoProperty gain;
		fc2EmbeddedImageInfoProperty shutter;
		fc2EmbeddedImageInfoProperty brightness;
		fc2EmbeddedImageInfoProperty exposure;
		fc2EmbeddedImageInfoProperty whiteBalance;
		fc2EmbeddedImageInfoProperty frameCounter;
		fc2EmbeddedImageInfoProperty strobePattern;
		fc2EmbeddedImageInfoProperty GPIOPinState;
		fc2EmbeddedImageInfoProperty ROIPosition;

	} fc2EmbeddedImageInfo;

	/** Metadata related to an image. */
	typedef struct _fc2ImageMetadata
	{
		/** Embedded timestamp. */
		unsigned int embeddedTimeStamp;
		/** Embedded gain. */
		unsigned int embeddedGain;
		/** Embedded shutter. */
		unsigned int embeddedShutter;
		/** Embedded brightness. */
		unsigned int embeddedBrightness;
		/** Embedded exposure. */
		unsigned int embeddedExposure;
		/** Embedded white balance. */
		unsigned int embeddedWhiteBalance;
		/** Embedded frame counter. */
		unsigned int embeddedFrameCounter;
		/** Embedded strobe pattern. */
		unsigned int embeddedStrobePattern;
		/** Embedded GPIO pin state. */
		unsigned int embeddedGPIOPinState;
		/** Embedded ROI position. */
		unsigned int embeddedROIPosition;
		/** Reserved for future use. */
		unsigned int reserved[31];

	} fc2ImageMetadata;

	/** Information about the camera's look up table. */
	typedef struct _fc2LUTData
	{
		/** Flag indicating if LUT is supported. */
		BOOL supported;
		/** Flag indicating if LUT is enabled. */
		BOOL enabled;
		/** The number of LUT banks available (Always 1 for PGR LUT). */
		unsigned int numBanks;
		/** The number of LUT channels per bank available. */
		unsigned int numChannels;
		/** The input bit depth of the LUT. */
		unsigned int inputBitDepth;
		/** The output bit depth of the LUT. */
		unsigned int outputBitDepth;
		/** The number of entries in the LUT. */
		unsigned int numEntries;
		/** Reserved for future use. */
		unsigned int reserved[8];

	} fc2LUTData;

	/** Camera diagnostic information. */
	typedef struct _fc2CameraStats
	{
		/* Number of dropped images in DROP_IMAGE mode */
		unsigned int imageDropped;
		/* Number of corrupt images, such as missing packet, zero packet */
		unsigned int imageCorrupt;
		/* Number of transmissions failed of camera */
		unsigned int imageXmitFailed;
		/* Number of images dropped in driver */
		unsigned int imageDriverDropped;
		/* Errors of register reading */
		unsigned int regReadFailed;
		/* Errors of register writing */
		unsigned int regWriteFailed;
		/* Port errors */
		unsigned int portErrors;

		/* The value of the camera power register.
		 * false: Camera is powered down.
		 * true: Camera is powered up.
		 */
		BOOL cameraPowerUp;

		/* The voltage values of the various voltage registers
		 * supported by the camera.
		 */
		float cameraVoltages[8];

		/** The number of voltage registers available.
		 * 0: the values in cameraVoltages[] are invalid.
		 */
		unsigned int numVoltages;

		/* The current values of the various current registers
		 * supported by the camera.
		 */
		float cameraCurrents[8];

		/** The number of current registers available.
		 * 0: the values in cameraCurrents[] are invalid.
		 */
		unsigned int numCurrents;

		/* The temperature of the camera board-level components. The value is
		 * in kelvins (0°C = 273.15K) and are in one-tenths (0.1) of a kelvin.
		 */
		unsigned int temperature;

		/* Time in seconds since the camera was initialized. */
		unsigned int timeSinceInitialization;
		/* Time in seconds since the camera detected a bus reset. */
		unsigned int timeSinceBusReset;
		/* Time stamp */
		fc2TimeStamp timeStamp;
		/* Number of packets requested for resend */
		unsigned int numResendPacketsRequested;
		/* Number of packet-resend packets received */
		unsigned int numResendPacketsReceived;
		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2CameraStats;

	/**
	 * @defgroup CImageSaveStructures Image saving structures.
	 *
	 * These structures define various parameters used for saving images.
	 */

	/*@{*/

	/** Options for saving PNG images. */
	typedef struct _fc2PNGOption
	{
		/** Whether to save the PNG as interlaced. */
		BOOL interlaced;
		/** Compression level (0-9). 0 is no compression, 9 is best compression. */
		unsigned int compressionLevel;
		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2PNGOption;

	/** Options for saving PPM images. */
	typedef struct _fc2PPMOption
	{
		/** Whether to save the PPM as a binary file. */
		BOOL binaryFile;
		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2PPMOption ;

	/** Options for saving PGM images. */
	typedef struct _fc2PGMOption
	{
		/** Whether to save the PPM as a binary file. */
		BOOL binaryFile;
		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2PGMOption;

	typedef enum _fc2TIFFCompressionMethod
	{
		FC2_TIFF_NONE = 1, /**< Save without any compression. */
		FC2_TIFF_PACKBITS, /**< Save using PACKBITS compression. */
		FC2_TIFF_DEFLATE, /**< Save using DEFLATE compression (ZLIB compression). */
		FC2_TIFF_ADOBE_DEFLATE, /**< Save using ADOBE DEFLATE compression */
		/**
		 * Save using CCITT Group 3 fax encoding. This is only valid for
		 * 1-bit images only. Default to LZW for other bit depths.
		 */
		FC2_TIFF_CCITTFAX3,
		/**
		 * Save using CCITT Group 4 fax encoding. This is only valid for
		 * 1-bit images only. Default to LZW for other bit depths.
		 */
		FC2_TIFF_CCITTFAX4,
		FC2_TIFF_LZW, /**< Save using LZW compression. */
		/**
		 * Save using JPEG compression. This is only valid for 8-bit
		 * greyscale and 24-bit only. Default to LZW for other bit depths.
		 */
		FC2_TIFF_JPEG,
	} fc2TIFFCompressionMethod;

	/** Options for saving TIFF images. */
	typedef struct _fc2TIFFOption
	{
		/** Compression method to use for encoding TIFF images. */
		fc2TIFFCompressionMethod compression;
		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2TIFFOption;

	/** Options for saving JPEG image. */
	typedef struct _fc2JPEGOption
	{
		/** Whether to save as a progressive JPEG file. */
		BOOL progressive;
		/**
		 * JPEG image quality in range (0-100).
		 * - 100 - Superb quality.
		 * - 75  - Good quality.
		 * - 50  - Normal quality.
		 * - 10  - Poor quality.
		 */
		unsigned int quality;
		/** Reserved for future use. */
		unsigned int reserved[16];

	} fc2JPEGOption;

	/** Options for saving JPEG2000 image. */
	typedef struct _fc2JPG2Option
	{
		/** JPEG saving quality in range (1-512). */
		unsigned int quality;
		/** Reserved for future use. */
		unsigned int reserved[16];
	} fc2JPG2Option;

	/** Options for saving Bitmap image. */
	typedef struct _fc2BMPOption
	{
		BOOL indexedColor_8bit;
		/** Reserved for future use. */
		unsigned int reserved[16];
	} fc2BMPOption;

	/** Options for saving MJPG files. */
	typedef struct _fc2MJPGOption
	{
		/** Frame rate of the stream */
		float frameRate;
		/** Image quality (1-100) */
		unsigned int quality;
		unsigned int reserved[256];

	} fc2MJPGOption;

	/** Options for saving H264 files. */
	typedef struct _fc2H264Option
	{
		/** Frame rate of the stream */
		float frameRate;
		/** Width of source image */
		unsigned int width;
		/** Height of source image */
		unsigned int height;
		/** Bitrate to encode at */
		unsigned int bitrate;
		/** Reserved for future use */
		unsigned int reserved[256];

	} fc2H264Option;

	/** Options for saving AVI files. */
	typedef struct _fc2AVIOption
	{
		/** Frame rate of the stream */
		float frameRate;
		/** Reserved for future use */
		unsigned int reserved[256];
	} fc2AVIOption;

	//=============================================================================
	// Callbacks
	//=============================================================================

	typedef void* fc2CallbackHandle;
	typedef void (*fc2BusEventCallback)( void* pParameter, unsigned int serialNumber );
	typedef void (*fc2ImageEventCallback)( fc2Image* image, void* pCallbackData );
	typedef void (*fc2AsyncCommandCallback)( fc2Error retError, void* pUserData );
	typedef void (*fc2CameraEventCallback)( void* pCallbackData );

	/*******************************************************************************
	 * Camera event data types
	 ******************************************************************************/
	/** Options for enabling device event registration. */
	typedef struct _fc2EventOptions
	{
		/** Callback function pointer */
		fc2CameraEventCallback EventCallbackFcn;

		/** Event name to register */
		const char* EventName;

		/** Pointer to callback data to be passed to the callback function */
		const void* EventUserData;

		/** Size of the underlying struct passed as eventCallbackData for sanity checks */
		size_t EventUserDataSize;
	} fc2EventOptions;


	/* Callback data passed to the callback function provided when using
	 * RegisterEvent() or RegisterAllEvents().
	 */
	typedef struct _fc2EventCallbackData
	{
		/** Pointer to the user-supplied data struct */
		void* EventUserData;

		/** Size of the user data supplied to the RegisterEvent()
		 * function.
		 */
		size_t EventUserDataSize;

		/** The event name used to register the event. Provided so the user
		 * knows which event triggered the callback.
		 */
		const char* EventName;

		/** The device register which EventName maps to. Provides an alternate
		 * means of indexing into different event types.
		 */
		unsigned long long EventID;

		/** Timestamp indicated the time (as reported by the camera) at which
		 * the camera exposure operation completed. This can be compared with
		 * image timestamps if there is a need to map event timestamps to
		 * specific images, if applicable.
		 */
		unsigned long long EventTimestamp;

		/** A pointer to additional data pertaining to the event which just
		 * trigger the callback function. The data may be of difference sizes
		 * or may not even be allocated, depending on the type of event which
		 * triggered the callback.
		 */
		void* EventData;

		/** The size of the structure pointed to by EventData. This value should
		 * be checked, especially if there are events which can trigger variable-
		 * length event data to be returned to the user when the callback function
		 * is issued.
		 */
		size_t EventDataSize;
	} fc2EventCallbackData;

	/*@}*/

	/*@}*/

#ifdef __cplusplus
};
#endif

#endif // PGR_FC2_FLYCAPTURE2DEFS_C_H