FLI libflipro API
Classes | Macros | Typedefs | Enumerations | Functions
/home/tom/projects/fli/libflipro/libflipro/libflipro.h File Reference

Finger Lakes Instrumentation Camera API. More...

#include "stdbool.h"
#include "stdint.h"

Go to the source code of this file.

Classes

struct  ip_info_t
 
struct  fibre_info_t
 
struct  con_info_t
 
struct  host_if_info
 
struct  device_info_t
 
struct  device_version_info_t
 
struct  ext_trigger_info_t
 
struct  sensor_mode_t
 
struct  gain_value_t
 
struct  fpro_stream_stats_t
 
struct  fpro_stream_preview_info_t
 
struct  ref_frames_t
 
struct  conv_info_t
 
struct  hw_merge_enables_t
 
struct  unpacked_images_t
 
struct  int_point_t
 
struct  pixel_info_t
 
struct  image_plane_stats_t
 
struct  unpacked_stats_t
 
struct  meta_data_value_t
 

Macros

#define FPRO_IMAGE_FRAMEBYTES_TO_PIXELS(__framebytes)   (((__framebytes) << 1) / 3)
 Convert image size in Bytes to Pixels. More...
 
#define FPRO_IMAGE_PIXELS_TO_FRAMEBYTES(__pixels)   (((__pixels) & 0x1) ? ((((__pixels) * 3 ) >> 1) + 1) : (((__pixels) * 3 ) >> 1))
 Convert Pixels to Image size in Bytes. More...
 
#define FPRO_IMAGE_DIMENSIONS_TO_FRAMEBYTES(__width, __height)   FPRO_IMAGE_PIXELS_TO_FRAMEBYTES((__width) * (__height))
 Convert image dimensions in Pixels to Image size in Bytes. More...
 
#define FPRO_REFERENCE_ROW_MAX   (4094)
 Maximum number of pre/post frame Reference rows supported by the API. More...
 
#define FPRO_THUMBNAIL_ROWS   (512)
 Height of Thumbnail image in pixels.
 
#define FPRO_THUMBNAIL_COLUMNS   (512)
 Width of Thumbnail image in pixels.
 
#define FPRO_USB_STRING_MAXLEN   (256)
 Maximum String Length. More...
 
#define FPRO_DEVICE_MAX_PATH_LENGTH   (1024)
 Maximum path length for low level OS device path. More...
 
#define FPRO_VERSION_STRING_MAXLEN   (32)
 Version String Lengths. More...
 
#define FPRO_DEBUG_NONE   (0x00000000)
 All debug disabled.
 
#define FPRO_DEBUG_ERROR   (0x00000001)
 Only ERROR level debug is output.
 
#define FPRO_DEBUG_WARNING   (0x00000002)
 WARNING and ERROR debug is output.
 
#define FPRO_DEBUG_INFO   (0x00000004)
 INFO, WARNING, and ERROR debug is output.
 
#define FPRO_DEBUG_REGRW   (0x00000008)
 REGWR, INFO, WARNING, and ERROR debug is output.
 
#define FPRO_DEBUG_DEBUG   (0x00000010)
 DEBUG, REGRW, INFO, WARNING, and ERROR debug is output.
 
#define FPRO_DEBUG_TRACE   (0x00000020)
 TRACE, DEBUG, REGRW, INFO, WARNING, and ERROR debug is output.
 
#define FPRO_SENSOR_MODE_NAME_LENGTH   (32)
 Sensor Mode Name Length. More...
 
#define FPRO_GAIN_SCALE_FACTOR   (1000)
 Gain Scale Factor. More...
 
#define FPROCAP_ROI_BYCOL_ISCAM_SUPPORTED(__cap)   ((__cap & 0xFFFF) == (uint32_t)FPROCAP_ROI_BYCOL)
 Macro to determine if ROI By Column is supported natively by the camera. See FPROCAPROI.
 
#define FPROCAP_ROI_BYCOL_ISAPI_SUPPORTED(__cap)   ((__cap & 0xFFFF) == (uint32_t)FPROCAP_ROI_BYCOL_API_ONLY)
 Macro to determine if ROI By Column is supported only by the API. See FPROCAPROI.
 
#define FPROCAP_ROI_BYROW_ISCAM_SUPPORTED(__cap)   ((__cap & 0xFFFF0000) == (uint32_t)FPROCAP_ROI_BYROW)
 Macro to determine if ROI By Row is supported natively by the camera. See FPROCAPROI.
 
#define FPROCAP_ROI_BYROW_ISAPI_SUPPORTED(__cap)   ((__cap & 0xFFFF0000) == (uint32_t)FPROCAP_ROI_BYROW_API_ONLY)
 Macro to determine if ROI By Row is supported only by the API. See FPROCAPROI.
 
#define FPRO_META_VALUE_STRING_LENGTH_MAX   (64)
 Maximum length of a Meta Data string value See FPROMETAVALUE.
 

Typedefs

typedef struct ip_info_t FPROIPINFO
 IP Connection Information. More...
 
typedef struct fibre_info_t FPROFIBREINFO
 Fibre Connection Information. More...
 
typedef struct con_info_t FPROCONINFO
 Connection Information. More...
 
typedef struct host_if_info FPROHOSTINFO
 Host driver and hardware information. More...
 
typedef struct device_info_t FPRODEVICEINFO
 Device Information. More...
 
typedef struct device_version_info_t FPRODEVICEVERS
 Device Version Information. More...
 
typedef struct ext_trigger_info_t FPROEXTTRIGINFO
 External Trigger Setup Details. More...
 
typedef unsigned int FPRODBGLEVEL
 Convenience (unsigned int) typedef for debug levels. More...
 
typedef struct sensor_mode_t FPROSENSMODE
 Sensor Modes. More...
 
typedef struct gain_value_t FPROGAINVALUE
 Gain Value. More...
 
typedef struct fpro_stream_stats_t FPROSTREAMSTATS
 Streamer Statistics. More...
 
typedef struct fpro_stream_preview_info_t FPROPREVIEW
 Streamer Statistics For Preview Images When obtaining a preview image while streaming, this structure will contain the stream statistics for the image returned. See FPROFrame_StreamGetPreviewImageEx().
 
typedef struct ref_frames_t FPRO_REFFRAMES
 Reference Frames for Hardware Image Merging. More...
 
typedef struct conv_info_t FPRO_CONV
 Conversion info structure supplied to conversion functions. More...
 
typedef struct hw_merge_enables_t FPRO_HWMERGEENABLE
 Enables for Hardware Image Merging. More...
 
typedef struct unpacked_images_t FPROUNPACKEDIMAGES
 Unpacked Image Buffers. More...
 
typedef struct int_point_t FPROPOINT
 Point Coordinates. More...
 
typedef struct pixel_info_t FPROPIXELINFO
 Defines a location and value of a pixel within an image plane. More...
 
typedef struct image_plane_stats_t FPROPLANESTATS
 Defines the set of statistics available for unpacked frames. More...
 
typedef struct unpacked_stats_t FPROUNPACKEDSTATS
 Statistics for unpacked image planes. More...
 
typedef struct meta_data_value_t FPROMETAVALUE
 Defined a value for Meta Data fields. More...
 

Enumerations

enum  FPRODEVICETYPE {
  FPRO_CAM_DEVICE_TYPE_GSENSE400 = 0x01000400 , FPRO_CAM_DEVICE_TYPE_GSENSE2020 = 0x01002020 , FPRO_CAM_DEVICE_TYPE_GSENSE4040 = 0x01004040 , FPRO_CAM_DEVICE_TYPE_GSENSE6060 = 0x01006060 ,
  FPRO_CAM_DEVICE_TYPE_DC230_42 = 0x03023042 , FPRO_CAM_DEVICE_TYPE_DC230_84 = 0x03023084 , FPRO_CAM_DEVICE_TYPE_DC4320 = 0x03004320 , FPRO_CAM_DEVICE_TYPE_SONYIMX183 = 0x04000183 ,
  FPRO_CAM_DEVICE_TYPE_FTM = 0x04000F1F , FPRO_CAM_DEVICE_TYPE_BIOLINE_420 = 0x05000420 , FPRO_CAM_DEVICE_TYPE_BIOLINE_455 = 0x05000455 , FPRO_CAM_DEVICE_TYPE_BIOLINE_492 = 0x05000492 ,
  FPRO_CAM_DEVICE_TYPE_BIOLINE_530 = 0x05000530 , FPRO_CAM_DEVICE_TYPE_BIOLINE_533 = 0x05000533 , FPRO_CAM_DEVICE_TYPE_BIOLINE_541 = 0x05000541 , FPRO_CAM_DEVICE_TYPE_BIOLINE_571 = 0x05000571 ,
  FPRO_CAM_DEVICE_TYPE_LSGEN = 0x850F0000
}
 Known Device Types. More...
 
enum  FPROCONNECTION { FPRO_CONNECTION_USB , FPRO_CONNECTION_FIBRE , FPRO_CONNECTION_ENET }
 Supported Connection Types. More...
 
enum  FPROUSBSPEED { FPRO_USB_FULLSPEED , FPRO_USB_HIGHSPEED , FPRO_USB_SUPERSPEED }
 Known USB Connection Speeds. More...
 
enum  FPROTESTIMAGETYPE {
  FLI_TESTIMAGE_TYPE_ROW , FLI_TESTIMAGE_TYPE_COL , FLI_TESTIMAGE_IMX183_VERTICAL , FLI_TESTIMAGE_IMX183_HORIZONTAL ,
  FLI_TESTIMAGE_IMX183_ALL_LOW , FLI_TESTIMAGE_IMX183_ALL_HIGH , FLI_TESTIMAGE_IMX183_LOW_HIGH , FLI_TESTIMAGE_IMX183_HIGH_LOW
}
 Test Image Types. More...
 
enum  FPROEXTTRIGTYPE { FLI_EXT_TRIGGER_FALLING_EDGE , FLI_EXT_TRIGGER_RISING_EDGE , FLI_EXT_TRIGGER_EXPOSE_ACTIVE_LOW , FLI_EXT_TRIGGER_EXPOSE_ACTIVE_HIGH }
 External Trigger Types. More...
 
enum  FPROGPSSTATE { FPRO_GPS_NOT_DETECTED = 0 , FPRO_GPS_DETECTED_NO_SAT_LOCK , FPRO_GPS_DETECTED_AND_SAT_LOCK , FPRO_GPS_DETECTED_SAT_LOCK_TIME_ERROR }
 GPS Connection State. More...
 
enum  FPROGPSOPT { FPRO_GPSOPT_WAAS_EGNOS_ENABLE = 0x01 , FPRO_GPSOPT_GLONASS_ENABLE = 0x02 }
 GPS Options. More...
 
enum  FPROSENSREADCFG {
  FPRO_SENSREAD_CB_BOTTOMLEFT = 0x01 , FPRO_SENSREAD_CB_BOTTOMRIGHT = 0x02 , FPRO_SENSREAD_CB_TOPLEFT = 0x04 , FPRO_SENSREAD_CB_TOPRIGHT = 0x08 ,
  FPRO_SENSREAD_CB_ALL = 0x0F
}
 Sensor Read Out Configuration. More...
 
enum  FPROGAINTABLE { FPRO_GAIN_TABLE_LOW_CHANNEL , FPRO_GAIN_TABLE_HIGH_CHANNEL , FPRO_GAIN_TABLE_CHANNEL_NUM }
 Gain Tables. More...
 
enum  FPROBLACKADJUSTCHAN { FPRO_BLACK_ADJUST_CHAN_LDR , FPRO_BLACK_ADJUST_CHAN_HDR }
 Black Adjust Channels. More...
 
enum  FPROCAPS {
  FPROCAP_DEVICE_TYPE = 0 , FPROCAP_META_DATA_SIZE , FPROCAP_MAX_PIXEL_WIDTH , FPROCAP_MAX_PIXEL_HEIGHT ,
  FPROCAP_PIXEL_BIT_DEPTHS , FPROCAP_BINNING_TABLE_SIZE , FPROCAP_BLACK_LEVEL_MAX , FPROCAP_BLACK_SUN_MAX ,
  FPROCAP_LOW_GAIN_TABLE_SIZE , FPROCAP_HIGH_GAIN_TABLE_SIZE , FPROCAP_ROW_SCAN_TIME , FPROCAP_ROW_REFERENCE_PIXELS ,
  FPROCAP_FRAME_REFERENCE_ROWS , FPROCAP_IMAGE_INVERTABLE , FPROCAP_NV_STORAGE_AVAILABLE , FPROCAP_MERGE_REFERENCE_FRAMES_SUPPORTED ,
  FPROCAP_ROI_SUPPORT , FPROCAP_NUM
}
 Camera Capabilities. More...
 
enum  FPROCAPROI {
  FPROCAP_ROI_NONE = 0 , FPROCAP_ROI_BYROW = (0x00010000) , FPROCAP_ROI_BYROW_API_ONLY = (0x00020000) , FPROCAP_ROI_BYCOL = (0x00000001) ,
  FPROCAP_ROI_BYCOL_API_ONLY = (0x00000002)
}
 Region of Interest Support. More...
 
enum  FPROHDR { FPRO_HDR_DISABLED = 0 , FPRO_HDR_CAMERA , FPRO_HDR_INTERLEAVED }
 HDR Mode setting. More...
 
enum  FPROAUXIO { FPRO_AUXIO_1 = 0x01 , FPRO_AUXIO_2 = 0x02 , FPRO_AUXIO_3 = 0x04 , FPRO_AUXIO_4 = 0x08 }
 Auxiliary I/O Pins. More...
 
enum  FPROAUXIO_DIR { FPRO_AUXIO_DIR_IN = 0 , FPRO_AUXIO_DIR_OUT }
 Auxiliary I/O Pin Direction. More...
 
enum  FPROAUXIO_STATE { FPRO_AUXIO_STATE_LOW , FPRO_AUXIO_STATE_HIGH }
 Auxiliary Output State. More...
 
enum  FPROAUXIO_EXPACTIVETYPE {
  FPRO_AUXIO_EXPTYPE_EXPOSURE_ACTIVE = 0 , FPRO_AUXIO_EXPTYPE_GLOBAL_EXPOSURE_ACTIVE , FPRO_AUXIO_EXPTYPE_FIRST_ROW_SYNC , FPRO_AUXIO_EXPTYPE_RESERVED ,
  FPRO_AUXIO_EXPTYPE_NOTSET
}
 Exposure Active Auxiliary Output. More...
 
enum  FPROSTREAMERSTATUS { FPRO_STREAMER_STOPPED_ERROR = -1 , FPRO_STREAMER_STOPPED = 0 , FPRO_STREAMER_STREAMING }
 Streamer Status. More...
 
enum  FPRO_FRAME_TYPE {
  FPRO_FRAMETYPE_NORMAL = 0 , FPRO_FRAMETYPE_DARK , FPRO_FRAMETYPE_BIAS , FPRO_FRAMETYPE_LIGHTFLASH ,
  FPRO_FRAMETYPE_DARKFLASH
}
 Image Frame Type. More...
 
enum  FPROCMS { FPROCMS_1 = 0 , FPROCMS_2 , FPROCMS_4 }
 Correlated Multiple Samples (Samples Per Pixel) More...
 
enum  FPRO_IMAGE_FORMAT { IFORMAT_NONE = 0 , IFORMAT_RCD = 0 , IFORMAT_TIFF , IFORMAT_FITS }
 Output Frame Formats for image merging and conversion. More...
 
enum  FPRO_PIXEL_FORMAT {
  PFORMAT_MONO8 , PFORMAT_BAYER8_GRBG , PFORMAT_BAYER8_RGGB , PFORMAT_BAYER8_GBRG ,
  PFORMAT_BAYER8_BGGR , PFORMAT_MONO10_PACKED_MSFIRST , PFORMAT_BAYER10_GRBG_PACKED_MSFIRST , PFORMAT_BAYER10_RGGB_PACKED_MSFIRST ,
  PFORMAT_BAYER10_GBRG_PACKED_MSFIRST , PFORMAT_BAYER10_BGGR_PACKED_MSFIRST , PFORMAT_MONO12_KEPLER , PFORMAT_MONO12_PACKED ,
  PFORMAT_BAYER12_GRBG_PACKED , PFORMAT_BAYER12_RGGB_PACKED , PFORMAT_BAYER12_GBRG_PACKED , PFORMAT_BAYER12_BGGR_PACKED ,
  PFORMAT_MONO12_PACKED_MSFIRST , PFORMAT_BAYER12_GRBG_PACKED_MSFIRST , PFORMAT_BAYER12_RGGB_PACKED_MSFIRST , PFORMAT_BAYER12_GBRG_PACKED_MSFIRST ,
  PFORMAT_BAYER12_BGGR_PACKED_MSFIRST , PFORMAT_MONO16_KEPLER , PFORMAT_MONO16 , PFORMAT_MONO16_MSFIRST ,
  PFORMAT_YUV422 , PFORMAT_BAYER16_GRBG , PFORMAT_BAYER16_RGGB , PFORMAT_BAYER16_GBRG ,
  PFORMAT_BAYER16_BGGR , PFORMAT_RGB24 , PFORMAT_RGB24_NON_DIB , PFORMAT_BGR24 ,
  PFORMAT_RGBA , PFORMAT_BGRA , PFORMAT_ARGB , PFORMAT_ABGR ,
  PFORMAT_RGB48 , PFORMAT_RGB48_DIB , PFORMAT_STOKES4_12 , PFORMAT_POLAR4_12 ,
  PFORMAT_POLAR_RAW4_12 , PFORMAT_HSV4_12 , PFORMAT_UNKNOWN
}
 SUpported Pixel Formats across the various cameras. More...
 
enum  FPRO_HWMERGEFRAMES { HWMERGE_FRAME_BOTH = 0 , HWMERGE_FRAME_LOWONLY , HWMERGE_FRAME_HIGHONLY }
 Enables for Hardware Image Merging. More...
 
enum  FPRO_META_KEYS {
  META_KEY_MAGIC , META_KEY_META_DATA_LENGTH , META_KEY_META_DATA_VERSION , META_KEY_BACK_SIDE_ILLUMINATED ,
  META_KEY_BASE_TEMPERATURE , META_KEY_BINNING_X , META_KEY_BINNING_Y , META_KEY_BLACK_LEVEL_ADJUST ,
  META_KEY_BLACK_SUN_ADJUST , META_KEY_BLACK_LEVEL_HIGH_ADJUST , META_KEY_BLACK_SUN_HIGH_ADJUST , META_KEY_CAMERA_MODEL ,
  META_KEY_CAPTURE_DATE , META_KEY_CAPTURE_TIME_SECS , META_KEY_CAPTURE_TIME_NSECS , META_KEY_COOLER_TEMPERATURE ,
  META_KEY_COOLER_DUTY_CYCLE , META_KEY_CONTROL_BLOCK , META_KEY_CORRELATED_MULTIPLE_SAMPLE , META_KEY_DATA_PIXEL_BIT_DEPTH ,
  META_KEY_DATA_ZERO_POINT , META_KEY_DEAD_PIXEL_CORRECTION , META_KEY_EXPOSURE_TIME , META_KEY_FILE_CREATE_TIME ,
  META_KEY_FPGA_TEMPERATURE , META_KEY_FRAME_NUMBER , META_KEY_GAIN_LOW , META_KEY_GAIN_GLOBAL ,
  META_KEY_GAIN_HIGH , META_KEY_GEO_LAT_RAW , META_KEY_GEO_LAT_DEGREES , META_KEY_GEO_LAT_MINUTES ,
  META_KEY_GEO_LAT_NORTH , META_KEY_GEO_LONG_RAW , META_KEY_GEO_LONG_DEGREES , META_KEY_GEO_LONG_MINUTES ,
  META_KEY_GEO_LONG_EAST , META_KEY_GLOBAL_RESET , META_KEY_GPS_ERROR , META_KEY_GPS_LOCK ,
  META_KEY_HDR_MODE , META_KEY_HIGH_ADUE , META_KEY_HORIZONTAL_PIXELS , META_KEY_HORIZONTAL_PIXEL_SIZE ,
  META_KEY_HORIZONTAL_SCAN_DIRECTION_INVERT , META_KEY_ILLUMINATION_START_DELAY , META_KEY_ILLUMINATION_STOP_DELAY , META_KEY_IMAGE_HEIGHT ,
  META_KEY_IMAGE_MODE , META_KEY_IMAGE_START_COLUMN , META_KEY_IMAGE_START_ROW , META_KEY_IMAGE_STOP_COLUMN ,
  META_KEY_IMAGE_STOP_ROW , META_KEY_IMAGE_START_EXPOSURE_ROW , META_KEY_IMAGE_TYPE , META_KEY_IMAGE_WIDTH ,
  META_KEY_IS_HIGH_FRAME , META_KEY_IS_HIGH_GAIN_ONLY_FRAME , META_KEY_IS_MERGED_FRAME , META_KEY_IS_SOFTWARE_BINNING ,
  META_KEY_IS_STACKED_FRAME , META_KEY_LOW_DARK_CURRENT , META_KEY_LOW_NOISE , META_KEY_MERGE_GAIN_RATIO ,
  META_KEY_MERGE_LINE_OFFSET , META_KEY_NON_ROW_ALLIGNED_IMAGE , META_KEY_NUM_OF_DATA_CHANNELS , META_KEY_PIXEL_ORDERED_IMAGE ,
  META_KEY_POST_REFERENCE_ROW , META_KEY_PRE_REFERENCE_ROW , META_KEY_POST_REFERENCE_PIXELS_PER_ROW , META_KEY_PRE_REFERENCE_PIXELS_PER_ROW ,
  META_KEY_SENSOR_PIXEL_BIT_DEPTH , META_KEY_SENSOR_READ_QUADRANTS , META_KEY_SENSOR_CHIP_TEMPERATURE , META_KEY_SERIAL_NUMBER ,
  META_KEY_SHUTTER_CLOSE_DELAY , META_KEY_SHUTTER_OPEN_DELAY , META_KEY_TEMPERATURE_SETPOINT , META_KEY_TEST_HIGH_GAIN_ABSOLUTE ,
  META_KEY_TEST_LOW_GAIN_ABSOLUTE , META_KEY_TRACKING_FRAMES_PER_IMAGE , META_KEY_TRACKING_START_COLUMN , META_KEY_TRACKING_START_ROW ,
  META_KEY_TRACKING_STOP_COLUMN , META_KEY_TRACKING_STOP_ROW , META_KEY_USE_SHIFTED_AVERAGING , META_KEY_VERSION_API ,
  META_KEY_VERSION_APPLICATION , META_KEY_VERSION_FIRMWARE , META_KEY_VERTICAL_PIXELS , META_KEY_VERTICAL_PIXEL_SIZE ,
  META_KEY_VERTICAL_SCAN_DIRECTION_INVERT , META_KEY_V4IMAGE_OFFSET , META_KEY_V4META_INFO , META_KEY_V4PIXEL_FORMAT ,
  META_KEY_V4OTHER_TYPE , META_KEY_V4OTHER_TYPE_LENGTH , META_KEY_V4OTHER_TYPE_OFFSET , META_KEY_V4RESERVED ,
  META_KEY_NUM
}
 The list of available Meta Data keys. More...
 

Functions

LIBFLIPRO_API FPROCam_GetCameraList (FPRODEVICEINFO *pDeviceInfo, uint32_t *pNumDevices)
 FPROCam_GetCameraList. More...
 
LIBFLIPRO_API FPROCam_GetDeviceInfo (int32_t iHandle, FPRODEVICEINFO *pDeviceInfo)
 FPROCam_GetDeviceInfo. More...
 
LIBFLIPRO_API FPROCam_Open (FPRODEVICEINFO *pDevInfo, int32_t *pHandle)
 Connects to the camera specified by the pDevInfo parameter.
More...
 
LIBFLIPRO_API FPROCam_Close (int32_t iHandle)
 Disconnects from the camera an releases the handle. More...
 
LIBFLIPRO_API FPROCam_GetAPIVersion (wchar_t *pVersion, uint32_t uiLength)
 Returns the version of this API Library.
More...
 
LIBFLIPRO_API FPROCam_GetDeviceVersion (int32_t iHandle, FPRODEVICEVERS *pVersion)
 Returns the version information from the connected device. More...
 
LIBFLIPRO_API FPROCam_GetHostInterfaceInfo (FPROHOSTINFO *pHostInfo, uint32_t *pNum)
 Returns information pertaining to the installed host Fibre/PCIE cards. More...
 
LIBFLIPRO_API FPROFrame_CaptureAbort (int32_t iHandle)
 Aborts the active image capture. More...
 
LIBFLIPRO_API FPROFrame_CaptureStart (int32_t iHandle, uint32_t uiFrameCount)
 Initiates the capture of the configured image.
More...
 
LIBFLIPRO_API FPROFrame_CaptureStop (int32_t iHandle)
 Stops the active image capture. More...
 
LIBFLIPRO_API FPROFrame_CaptureThumbnail (int32_t iHandle)
 Initiates the capture of a thumbnail image.
More...
 
LIBFLIPRO_API FPROFrame_ComputeFrameSize (int32_t iHandle)
 Computes the size in bytes of the image frame.
More...
 
LIBFLIPRO_API FPROFrame_ComputeFrameSizePixels (int32_t iHandle, uint32_t *pTotalWidth, uint32_t *pTotalHeight)
 Computes the size in pixels of the image frame.
More...
 
LIBFLIPRO_VOID FPROFrame_FreeUnpackedBuffers (FPROUNPACKEDIMAGES *pUPBuffers)
 Frees the Unpacked Buffers within the given structure.
More...
 
LIBFLIPRO_VOID FPROFrame_FreeUnpackedStatistics (FPROUNPACKEDSTATS *pStats)
 Frees the Unpacked Statistics Buffers within the given structure.
More...
 
LIBFLIPRO_API FPROFrame_GetDummyPixelEnable (int32_t iHandle, bool *pEnable)
 Retrieves the dummy pixel configuration to be appended row data.
More...
 
LIBFLIPRO_API FPROFrame_GetFrameReferenceRows (int32_t iHandle, uint32_t *pPreRows, uint32_t *pPostRows)
 Retrieves the reference row count to be appended to frame data.
More...
 
LIBFLIPRO_API FPROFrame_GetFrameType (int32_t iHandle, FPRO_FRAME_TYPE *pType)
 Retrieves the Frame Type setting.
More...
 
LIBFLIPRO_API FPROFrame_GetImageDataEnable (int32_t iHandle, bool *pEnable)
 Enables image data imaging. More...
 
LIBFLIPRO_API FPROFrame_GetTestImageEnable (int32_t iHandle, bool *pEnable, FPROTESTIMAGETYPE *pFormat)
 Retrieves the test image data settings. More...
 
LIBFLIPRO_API FPROFrame_GetImageArea (int32_t iHandle, uint32_t *pColOffset, uint32_t *pRowOffset, uint32_t *pWidth, uint32_t *pHeight)
 Gets the area of the image sensor being used to produce image frame data. More...
 
LIBFLIPRO_API FPROFrame_GetPixelFormat (int32_t iHandle, FPRO_PIXEL_FORMAT *pFormat, uint32_t *pPixelLSB)
 Retrieves the current pixel format configuration. More...
 
LIBFLIPRO_API FPROFrame_GetSupportedPixelFormats (int32_t iHandle, FPRO_PIXEL_FORMAT *pFormats, uint32_t *pNumFormats)
 Retrieves the supported pixel formats. More...
 
LIBFLIPRO_API FPROFrame_GetThumbnailFrame (int32_t iHandle, uint8_t *pFrameData, uint32_t *pSize)
 Retrieves the thumbnail image from the camera. More...
 
LIBFLIPRO_API FPROFrame_GetVideoFrame (int32_t iHandle, uint8_t *pFrameData, uint32_t *pSize, uint32_t uiTimeoutMS)
 Retrieves an image frame from the camera. More...
 
LIBFLIPRO_API FPROFrame_GetVideoFrameUnpacked (int32_t iHandle, uint8_t *pFrameData, uint32_t *pSize, uint32_t uiTimeoutMS, FPROUNPACKEDIMAGES *pUPBuffers, FPROUNPACKEDSTATS *pStats)
 Retrieves an image frame from the camera and optionally unpacks and merges the image planes. More...
 
LIBFLIPRO_API FPROFrame_GetVideoFrameExt (int32_t iHandle, uint8_t *pFrameData, uint32_t *pSize)
 Retrieves an externally triggered image frame from the camera. More...
 
LIBFLIPRO_API FPROFrame_GetVideoFrameUnpackedExt (int32_t iHandle, uint8_t *pFrameData, uint32_t *pSize, FPROUNPACKEDIMAGES *pUPBuffers, FPROUNPACKEDSTATS *pStats)
 Retrieves an externally triggered image frame from the camera and unpacks the image. More...
 
LIBFLIPRO_API FPROFrame_UnpackFile (wchar_t *pFileName, FPROUNPACKEDIMAGES *pUPBuffers, FPROUNPACKEDSTATS *pStats)
 Unpack and merge the given file. More...
 
LIBFLIPRO_API FPROFrame_UnpackFileEx (wchar_t *pFileName, FPROUNPACKEDIMAGES *pUPBuffers, FPROUNPACKEDSTATS *pStats, const wchar_t *pDSNUFile, const wchar_t *pPRNUFile)
 Unpack and merge the given file. More...
 
LIBFLIPRO_API FPROFrame_ConvertFile (wchar_t *pInRcdFile, FPRO_CONV *pConvInfo, wchar_t *pOutFile)
 Convert (and possibly) merge the given RCD file. More...
 
LIBFLIPRO_API FPROFrame_MetaDataToString (wchar_t *pFileName, wchar_t *pMetaString, uint32_t uiMaxChars)
 Convert the meta data in the given file to string. More...
 
LIBFLIPRO_API FPROFrame_MetaDataToStringBin (uint8_t *pImageData, uint32_t uiImageSizeBytes, wchar_t *pMetaString, uint32_t uiMaxChars)
 Convert the meta data in the given file to string. More...
 
LIBFLIPRO_API FPROFrame_MetaValueInit (wchar_t *pFileName)
 Parses the meta data from the given file for access by the FPROFrame_MetaValueGet() and FPROFrame_MetaValueGetNext() API calls. More...
 
LIBFLIPRO_API FPROFrame_MetaValueInitBin (uint8_t *pMetaData, uint32_t uiLength)
 Parses the meta data from the given image data for access by the FPROFrame_MetaValueGet() and FPROFrame_MetaValueGetNext() API calls. More...
 
LIBFLIPRO_API FPROFrame_MetaValueGet (FPRO_META_KEYS eMetaKey, FPROMETAVALUE *pMetaValue)
 Retrieve the value for the given meta key. More...
 
LIBFLIPRO_API FPROFrame_MetaValueGetNext (FPROMETAVALUE *pMetaValue)
 Retrieve the next meta key value. More...
 
LIBFLIPRO_API FPROFrame_SetDummyPixelEnable (int32_t iHandle, bool bEnable)
 Returns whether or not Image Frame data is ready for retrieval.
More...
 
LIBFLIPRO_API FPROFrame_SetFrameReferenceRows (int32_t iHandle, uint32_t uiPreRows, uint32_t uiPostRows)
 Sets the reference row count to be added to frame data.
More...
 
LIBFLIPRO_API FPROFrame_SetFrameType (int32_t iHandle, FPRO_FRAME_TYPE eType)
 Sets Frame Type produced by the camera.
More...
 
LIBFLIPRO_API FPROFrame_SetImageDataEnable (int32_t iHandle, bool bEnable)
 Enables image data imaging. More...
 
LIBFLIPRO_API FPROFrame_SetTestImageEnable (int32_t iHandle, bool bEnable, FPROTESTIMAGETYPE eFormat)
 Enables test image data to be generated rather than normal image data. More...
 
LIBFLIPRO_API FPROFrame_SetTrackingArea (int32_t iHandle, uint32_t uiStartRow, uint32_t uiEndRow)
 Sets the area of the image sensor to be used for Tracking Frames during image capture. More...
 
LIBFLIPRO_API FPROFrame_SetTrackingAreaEnable (int32_t iHandle, uint32_t uiNumTrackingFrames)
 Enables the production of Tracking Frames by the camera. More...
 
LIBFLIPRO_API FPROFrame_SetPixelFormat (int32_t iHandle, FPRO_PIXEL_FORMAT pfPixelFormat, uint32_t uiPixelLSB)
 Sets the current pixel configuration to the specified values. More...
 
LIBFLIPRO_API FPROFrame_SetImageArea (int32_t iHandle, uint32_t uiColOffset, uint32_t uiRowOffset, uint32_t uiWidth, uint32_t uiHeight)
 Sets the area of the image sensor to be used to produce image frame data. More...
 
LIBFLIPRO_API FPROFrame_StreamInitialize (int32_t iHandle, uint32_t uiFrameSizeBytes, wchar_t *pRootPath, wchar_t *pFilePrefix)
 Initializes the Streamer interfaces. More...
 
LIBFLIPRO_API FPROFrame_StreamDeinitialize (int32_t iHandle)
 Deinitializes the Streamer interfaces. More...
 
LIBFLIPRO_API FPROFrame_StreamStart (int32_t iHandle, uint32_t uiFrameCount, uint64_t uiFrameIntervalMS)
 Start the streaming operation. More...
 
LIBFLIPRO_API FPROFrame_StreamStop (int32_t iHandle)
 Stop the streaming operation. More...
 
LIBFLIPRO_API FPROFrame_StreamGetStatistics (int32_t iHandle, FPROSTREAMSTATS *pStats)
 Stop the streaming operation. More...
 
LIBFLIPRO_API FPROFrame_StreamGetPreviewImage (int32_t iHandle, uint8_t *pImage, uint32_t *pLength, uint32_t uiTimeoutMSecs)
 Retrieve the next image available for preview from the image stream. More...
 
LIBFLIPRO_API FPROFrame_StreamGetPreviewImageEx (int32_t iHandle, uint8_t *pImage, uint32_t *pLength, FPROPREVIEW *pInfo, uint32_t uiTimeoutMSecs)
 Retrieve the next image available for preview from the image stream. More...
 
LIBFLIPRO_API FPROCtrl_GetBurstModeEnable (int32_t iHandle, bool *pEnable)
 Get Camera Burst Mode enable. More...
 
LIBFLIPRO_API FPROCtrl_GetCoolerDutyCycle (int32_t iHandle, uint32_t *pDutyCycle)
 Reads the current duty cycle of the cooler. More...
 
LIBFLIPRO_API FPROCtrl_GetCameraBufferBypass (int32_t iHandle, bool *pCameraBypassEnable, bool *pHostBypassEnable)
 Returns the current Camera Buffer Bypass state of the camera. More...
 
LIBFLIPRO_API FPROCtrl_GetElectricallyBlackPixelEnable (int32_t iHandle, bool *pEnable)
 Returns the current Electrically Black Pixel Enable state from the camera. More...
 
LIBFLIPRO_API FPROCtrl_GetExposure (int32_t iHandle, uint64_t *pExposureTime, uint64_t *pFrameDelay, bool *pImmediate)
 Reads the exposure time of the image sensor. More...
 
LIBFLIPRO_API FPROCtrl_GetExternalTriggerEnable (int32_t iHandle, FPROEXTTRIGINFO *pTrigInfo)
 Returns the external trigger settings of the camera. More...
 
LIBFLIPRO_API FPROCtrl_GetFanEnable (int32_t iHandle, bool *pOn)
 Returns the current Fan status, on or off. More...
 
LIBFLIPRO_API FPROCtrl_GetGPSState (int32_t iHandle, FPROGPSSTATE *pState, uint32_t *pOptions)
 Returns the current state of an optionally attached GPS unit. More...
 
LIBFLIPRO_API FPROCtrl_GetHeaterPower (int32_t iHandle, uint32_t *pPwrPercentage)
 Reads the current heater configuration. More...
 
LIBFLIPRO_API FPROCtrl_GetIlluminationDelay (int32_t iHandle, uint32_t *pOnDelay, uint32_t *pOffDelay)
 Gets the delay between setting the Illumination on/off via FPROCtrl_SetIlluminationOn() and when the illumination actually activates. Each increment is TBD msecs. More...
 
LIBFLIPRO_API FPROCtrl_GetIlluminationOn (int32_t iHandle, bool *pOn)
 Returns the setting of External Illumination- on or off. More...
 
LIBFLIPRO_API FPROCtrl_GetLED (int32_t iHandle, bool *pOn)
 Returns the state of the LED on or off setting. More...
 
LIBFLIPRO_API FPROCtrl_GetLEDDuration (int32_t iHandle, uint32_t *pDurationUsec)
 Get the LED Duration setting. More...
 
LIBFLIPRO_API FPROCtrl_GetPCIETemperatures (int32_t iHandle, double *pPcieFpga, double *pFibreFpga)
 Returns the temperatures on the Host PCIE Fibre Interface card. More...
 
LIBFLIPRO_API FPROCtrl_GetSensorTemperature (int32_t iHandle, int32_t *pTemp)
 Reads the internal sensor temperature of the camera.
More...
 
LIBFLIPRO_API FPROCtrl_GetSensorTemperatureReadEnable (int32_t iHandle, bool *pEnable)
 Returns the 'read sensor temperature during exposure' enabled flag. More...
 
LIBFLIPRO_API FPROCtrl_GetShutterOpen (int32_t iHandle, bool *pOpen)
 Gets the current shutter setting. More...
 
LIBFLIPRO_API FPROCtrl_GetShutterOverride (int32_t iHandle, bool *pOverride)
 Gets the current shutter override setting. More...
 
LIBFLIPRO_API FPROCtrl_GetTemperatures (int32_t iHandle, double *pOtherTemp, double *pBaseTemp, double *pCoolerTemp)
 Reads the various temperatures sensors of the camera. More...
 
LIBFLIPRO_API FPROCtrl_GetTemperatureSetPoint (int32_t iHandle, double *pSetPoint)
 Returns the Base Temperature Set Point. More...
 
LIBFLIPRO_API FPROCtrl_SetBurstModeEnable (int32_t iHandle, bool bEnable)
 Set Camera Burst Mode enable. More...
 
LIBFLIPRO_API FPROCtrl_SetCameraBufferBypass (int32_t iHandle, bool bCameraBypassEnable, bool bHostBypassEnable)
 Set Camera Buffer Bypass state of the camera. More...
 
LIBFLIPRO_API FPROCtrl_SetElectricallyBlackPixelEnable (int32_t iHandle, bool bEnable)
 Returns the current Electrically Black Pixel Enable state from the camera. More...
 
LIBFLIPRO_API FPROCtrl_SetExposure (int32_t iHandle, uint64_t uiExposureTime, uint64_t uiFrameDelay, bool bImmediate)
 Sets the exposure time of the image sensor. More...
 
LIBFLIPRO_API FPROCtrl_SetExposureEx (int32_t iHandle, uint64_t uiExposureTime, uint64_t uiFrameDelay, bool bImmediate, uint64_t *pActualExposureTime, uint64_t *pActualFrameDelay)
 Sets the exposure time of the image sensor. More...
 
LIBFLIPRO_API FPROCtrl_SetExternalTriggerEnable (int32_t iHandle, uint32_t uiFrameCount, FPROEXTTRIGINFO *pTrigInfo)
 Enables or disables the external trigger of the camera. More...
 
LIBFLIPRO_API FPROCtrl_SetFanEnable (int32_t iHandle, bool bOn)
 Turns the Fan on or off. More...
 
LIBFLIPRO_API FPROCtrl_SetGPSOptions (int32_t iHandle, uint32_t uiOptions)
 Set the tracking options of an optionally attached GPS unit. More...
 
LIBFLIPRO_API FPROCtrl_SetHeaterPower (int32_t iHandle, uint32_t uiPwrPercentage)
 Turns the Heater on or off at the specified power level. More...
 
LIBFLIPRO_API FPROCtrl_SetIlluminationDelay (int32_t iHandle, uint16_t uiOnDelay, uint16_t uiOffDelay)
 Sets the illumination delay. More...
 
LIBFLIPRO_API FPROCtrl_SetIlluminationOn (int32_t iHandle, bool bOn)
 Turns External Illumination on or off. More...
 
LIBFLIPRO_API FPROCtrl_SetLED (int32_t iHandle, bool bOn)
 Turn the LED on or off. More...
 
LIBFLIPRO_API FPROCtrl_SetLEDDuration (int32_t iHandle, uint32_t uiDurationUSec)
 Set LED Duration during exposure. More...
 
LIBFLIPRO_API FPROCtrl_SetSensorTemperatureReadEnable (int32_t iHandle, bool bEnable)
 Enables/disables physical reading of the image sensor temperature during exposures.
More...
 
LIBFLIPRO_API FPROCtrl_SetShutterOpen (int32_t iHandle, bool bOpen)
 Opens/Close the shutter. More...
 
LIBFLIPRO_API FPROCtrl_SetShutterOverride (int32_t iHandle, bool bOverride)
 Sets the shutter control override. More...
 
LIBFLIPRO_API FPROCtrl_SetTemperatureSetPoint (int32_t iHandle, double dblSetPoint)
 Sets the Base Temperature Set Point. More...
 
LIBFLIPRO_API FPROSensor_GetBinning (int32_t iHandle, uint32_t *pXBin, uint32_t *pYBin)
 Retrieves the current pixel bin settings. More...
 
LIBFLIPRO_API FPROSensor_GetBinningTable (int32_t iHandle, uint32_t *pBinTable, uint32_t *pTableSizeBytes)
 Retrieves the Binning table capability from the camera. More...
 
LIBFLIPRO_API FPROSensor_GetBlackLevelAdjust (int32_t iHandle, FPROBLACKADJUSTCHAN eChan, uint32_t *pAdjustValue)
 Retrieves the current Black Level Adjustment values for the given channel. More...
 
LIBFLIPRO_API FPROSensor_GetBlackSunAdjust (int32_t iHandle, FPROBLACKADJUSTCHAN eChan, uint32_t *pAdjustValue)
 Retrieves the current Black Sun Adjustment values for the given channel. More...
 
LIBFLIPRO_API FPROSensor_GetCapabilityList (int32_t iHandle, uint32_t *pCapList, uint32_t *pNumCaps)
 Retrieves the capabilities list for the connected camera.
More...
 
LIBFLIPRO_API FPROSensor_GetGainIndex (int32_t iHandle, FPROGAINTABLE eTable, uint32_t *pGainIndex)
 Retrieves the current setting for the Gain for the specified table. More...
 
LIBFLIPRO_API FPROSensor_GetGainTable (int32_t iHandle, FPROGAINTABLE eTable, FPROGAINVALUE *pGainValues, uint32_t *pNumEntries)
 Retrieves the specified Gain Table. More...
 
LIBFLIPRO_API FPROSensor_GetHDREnable (int32_t iHandle, FPROHDR *pHDREnable)
 Retrieves the current setting for HDR enable. More...
 
LIBFLIPRO_API FPROSensor_GetHighGainOnlyEnable (int32_t iHandle, bool *pHighGainOnly)
 Retrieves the High Gain Only Mode. More...
 
LIBFLIPRO_API FPROSensor_GetMode (int32_t iHandle, uint32_t uiModeIndex, FPROSENSMODE *pMode)
 Retrieves the current mode name for the specified index.
More...
 
LIBFLIPRO_API FPROSensor_GetModeCount (int32_t iHandle, uint32_t *pCount, uint32_t *pCurrentMode)
 Retrieves the current mode count and current mode index setting. More...
 
LIBFLIPRO_API FPROSensor_GetReadoutConfiguration (int32_t iHandle, FPROSENSREADCFG *pReadCfg)
 Retrieves the current sensor read out configuration on supported models. More...
 
LIBFLIPRO_API FPROSensor_GetSamplesPerPixel (int32_t iHandle, FPROCMS *pSamplesPerPixel)
 Retrieves the Samples Per Pixel settings on the sensor.

NOTE: This function is not supported on on all camera models. Consult your documentation for your specific camera.
More...
 
LIBFLIPRO_API FPROSensor_GetScanDirection (int32_t iHandle, bool *pHInverted, bool *pVInverted)
 Retrieves the current pixel scan direction settings on the sensor. More...
 
LIBFLIPRO_API FPROSensor_GetTrainingEnable (int32_t iHandle, bool *pEnable)
 Returns the sensor re-training setting. More...
 
LIBFLIPRO_API FPROSensor_SetAnalogGain (int32_t iHandle, int32_t iGainValue)
 Sets the analog gain for the sensor. More...
 
LIBFLIPRO_API FPROSensor_SetBinning (int32_t iHandle, uint32_t uiXBin, uint32_t uiYBin)
 Sets the desired horizontal and vertical binning. More...
 
LIBFLIPRO_API FPROSensor_SetBlackLevelAdjust (int32_t iHandle, FPROBLACKADJUSTCHAN eChan, uint32_t uiAdjustValue)
 Sets the current Black Level Adjustment values. More...
 
LIBFLIPRO_API FPROSensor_SetBlackSunAdjust (int32_t iHandle, FPROBLACKADJUSTCHAN eChan, uint32_t uiAdjustValue)
 Sets the current Black Sun Adjustment value. More...
 
LIBFLIPRO_API FPROSensor_SetHDREnable (int32_t iHandle, FPROHDR eHDREnable)
 Sets the setting for HDR enable. More...
 
LIBFLIPRO_API FPROSensor_SetHighGainOnlyEnable (int32_t iHandle, bool bHighGainOnly)
 Sets the High Gain Only Mode.

Note: The High Gain Only Mode is not applicable to all camera models. In addition, it is only applicable in HDR modes. When in an HDR mode, if the High Gain Only flag is set, only the High Gain image will be returned by the camera. More...
 
LIBFLIPRO_API FPROSensor_SetGainIndex (int32_t iHandle, FPROGAINTABLE eTable, uint32_t uiGainIndex)
 Sets the current setting for the Gain for the specified table. More...
 
LIBFLIPRO_API FPROSensor_SetMode (int32_t iHandle, uint32_t uiModeIndex)
 Sets the current mode specified by the given index. More...
 
LIBFLIPRO_API FPROSensor_SetReadoutConfiguration (int32_t iHandle, FPROSENSREADCFG eReadCfg)
 Sets the sensor read out configuration on supported models. More...
 
LIBFLIPRO_API FPROSensor_SetSamplesPerPixel (int32_t iHandle, FPROCMS eSamplesPerPixel)
 Sets the Samples Per Pixel settings on the sensor.

NOTE: This function is not supported on on all camera models. Consult your documentation for your specific camera.
More...
 
LIBFLIPRO_API FPROSensor_SetScanDirection (int32_t iHandle, bool bHInverted, bool bVInverted)
 Retrieves the current pixel scan direction settings on the sensor. More...
 
LIBFLIPRO_API FPROSensor_SetTrainingEnable (int32_t iHandle, bool bEnable)
 Enables/Disables sensor re-training. More...
 
LIBFLIPRO_API FPROAuxIO_GetPin (int32_t iHandle, FPROAUXIO eAuxIO, FPROAUXIO_DIR *pDirection, FPROAUXIO_STATE *pState)
 Gets the direction and state for given Auxiliary I/O pin. More...
 
LIBFLIPRO_API FPROAuxIO_GetExposureActiveType (int32_t iHandle, FPROAUXIO ePin, FPROAUXIO_EXPACTIVETYPE *pType, bool *pActiveHigh)
 Get Exposure Active Type Signal. More...
 
LIBFLIPRO_API FPROAuxIO_SetPin (int32_t iHandle, FPROAUXIO eAuxIO, FPROAUXIO_DIR eDirection, FPROAUXIO_STATE eState)
 Sets the direction and state for given Auxiliary I/O pin. More...
 
LIBFLIPRO_API FPROAuxIO_SetExposureActiveType (int32_t iHandle, FPROAUXIO ePin, FPROAUXIO_EXPACTIVETYPE eType, bool bActiveHigh)
 Exposure Active Type Signal. More...
 
LIBFLIPRO_API FPROFAck_GetEnable (int32_t iHandle, bool *pEnable)
 Get Frame Acknowledgment Mode Enable. More...
 
LIBFLIPRO_API FPROFAck_SetEnable (int32_t iHandle, bool bEnable)
 Set Frame Acknowledgment Mode Enable. More...
 
LIBFLIPRO_API FPROFAck_FrameAcknowledge (int32_t iHandle)
 Acknowledge the last frame sent in Frame Acknowledgment Mode. More...
 
LIBFLIPRO_API FPROFAck_FrameResend (int32_t iHandle)
 Re-send the last frame in Frame Acknowledgment Mode. More...
 
LIBFLIPRO_API FPROFAck_FlushImageQueue (int32_t iHandle)
 Flush the in memory frame queue in Frame Acknowledgment Mode. More...
 
LIBFLIPRO_API FPROAlgo_StackInitialize (int32_t iHandle)
 Initialize the stacking process. More...
 
LIBFLIPRO_API FPROAlgo_StackNextFrame (int32_t iHandle, uint8_t *pFrameData, uint32_t *pSize, uint32_t uiTimeoutMS)
 Capture and retrieve the next frame to stack from the camera. More...
 
LIBFLIPRO_API FPROAlgo_StackFinish (int32_t iHandle, uint16_t **ppLowMeanFrame, uint16_t **ppHighMeanFrame, uint32_t *pNumPixels, uint8_t **ppMetaData, uint32_t *puiMetaSize)
 Finish the stacking process and retrieve the mean frames. More...
 
LIBFLIPRO_API FPROAlgo_StackDeinitialize (int32_t iHandle)
 Returns all the resources allocated during the stacking process to the system. More...
 
LIBFLIPRO_API FPROAlgo_SetHardwareMergeReferenceFrames (int32_t iHandle, FPRO_REFFRAMES *pRefFrames)
 Sets the reference frames used in PCIE Fibre hardware image merging. More...
 
LIBFLIPRO_API FPROAlgo_SetHardwareMergeReferenceFiles (int32_t iHandle, const wchar_t *pDSNUFile, const wchar_t *pPRNUFile)
 Sets the reference frames used in PCIE Fibre hardware image merging. More...
 
LIBFLIPRO_API FPROAlgo_GetHardwareMergeThresholds (int32_t iHandle, uint16_t *pHighGainThreshold, uint16_t *pMergeDifferenceThreshold)
 Retrieve the current Hardware Merge Threshold values. More...
 
LIBFLIPRO_API FPROAlgo_SetHardwareMergeThresholds (int32_t iHandle, uint16_t uiHighGainThreshold, uint16_t uiMergeDifferenceThreshold)
 Retrieve the current Hardware Merge Threshold values. More...
 
LIBFLIPRO_API FPROAlgo_GetHardwareMergeEnables (int32_t iHandle, FPRO_HWMERGEENABLE *pMergeEnables)
 Retrieve the hardware merge enable settings. More...
 
LIBFLIPRO_API FPROAlgo_SetHardwareMergeEnables (int32_t iHandle, FPRO_HWMERGEENABLE mergeEnables)
 Enable/disable hardware merging options. More...
 
LIBFLIPRO_API FPRONV_WriteNVStorage (int32_t iHandle, uint32_t uiOffset, uint8_t *pData, uint32_t uiLength)
 Write the given data to the non volatile storage area on the camera. More...
 
LIBFLIPRO_API FPRONV_ReadNVStorage (int32_t iHandle, uint32_t uiOffset, uint8_t *pData, uint32_t uiLength)
 Read the non volatile storage area on the camera. More...
 
LIBFLIPRO_API FPRODebug_EnableLevel (bool bEnable, FPRODBGLEVEL eLevel)
 
LIBFLIPRO_API FPRODebug_SetLogPath (const wchar_t *pPath)
 
LIBFLIPRO_VOID FPRODebug_Write (FPRODBGLEVEL eLevel, const wchar_t *format,...)
 

Detailed Description

Finger Lakes Instrumentation Camera API.

The library uses the standard way of creating macros which make exporting from a DLL simpler. All files within this DLL are compiled with the LIBFLIPRO_EXPORTS symbol defined on the command line. This symbol should not be defined on any project that uses this DLL. This way any other project whose source files include this file see LIBFLIPRO_API functions as being imported from a DLL, whereas this DLL sees symbols defined with this macro as being exported.

Macro Definition Documentation

◆ FPRO_DEVICE_MAX_PATH_LENGTH

#define FPRO_DEVICE_MAX_PATH_LENGTH   (1024)

Maximum path length for low level OS device path.

The maximum number of characters (not bytes) allowed for device path strings throughout the API.

◆ FPRO_GAIN_SCALE_FACTOR

#define FPRO_GAIN_SCALE_FACTOR   (1000)

Gain Scale Factor.

All gain table values (see FPROGAINTABLE) returned by the API are scaled by the factor FPRO_GAIN_SCALE_FACTOR.

Examples
CapabilitiesAndGainTables.cpp.

◆ FPRO_IMAGE_DIMENSIONS_TO_FRAMEBYTES

#define FPRO_IMAGE_DIMENSIONS_TO_FRAMEBYTES (   __width,
  __height 
)    FPRO_IMAGE_PIXELS_TO_FRAMEBYTES((__width) * (__height))

Convert image dimensions in Pixels to Image size in Bytes.

This macro only works if the pixel size is 12 bits.

◆ FPRO_IMAGE_FRAMEBYTES_TO_PIXELS

#define FPRO_IMAGE_FRAMEBYTES_TO_PIXELS (   __framebytes)    (((__framebytes) << 1) / 3)

Convert image size in Bytes to Pixels.

The frame size is 1.5 * width * height (12 bit pixels) This macro only works if the pixel size is 12 bits.

◆ FPRO_IMAGE_PIXELS_TO_FRAMEBYTES

#define FPRO_IMAGE_PIXELS_TO_FRAMEBYTES (   __pixels)    (((__pixels) & 0x1) ? ((((__pixels) * 3 ) >> 1) + 1) : (((__pixels) * 3 ) >> 1))

Convert Pixels to Image size in Bytes.

This macro only works if the pixel size is 12 bits.

◆ FPRO_REFERENCE_ROW_MAX

#define FPRO_REFERENCE_ROW_MAX   (4094)

Maximum number of pre/post frame Reference rows supported by the API.

This number should be treated as a constant.

◆ FPRO_SENSOR_MODE_NAME_LENGTH

#define FPRO_SENSOR_MODE_NAME_LENGTH   (32)

Sensor Mode Name Length.

Max allowed name length for Camera Modes. See FPROSENSMODE

◆ FPRO_USB_STRING_MAXLEN

#define FPRO_USB_STRING_MAXLEN   (256)

Maximum String Length.

The maximum number of characters (not bytes) allowed in USB strings throughout the API.

◆ FPRO_VERSION_STRING_MAXLEN

#define FPRO_VERSION_STRING_MAXLEN   (32)

Version String Lengths.

Maximum length characters (not bytes) of version strings.

Typedef Documentation

◆ FPRO_CONV

Conversion info structure supplied to conversion functions.

This enum is used by the conversion functions to specify the resultant image format of the operation. It also supplies merge reference frames to use in the case a image merge needs to occur. If these are not supplied, identity frames are used based on the gain settings in the meta data of the given rcd file to convert. See FPROAlgo_SetHardwareMergeReferenceFiles and FPROFrame_ConvertFile for more information.

◆ FPRO_HWMERGEENABLE

Enables for Hardware Image Merging.

Version 2 and later of the PCIE Fibre interface card allows for the image merging process to be done in hardware directly on the card. This structure is used to enable the different merging options. See FPROAlgo_SetHardwareMergeEnables() and FPRO_REFFRAMES for more information.

In addition, the same merge algorithm used on the PCIE card is available in the API for use on USB connections, Fibre connections with older hardware, and even with version 2 PCIE hardware. For use in the API, all of the same hardware merge API's are used to set up the reference frames, thresholds, and enables (as with this structure). In the API's emulation, the bMergeEnable and eMergeFrames fields in this structure are ignored. You tell the API to merge or return the desired frames through the FPROUNPACKEDIMAGES structure using the FPROFrame_GetVideoFrameUnpacked() call. See the structure definition FPROUNPACKEDIMAGES for more information on unpacking and merging.

If unpacked and unmerged data is desired the FPROFrame_GetVideoFrame() call is used.

◆ FPRO_REFFRAMES

Reference Frames for Hardware Image Merging.

Version 2 and later of the PCIE Fibre interface allows for the image merging process to be done in hardware on the host side PCIE Fibre interface card. This structure is used to transfer the reference frames used in the processing. See FPROAlgo_SetHardwareMergeReferenceFrames and FPROAlgo_SetHardwareMergeReferenceFiles for additional information.

The format of the additive frames is a fixed point number with the lower 3 bits being the decimal. The 16 bit quantity must be in Little Endian byte order.
The aditive frames are also referred to as Dark Signal Non-Uniformity (DSNU) frames.

The format of the multiply frames is a fixed point number with the lower 10 bits being the decimal. For example, a vaue of 1.0 = 0x0400. These values must also be stored in Little Endian byte order.
The multiplicative frames are also referred to as Photo Response Non-Uniformity (PRNU) frames.

◆ FPROCONINFO

Connection Information.

This structure contains detailed information on how the camera is physically connected to the host. It is used as part of the FPRODEVICEINFO structure returned by the FPROCam_GetCameraList function. See FPRODEVICEINFO and FPROCam_GetCameraList for additional information.

◆ FPRODBGLEVEL

Convenience (unsigned int) typedef for debug levels.

The API provides a debug interface. This sets the level of debug information that can be logged by your application.

◆ FPRODEVICEINFO

Device Information.

This is used as the Camera Device enumeration structure. It is returned by the FPROCam_GetCameraList function and contains the list of detected cameras. To open a connection to a specific camera, a single FPRODEVICEINFO structure is passed to the FPROCam_Open function.

◆ FPRODEVICEVERS

Device Version Information.

Contains the various version numbers supplied by the device. See FPROCam_GetDeviceVersion.

◆ FPROEXTTRIGINFO

External Trigger Setup Details.

This structure is used to set up the External Trigger capability on the camera. See FPROEXTTRIGTYPE for more information.
Note that the bSingleFramePerTrigger function is not avaliable on older cameras. This function was introduced in the camera firmware versions 0x2A. In addition, in API versions prior to 1.12.32, the API enforced an Image Count of 1 when enabling the external trigger.

◆ FPROFIBREINFO

Fibre Connection Information.

This structure contains detailed information on the physical Fibre connection. See FPRODEVICEINFO for additional information.

◆ FPROGAINVALUE

Gain Value.

The function FPROSensor_GetGainTable returns a list of FPROGAINVALUE items. The uiDeviceIndex must be used to set the desired gain on the camera using the FPROSensor_SetGainIndex function.

◆ FPROHOSTINFO

Host driver and hardware information.

This structure contains detailed information for any host drivers or hardware specific to the FLI cameras (e.g. the PCIE Fibre card). This structure is used by the FPROCam_GetHostInterfaceInfo API and is typically used for debug purposes.

◆ FPROIPINFO

IP Connection Information.

This structure contains detailed information on the physical IP Network connection. See FPRODEVICEINFO for additional information.

◆ FPROMETAVALUE

Defined a value for Meta Data fields.

A composite structure to define the value of a Met Data field as defined by the FPRO_META_KEYS enumeration. The value is either a number represented by a double, or a character string. If the value is a character string, the iByteLength of the pMetaValue will be gretaer than or equal (>=) to zero. If the value is represented by a number, the iByteLength field will be less than (<) zero.

◆ FPROPIXELINFO

Defines a location and value of a pixel within an image plane.

A composite structure to define a location and value of a pixel within an image plane. Used by other structures in the API such as FPROPLANESTATS to specify the location of the dimmest and brightest pixels in an image plane.

◆ FPROPLANESTATS

Defines the set of statistics available for unpacked frames.

This structure provides the given statistics for an image plane when unpacked by the API. See FPROUNPACKEDSTATS for more information.

◆ FPROPOINT

Point Coordinates.

A simple structure to define a point in space. Used by other structures in the API such as FPROPLANESTATS to specify the location of the dimmest and brightest pixels in an image plane.

◆ FPROSENSMODE

Sensor Modes.

The FLI Camera devices support the concept of 'Modes'. A mode is a collection of settings for the camera. As this structure illustrates, the mode has a name and an index. The name can be used primarily for a user interface so that a user can see a friendly and descriptive name for the mode. The index is used by the API to set a particular mode on the camera. See FPROSensor_SetMode, FPROSensor_GetMode, and FPROSensor_GetModeCount.

◆ FPROSTREAMSTATS

Streamer Statistics.

The FLI Camera devices support the ability to stream images to disk. The FPROFrame_Streamxxx() API's are used to enable, start, and stop the streaming process. In addition, FPROFrame_StreamGetStatistics() is provided to retrieve the current stream statistics in this structure. The statistics are reset each time FPROFrame_StreamStart() is called.

◆ FPROUNPACKEDIMAGES

Unpacked Image Buffers.

The raw data returned by the cameras is of varying formats, bit depths, and interleaving based on the internal sensor used in the camera. In order to make use of the data for analysis or display, the images must be unpacked to a form more suitable for such purposes. This structure is used by the API to allow the application to request the frames to be automatically unpacked. The specific usage of these pointers is described in the function documentation in which they are used. For example, see FPROFrame_GetVideoFrameUnpacked() for a description of how this structure is used for that particular call.

◆ FPROUNPACKEDSTATS

Statistics for unpacked image planes.

A structure to retrieve the statistics for unpacked frames. The pointers within the encapsulated structures are allocated and deallocated by the API. See FPROFrame_GetVideoFrameUnpacked() for a description of how this structure is used for that particular call.

Enumeration Type Documentation

◆ FPRO_FRAME_TYPE

Image Frame Type.

The camera has the ability to produce different frame types. The default frame type is FPRO_FRAMETYPE_NORMAL. Consult you camera documentation for the details of each frame type and availability on a given camera model.

See FPROFrame_SetFrameType() and FPROFrame_GetFrameType().

Enumerator
FPRO_FRAMETYPE_NORMAL 

Normal Frame (default).

FPRO_FRAMETYPE_DARK 

Dark Frame.

FPRO_FRAMETYPE_BIAS 

Bias Frame.

FPRO_FRAMETYPE_LIGHTFLASH 

Light Flash Frame.

FPRO_FRAMETYPE_DARKFLASH 

Dark Flash Frame.

◆ FPRO_HWMERGEFRAMES

Enables for Hardware Image Merging.

This enum is used by the hardware merging algorithms and specifies which image planes from the camera to merge. See FPRO_HWMERGEENABLE. Normally you would merge both the low and high gain frames to get the best resultant merged image. This allows you to obtain either the low or high gain images as well.

Enumerator
HWMERGE_FRAME_BOTH 

Normal merge, both low and high gain planes are corrected and merged.

HWMERGE_FRAME_LOWONLY 

Only the corrected low gain pixels will be sent through to the API. The high gain pixels will be ignored.

HWMERGE_FRAME_HIGHONLY 

Only the corrected high gain pixels will be sent through to the API. The low gain pixels will be ignored.

◆ FPRO_IMAGE_FORMAT

Output Frame Formats for image merging and conversion.

This enum is used by the merging algorithms and conversion functions to specify the resultant image format of the operation.

Enumerator
IFORMAT_RCD 

FLI native RCD Frame.

IFORMAT_TIFF 

TIFF Formatted image.

IFORMAT_FITS 

FITS formatted image.

◆ FPRO_META_KEYS

The list of available Meta Data keys.

The meta data of an image may be parsed and the values for the fields described by this enumeration may be retrieved. See the FPROMETAVALUE structure and the FPROFrame_MetaValueInit(), FPROFrame_MetaValueInitBin(), FPROFrame_MetaValueGet(), and FPROFrame_MetaValueGetNext() API calls for additional information.

Enumerator
META_KEY_CAPTURE_DATE 

(uiYear << 16) | (uiMonth << 8) | (uiDay)

◆ FPRO_PIXEL_FORMAT

SUpported Pixel Formats across the various cameras.

This enum defines the supported Pixel Formats supported by the various FLI cameras. Note that not all cameras support all the formats. A given camera model will only support a small subset of these formats. In order to obtain the list of supported Pixel Formats for a specific camera, you can use the FPROFrame_GetSupportedPixelFormats() API. Further, see FPROFrame_GetPixelFormat() and FPROFrame_SetPixelFormat() for additional information.

Enumerator
PFORMAT_MONO8 

Gray scale 8 bits per pixel.

PFORMAT_BAYER8_GRBG 

8 bits per pixel. Data in Bayer pattern format with first pixel being green (on a red line).

PFORMAT_BAYER8_RGGB 

8 bits per pixel. Data in Bayer pattern format with first pixel being red.

PFORMAT_BAYER8_GBRG 

8 bits per pixel. Data in Bayer pattern format with first pixel being green (on a blue line).

PFORMAT_BAYER8_BGGR 

8 bits per pixel. Data in Bayer pattern format with first pixel being bllue.

PFORMAT_MONO10_PACKED_MSFIRST 

Gray scale 10 bits per pixel. Most significant bit is first (beg-endian like).

PFORMAT_BAYER10_GRBG_PACKED_MSFIRST 

10 bits per pixel. Data in Bayer pattern format with first pixel being green (on a red line).

PFORMAT_BAYER10_RGGB_PACKED_MSFIRST 

10 bits per pixel. Data in Bayer pattern format with first pixel being red.

PFORMAT_BAYER10_GBRG_PACKED_MSFIRST 

10 bits per pixel. Data in Bayer pattern format with first pixel being green (on a blue line).

PFORMAT_BAYER10_BGGR_PACKED_MSFIRST 

10 bits per pixel. Data in Bayer pattern format with first pixel being blue.

PFORMAT_MONO12_PACKED 

Gray scale 12 bits per pixel so 2 pixels are spread over 3 bytes.
The first byte will contain the 8 most significant bits of the first pixel and
the 4 least significant bits of the second byte contain the 4 least significant bits of the first pixel.
The most significant 4 bits of the second byte contain the least significant 4 bits of the second pixel, and the 3rd byte will contain the most significant 8 bits of the second pixel.

PFORMAT_BAYER12_GRBG_PACKED 

12 bits per pixel. Data in Bayer pattern format with first pixel being green (on a red line). See PFORMAT_MONO12_PACKED for packing information.

PFORMAT_BAYER12_RGGB_PACKED 

12 bits per pixel. Data in Bayer pattern format with first pixel being red. See PFORMAT_MONO12_PACKED for packing information.

PFORMAT_BAYER12_GBRG_PACKED 

12 bits per pixel. Data in Bayer pattern format with first pixel being green (on a blue line). See PFORMAT_MONO12_PACKED for packing information.

PFORMAT_BAYER12_BGGR_PACKED 

12 bits per pixel. Data in Bayer pattern format with first pixel being blue. See PFORMAT_MONO12_PACKED for packing information.

PFORMAT_MONO12_PACKED_MSFIRST 

Gray scale 12 bits per pixel so 2 pixels are spread over 3 bytes.

PFORMAT_BAYER12_GRBG_PACKED_MSFIRST 

12 bits per pixel. Data in Bayer pattern format with first pixel being green (on a red line).

PFORMAT_BAYER12_RGGB_PACKED_MSFIRST 

12 bits per pixel. Data in Bayer pattern format with first pixel being red.

PFORMAT_BAYER12_GBRG_PACKED_MSFIRST 

12 bits per pixel. Data in Bayer pattern format with first pixel being green (on a blue line).

PFORMAT_BAYER12_BGGR_PACKED_MSFIRST 

12 bits per pixel. Data in Bayer pattern format with first pixel being blue.

PFORMAT_MONO16 

Gray scale 16 bits per pixel.

PFORMAT_MONO16_MSFIRST 

Gray scale 16 bits per pixel.

PFORMAT_YUV422 

Color, 16 bits per pixel, with a coding pattern of U0, Y0, V0, Y1, U2, Y2, V2, Y3.

PFORMAT_BAYER16_GRBG 

16 bits per pixel. Data in Bayer pattern format with first pixel being green (on a red line).

PFORMAT_BAYER16_RGGB 

16 bits per pixel. Data in Bayer pattern format with first pixel being red.

PFORMAT_BAYER16_GBRG 

16 bits per pixel. Data in Bayer pattern format with first pixel being green (on a blue line).

PFORMAT_BAYER16_BGGR 

16 bits per pixel. Data in Bayer pattern format with first pixel being blue.

PFORMAT_RGB24 

Color, 8 bits per color, 24 bits per pixel (RGB).

PFORMAT_RGB24_NON_DIB 

Color, 24 bits per pixel.

PFORMAT_BGR24 

Color, 8 bits per color, 24 bits per pixel (BGR).

PFORMAT_RGBA 

Color, 32 bits per pixel with alpha channel (RGBA).

PFORMAT_BGRA 

Color, 32 bits per pixel with alpha channel (BGRA).

PFORMAT_ARGB 

Color, 32 bits per pixel with alpha channel (ARGB).

PFORMAT_ABGR 

Color, 32 bits per pixel with alpha channel (ABGR).

PFORMAT_RGB48 

Color, 48 bits per pixel.

PFORMAT_RGB48_DIB 

Color, 48 bits per pixel.

PFORMAT_STOKES4_12 

48 bits per pixel, 12 bits for each of 4 Stokes channels.

PFORMAT_POLAR4_12 

48 bits per pixel � made up of a 12 bit weighted polar channel value, repeated 4 times.

PFORMAT_POLAR_RAW4_12 

48 bits per pixel; 4 12-bit values for each of the polar channels � 0, 45, 90, and 135 degrees.

PFORMAT_HSV4_12 

48 bits per pixel; 12 bits for each of degree and angle of polarization, and 12 bits pixel value repeated twice.

◆ FPROAUXIO

enum FPROAUXIO

Auxiliary I/O Pins.

The camera makes available auxiliary I/O pins for customer defined use. This enum simply assigns a name for each of the pins to be used in the FPROAuxIO_xxx() set of API calls.

Note that different camera models can support different Aux I/O pins. Consult your specific camera documentation for supported pins and physical pin outs.

Enumerator
FPRO_AUXIO_1 

Name for AUX I/O Pin 1.

FPRO_AUXIO_2 

Name for AUX I/O Pin 2.

FPRO_AUXIO_3 

Name for AUX I/O Pin 3.

FPRO_AUXIO_4 

Name for AUX I/O Pin 4.

◆ FPROAUXIO_DIR

Auxiliary I/O Pin Direction.

The camera makes available auxiliary I/O pins for customer defined use. The pins can be defined as inputs or outputs. This enum is to be used with the FPROAuxIO_xxx() set of API calls to set the direction of a given AUX I/O pin. See FPROAUXIO for more information.

Note that different camera models can support different Aux I/O pins. Consult your specific camera documentation for supported pins and physical pin outs.

Enumerator
FPRO_AUXIO_DIR_IN 

Set AUX I/O pin as an input with respect to the camera.

FPRO_AUXIO_DIR_OUT 

Set AUX I/O pin as an output with respect to the camera.

◆ FPROAUXIO_EXPACTIVETYPE

Exposure Active Auxiliary Output.

The camera makes available an auxiliary output pin that signals when an exposure is active. This enum defines the the set of signal types that may be configured for the output. Consult your specific camera documentation for the timing details of each of these signal types.

Note that different camera models can support different Aux I/O pins. Consult your specific camera documentation for supported pins and physical pin outs.

Enumerator
FPRO_AUXIO_EXPTYPE_EXPOSURE_ACTIVE 

Exposure Active- If supported, consult your camera documentation for timing details.

FPRO_AUXIO_EXPTYPE_GLOBAL_EXPOSURE_ACTIVE 

Global Exposure Active- If supported, consult your camera documentation for timing details.

FPRO_AUXIO_EXPTYPE_FIRST_ROW_SYNC 

First Row Sync- If supported, consult your camera documentation for timing details.

◆ FPROAUXIO_STATE

Auxiliary Output State.

The camera makes available auxiliary I/O pins for customer defined use. The pins can be defined as inputs or outputs. For pins defined as outputs, this enum is to be used with the FPROAuxIO_xxx() set of API calls to set the state of that pin. See FPROAUXIO for more information.

Note that different camera models can support different Aux I/O pins. Consult your specific camera documentation for supported pins and physical pin outs.

Enumerator
FPRO_AUXIO_STATE_LOW 

Pin is in the low state.

FPRO_AUXIO_STATE_HIGH 

Pin is in the high state.

◆ FPROBLACKADJUSTCHAN

Black Adjust Channels.

Depending on the camera model, multiple channels may be supported with respect to Black Level and Black Sun adjustment. This enumeration lists the appropriate channels supported by the API. They are meant for use with the FPROSensor_GetBlackLevelAdjust, and FPROSensor_GetBlackSunAdjust API calls to specify the channel for the adjustment.

Enumerator
FPRO_BLACK_ADJUST_CHAN_LDR 

Specifies the LDR Black adjust channel.

FPRO_BLACK_ADJUST_CHAN_HDR 

Specifies the HDR Black adjust channel.
NOTE: Not supported on all devices. See your specific device documentation for details.

◆ FPROCAPROI

enum FPROCAPROI

Region of Interest Support.

Different camera models offer different levels of support for specifying a Region of Interest (ROI) for the image frame. When supported by the camera device, this can be used to specify an image region smaller than the full frame to effectively increase the the frame rate of for those images. This enumeration an the FPROCAP_ROI_xxx macros are intended to operate on the FPROCAP_ROI_SUPPORT capability of the FPROCAPS array. See the macros FPROCAP_ROI_BYCOL_ISCAM_SUPPORTED, FPROCAP_ROI_BYCOL_ISAPI_SUPPORTED, FPROCAP_ROI_BYROW_ISCAM_SUPPORTED, and FPROCAP_ROI_BYROW_ISAPI_SUPPORTED for additional information. Also see the FPROSensor_GetCapabilityList() for additional information.

The FPROCAPROI enumeration defines the specific support flags for ROI. Support can be by row, by column, or both. By Row support means that you can specify an arbitrary hight and row offset in the FPROFrame_SetImageArea() API. By Column support means that you can specify an arbitrary width and column offset in the FPROFrame_SetImageArea() API.

If the API_ONLY flag is set for the given dimension, the support if only available through software processing in the API. While this can simplify your application, the performance of this feature is based on the performance of your computer platform. In the case of API only support, the API will request the smallest frame it can get from the camera (e.g. always full rows if 'by column' is not supported) and extract the region of interest for the caller. This involves parsing the raw image data and memory copying to the users buffer.

Enumerator
FPROCAP_ROI_NONE 

No ROI supported.

FPROCAP_ROI_BYROW 

By Row ROI is supported by the camera.

FPROCAP_ROI_BYROW_API_ONLY 

By Row ROI is supported only by the API.

FPROCAP_ROI_BYCOL 

By Column ROI is supported by the camera.

FPROCAP_ROI_BYCOL_API_ONLY 

By Column ROI is supported only by the API.

◆ FPROCAPS

enum FPROCAPS

Camera Capabilities.

Different camera models offer different sets of capabilities based on the imaging sensor and other hardware attributes. The values returned for these can be used by an application to configure settings and user interfaces based on the specific camera model that is connected. The uiDeviceType capability is a specific device type, one of FPRODEVICETYPE, that allows further checking by an application as it can cover specific functionality for each model.
That is, the uiDeviceType number maps to a specific camera model. As such, you can use this number along with the user documentation provided for the associated camera model to determine specific functionality not covered here. See the FPROSensor_GetCapabilityList() for additional information.

Image Scan Inversion: The FPROCAP_IMAGE_INVERTABLE capability indicates whether or not the image sensor supports an inverted readout scan of the pixels. The 32 bit value returned for this capability is partitioned into two 16 bit quantities. The least significant bit of the upper 16 bits (0x00010000) is the horizontal inversion capability (1 == inverted). The least significant bit of the lower 16 bits (0x00000001) is the vertical inversion capability.

Frame Reference Rows: The CAP_FRAME_REFERENCE_ROWS fields in the capabilities enumeration is the number of physical pre/post frame imaging sensor cells available for the camera model. The 32 bit value returned for this capability is partitioned into two 16 bit numbers. The upper 16 bits contains the pre-reference rows, the lower 16 bits contains the post-rows pixels.



Row Reference Pixels: The FPROCAP_ROW_REFERENCE_PIXELS are reference pixels that may occur prior (pre) or after (post) each row in an image. Each camera model handles row reference pixels differently. Consult your camera model documentation for additional information.
See See FPROFrame_SetDummyPixelEnable. The 32 bit value returned for this capability is partitioned into two 16 bit numbers. The upper 16 bits contains the pre-reference pixels, the lower 16 bits contains the post-reference pixels.

FPROCAP_MERGE_REFERENCE_FRAMES_SUPPORTED: When calling the FPROFrame_GetVideoFrameUnpacked() API to get unpacked image data, some cameras support image correction through the Merge Reference Frame API's (See FPRO_REFFRAMES and FPROAlgo_SetHardwareMergeReferenceFiles). Use this capability setting to see if your camera will support the image correction.

Enumerator
FPROCAP_DEVICE_TYPE 

General device type- see documentation.

FPROCAP_META_DATA_SIZE 

Number of bytes used for the pre-frame image meta data.

FPROCAP_MAX_PIXEL_WIDTH 

Max allowed image width in pixels.

FPROCAP_MAX_PIXEL_HEIGHT 

Max allowed image height in pixels.

FPROCAP_PIXEL_BIT_DEPTHS 

Bit 'b' is set if pixel b+1 depth allowed (bit 0 (lsb)= pixel depth 1)

FPROCAP_BINNING_TABLE_SIZE 

0= 1:1 binning only

FPROCAP_BLACK_LEVEL_MAX 

Max Value Allowed (see FPROSensor_SetBlackLevelAdjust())

FPROCAP_BLACK_SUN_MAX 

Max Value Allowed (see FPROSensor_SetBlackSunAdjust())

FPROCAP_LOW_GAIN_TABLE_SIZE 

Number of Gain Values (Low Gain channel for low gain frame in HDR Modes)

FPROCAP_HIGH_GAIN_TABLE_SIZE 

Number Of Gain Values (High Gain channel for LDR and HDR Modes)

FPROCAP_ROW_SCAN_TIME 

Row Scan Time in nano secs (LDR)

FPROCAP_ROW_REFERENCE_PIXELS 

Number of Pre and Post Row Dummy Pixels when enabled.

FPROCAP_FRAME_REFERENCE_ROWS 

Number of Pre and Post Frame Reference rows available.

FPROCAP_IMAGE_INVERTABLE 

False= Normal scan direction only, True= Inverse Scan Available.

FPROCAP_NV_STORAGE_AVAILABLE 

Number of bytes used for the pre-frame image meta data.

FPROCAP_MERGE_REFERENCE_FRAMES_SUPPORTED 

Whether merge reference frames are supported: 0= not supported, otherwise supported.

FPROCAP_ROI_SUPPORT 

Region of Interest Support: Row support is in upper 16 bits, column support in lower 16 bits.
See the FPROCAPROI enumeration for details. Use the FPROCAP_ROI_xxx macros to inspect.

FPROCAP_NUM 

Number of supported capabilities.

◆ FPROCMS

enum FPROCMS

Correlated Multiple Samples (Samples Per Pixel)

Some camera models are capable of taking multiple sensor samples per pixel. Based on imaging modes this can effect the amount of image data sent by the camera for a frame of data. Consult your specific camera documentation for details on how this feature is supported and its effect on image data. The values are used in the FPROSensor_GetSamplesPerPixel() and FPROSensor_SetSamplesPerPixel() API calls.

Enumerator
FPROCMS_1 

Single Sample Per Pixel. This is the default for all cameras.

FPROCMS_2 

Two sensor samples per pixel are read out.

FPROCMS_4 

Four sensor samples per pixel are read out.

◆ FPROCONNECTION

Supported Connection Types.

This enumeration is used as part of the FPRODEVICEINFO structure to return the physical connection type to the camera.

Enumerator
FPRO_CONNECTION_USB 

Camera is connected with a USB link.

FPRO_CONNECTION_FIBRE 

Camera is connected with a Fibre Optic link.

FPRO_CONNECTION_ENET 

Camera is connected with an ethernet link.

◆ FPRODEVICETYPE

Known Device Types.

These constants are returned for the Device Capabilities enumeration FPROCAPS::CAP_DEVICE_TYPE in the member. See the user manual for a description of the capabilities for your device.

Enumerator
FPRO_CAM_DEVICE_TYPE_GSENSE400 

Enum value = 0x01000400.

FPRO_CAM_DEVICE_TYPE_GSENSE2020 

Enum value = 0x01002020.

FPRO_CAM_DEVICE_TYPE_GSENSE4040 

Enum value = 0x01004040.

FPRO_CAM_DEVICE_TYPE_GSENSE6060 

Enum value = 0x01006060.

FPRO_CAM_DEVICE_TYPE_DC230_42 

Enum value = 0x03023042.

FPRO_CAM_DEVICE_TYPE_DC230_84 

Enum value = 0x03023084.

FPRO_CAM_DEVICE_TYPE_SONYIMX183 

Enum value = 0x04000183.

FPRO_CAM_DEVICE_TYPE_FTM 

Enum value = 0x04000F1F.

FPRO_CAM_DEVICE_TYPE_LSGEN 

Enum value = 0x850F0000.

◆ FPROEXTTRIGTYPE

External Trigger Types.

This enumeration defines the types of external triggers available. There is a single external trigger line available to the camera. This enumeration governs how this signal behaves. This enumeration is used with the FPROCtrl_GetExternalTriggerEnable and FPROCtrl_SetExternalTriggerEnable API's.

Enumerator
FLI_EXT_TRIGGER_FALLING_EDGE 

Trigger Exposure on Falling Edge
For this setting, when the external trigger line goes from high to low, it triggers the exposure to begin on the camera. The exposure will complete based on the exposure time set with the FPROCtrl_SetExposure API.

FLI_EXT_TRIGGER_RISING_EDGE 

Trigger Exposure on Rising Edge
For this setting, when the external trigger line goes from low to high, it triggers the exposure to begin on the camera. The exposure will complete based on the exposure time set with the FPROCtrl_SetExposure API.

FLI_EXT_TRIGGER_EXPOSE_ACTIVE_LOW 

Exposure Active High
For this setting, the exposure is active the entire time the external trigger signal is low.
The exposure will complete when the external trigger line goes high or when the exposure time has reached the value set with the FPROCtrl_SetExposure API (whichever occurs first).
That is, in this case the value used in the FPROCtrl_SetExposure API acts as a maximum exposure time.

FLI_EXT_TRIGGER_EXPOSE_ACTIVE_HIGH 

Exposure Active High
For this setting, the exposure is active the entire time the external trigger signal is high.
The exposure will complete when the external trigger line goes low or when the exposure time has reached the value set with the FPROCtrl_SetExposure API (whichever occurs first).
That is, in this case the value used in the FPROCtrl_SetExposure API acts as a maximum exposure time.

◆ FPROGAINTABLE

Gain Tables.

The camera makes available specific gain values for the image sensor. Each set of values is stored in a table and this enum allows you to pick the desired gain table to get using the function FPROSensor_GetGainTable. The values in the table can be used as part of a user interface allowing users to select a specific gain setting. The settings are retrieved and set by index in the gain table using FPROSensor_GetGainIndex and FPROSensor_SetGainIndex.

Note that all gain table values returned by the API are scaled by the factor FPRO_GAIN_SCALE_FACTOR.

Enumerator
FPRO_GAIN_TABLE_LOW_CHANNEL 

Low Gain Channel used for Low Gain images in HDR modes.

FPRO_GAIN_TABLE_HIGH_CHANNEL 

High Gain Channel used for LDR modes
NOTE: Different cameras support different gain settings. See FPROCAPS for obtaiing the size of each of these gain tables.

◆ FPROGPSOPT

enum FPROGPSOPT

GPS Options.

This enumeration defines the possible options that may be set up for the GPS unit. Note that not all cameras support this feature. Consult your camera documentation for details.

Enumerator
FPRO_GPSOPT_WAAS_EGNOS_ENABLE 

Enable the WAAS and EGNOS augmentation feature.

FPRO_GPSOPT_GLONASS_ENABLE 

Enable GLONASS (Globalnaya Navigazionnaya Sputnikovaya Sistema, or Global Navigation Satellite System) capability.

◆ FPROGPSSTATE

GPS Connection State.

This enumeration defines the possible states of an optional GPS receiver attached to the camera. The GPS data is contained in the Meta Data that prepends every image. The format for the fields in the Meta Data is shown below:

Timestamp

Year - 2016(31:26), Month(25:22), Days(21:17), Hours(16:12), Minutes(11:6), Seconds(5:0)


Longitude

East / West(31), 600000 * DDD + 10000 * MM.MMMM(31:0)

Where bit 31 is 1 for East and 0 for West

Latitude

North / South(31), 600000 * DD + 10000 * MM.MMMM(31:0)

Where bit 31 is 1 for North and 0 for South

Enumerator
FPRO_GPS_NOT_DETECTED 

GPS unit has not been detected by the camera.

FPRO_GPS_DETECTED_NO_SAT_LOCK 

GPS unit has been detected by the camera but the satellite lock has not been made.

FPRO_GPS_DETECTED_AND_SAT_LOCK 

GPS unit has been detected by the camera and the satellite lock has been made. This is the only value that will provide accurate results in the Meta Data.

FPRO_GPS_DETECTED_SAT_LOCK_TIME_ERROR 

GPS unit has been detected by the camera and the satellite lock has been made. The camera has lost the precision time signal from the GPS unit. As a result, the time stamp in the meta data for an image could be incorrect by as much as 1 second. This is typically the result of using the external illumination signal on the camera (the physical lines are shared). Make sure the the external illumination signal is off using the FPROCtrl_SetIlluminationOn() API. This could also be caused by a GPS cable problem.

◆ FPROHDR

enum FPROHDR

HDR Mode setting.

When enabled, puts the camera in a High Dynamic Range (HDR) mode of operation, whereby images can be produced that have enhanced detail discernment in dark areas of the image, without compromising brighter areas of the image. As this enumeration describesm there are two separate settings for an HDR mode: 1.) FPRO_HDR_CAMERA: Using internal algorithm, the camera returns a 'combined' resultant image to the application. 2.) FPRO_HDR_INTERLEAVED: The camera returns both the �dark� and �bright� planes of the same image to the application. It is up to the application to use its own HDR algorithms to combine the interleaved images to a final resultant image. br> br> Not all camera models support the FPRO_HDR_CAMERA setting. Use the FPROSensor_GetHDREnable() API to retrieve the actual value. For Kepler Cameras, the HDR setting is typically enabled/disabled by setting the appropriate mode using the FPROSensor_SetMode() API.

Enumerator
FPRO_HDR_DISABLED 

HDR mode is disabled.

FPRO_HDR_CAMERA 

HDR Mode is enabled and the camera will combine the image planes.

FPRO_HDR_INTERLEAVED 

HDR Mode is enabled and the application must combine the image planes.

◆ FPROSENSREADCFG

Sensor Read Out Configuration.

Some camera models support different physical imaging sensor read out configurations. This enumeration allows setting and retrieving the sensor read out configuration through the FPROSensor_SetReadoutConfiguration() and FPROSensor_GetReadoutConfiguration(). Consult your camera user documentation for availability of this feature for your camera model.
For the Cobalt cameras that support this feature, you may select one of the channels or all four of the channels. Selecting 2 or 3 channels is not allowed.

Enumerator
FPRO_SENSREAD_CB_BOTTOMLEFT 

Read data using the bottom left channel of the sensor.

FPRO_SENSREAD_CB_BOTTOMRIGHT 

Read data using the bottom left channel of the sensor.

FPRO_SENSREAD_CB_TOPLEFT 

Read data using the top left channel of the sensor.

FPRO_SENSREAD_CB_TOPRIGHT 

Read data using the top right channel of the sensor.

FPRO_SENSREAD_CB_ALL 

Read data using all 4 sensor channels.

◆ FPROSTREAMERSTATUS

Streamer Status.

The FLI Camera devices support the ability to stream images to disk. The FPROFrame_Streamxxx() API's are used to enable, start, and stop the streaming process. In addition, FPROFrame_StreamGetStatistics() is provided to retrieve the current stream statistics. The status is part of the FPROSTREAMSTATS statistics returned by the FPROFrame_StreamGetStatistics() API. Note that this status is with respect to images arriving from the camera. Multiple frames can be received and queued to be written to disk. As such, in order to correctly determine when all images have been received and written to the disk, you need to check the FPROSTREAMSTATS uiDiskFramesWritten field and make sure it matches the number of images you requested. If you stop the stream before all frames are written to the disk, any frames not fully written will be lost.

Enumerator
FPRO_STREAMER_STOPPED_ERROR 

If streaming has stopped due to an error, the status will be less than 0. Consult the log file for error messages.

FPRO_STREAMER_STOPPED 

Streaming Stopped. This is the default state. It also enters this state when the requested number of images have been streamed or FPROFrame_StreamStop() is called.

FPRO_STREAMER_STREAMING 

Streaming is running. This state is entered when streaming is started via the FPROFrame_StreamStart() API. It remains in this state until FPROFrame_StreamStop() is called, the requested number of images have been streamed, or an error has caused streaming to stop.

◆ FPROTESTIMAGETYPE

Test Image Types.

Some cameras have the ability to generate test image data. This enumeration is used to tell the camera how you would like the test image data to be formatted. Not all cameras support all test image types. Consult you camera documentation for more details on which test images are supported for your device.

Enumerator
FLI_TESTIMAGE_TYPE_ROW 

Row order format.
The first 'width' number of pixels will be 0, the second 'width' number of pixels will be 1... etc.

FLI_TESTIMAGE_TYPE_COL 

Column order format.
The first pixel of the first row will be 0, the second pixel will be 1... the n'th pixel of the row will n. The first pixel of the second row will be 0 again, followed by 1, etc...

FLI_TESTIMAGE_IMX183_VERTICAL 

IMX183 Sensor Vertical Test Pattern.

FLI_TESTIMAGE_IMX183_HORIZONTAL 

IMX183 Sensor Horizontal Test Pattern.

FLI_TESTIMAGE_IMX183_ALL_LOW 

IMX183 Sensor All Low Test Pattern.
All pixels are 0x000.

FLI_TESTIMAGE_IMX183_ALL_HIGH 

IMX183 Sensor All High Test Pattern.
All pixels are 0xFFF.

FLI_TESTIMAGE_IMX183_LOW_HIGH 

IMX183 Sensor Repeating Low High Test Pattern.
All pixels are 0x555.

FLI_TESTIMAGE_IMX183_HIGH_LOW 

IMX183 Sensor Repeating High Low Test Pattern.
All pixels are 0xAAA.

◆ FPROUSBSPEED

Known USB Connection Speeds.

This enumeration is used as part of the FPRODEVICEINFO structure to return the detected USB connection speed. FLI Cameras require a FPRO_USB_SUPERSPEED USB connection in order to transfer image data reliably.

Enumerator
FPRO_USB_FULLSPEED 

Full Speed Connection.

FPRO_USB_HIGHSPEED 

High Speed Connection.

FPRO_USB_SUPERSPEED 

Super Speed Connection.

Function Documentation

◆ FPROAlgo_GetHardwareMergeEnables()

LIBFLIPRO_API FPROAlgo_GetHardwareMergeEnables ( int32_t  iHandle,
FPRO_HWMERGEENABLE pMergeEnables 
)

Retrieve the hardware merge enable settings.

Note this functionality only exists on Host PCIE Fibre connections version 2 or later. See FPROAlgo_SetHardwareMergeEnables().

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pMergeEnables- The enables for various options. See FPRO_HWMERGEENABLE for more information.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAlgo_GetHardwareMergeThresholds()

LIBFLIPRO_API FPROAlgo_GetHardwareMergeThresholds ( int32_t  iHandle,
uint16_t *  pHighGainThreshold,
uint16_t *  pMergeDifferenceThreshold 
)

Retrieve the current Hardware Merge Threshold values.

Note this functionality only exists on Host PCIE Fibre connections version 2 or later. If you use hardware merging, you must call this API prior to calling FPROFrame_ComputeFrameSize().

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pHighGainThreshold- The returned high gain pixel value threshold. See FPROAlgo_SetHardwareMergeThresholds for a description.
pMergeDifferenceThreshold- The returned merge difference threshold. See FPROAlgo_SetHardwareMergeThresholds for a description.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAlgo_SetHardwareMergeEnables()

LIBFLIPRO_API FPROAlgo_SetHardwareMergeEnables ( int32_t  iHandle,
FPRO_HWMERGEENABLE  mergeEnables 
)

Enable/disable hardware merging options.

Note this functionality only exists on Host PCIE Fibre connections version 2 or later. If you use hardware merging, you must call this API prior to calling FPROFrame_ComputeFrameSize().

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
mergeEnables- The enables for various options. See FPRO_HWMERGEENABLE for more information.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp, SimpleHWMerging.cpp, and StreamingAndHWMerge.cpp.

◆ FPROAlgo_SetHardwareMergeReferenceFiles()

LIBFLIPRO_API FPROAlgo_SetHardwareMergeReferenceFiles ( int32_t  iHandle,
const wchar_t *  pDSNUFile,
const wchar_t *  pPRNUFile 
)

Sets the reference frames used in PCIE Fibre hardware image merging.

This function is analogous to the FPROAlgo_SetHardwareMergeReferenceFrames API. It expects RCD Files as generated by the FLI Pilot application rather than the raw reference frame data. It builds the FPRO_REFFRAMES structure from the file data and sets the reference frames as if FPROAlgo_SetHardwareMergeReferenceFrames was called. You need only call this API or FPROAlgo_SetHardwareMergeReferenceFrames, you do not need to call both. This API is provided as a built in convenience when using the FLI Pilot application to generate the reference data files.


At least one of the parameters must point to a valid file name; the other file name may be NULL. Passing a NULL pointer for a file name will generate identity reference data for the frame: Zeros (0) for the DSNU frames and ones (1) for the PRNU frames.

See FPRO_REFFRAMES for further information.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pDSNUFile- Pointer to the DSNU File.
pPRNUFile- Pointer to the PRNU File.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
StreamingAndHWMerge.cpp.

◆ FPROAlgo_SetHardwareMergeReferenceFrames()

LIBFLIPRO_API FPROAlgo_SetHardwareMergeReferenceFrames ( int32_t  iHandle,
FPRO_REFFRAMES pRefFrames 
)

Sets the reference frames used in PCIE Fibre hardware image merging.


Use this function to setup the merging reference frames. If you pass NULL for one of the fields in pRefFrames, an identity reference frame is created for that plane. If you are using identity frames, you must call this function after changing the gain setting on the camera in order to get the proper merge results.
When Identity farames are used, the API extracts the gain setting from the image meta data and uses that to build an appropriate set of reference frames. So if you change the gain, you must reset the idneity frames in order to get the new set of reference frames constructed for the merge process.

The example code also provides guidance for building this structure from your reference files. See the SimpleAPIMerging and StreamingAndHWMerge examples for further information.

See FPRO_REFFRAMES for additional information.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pRefFrames- Pointer to the reference frames to use.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp, SimpleHWMerging.cpp, and StreamingAndHWMerge.cpp.

◆ FPROAlgo_SetHardwareMergeThresholds()

LIBFLIPRO_API FPROAlgo_SetHardwareMergeThresholds ( int32_t  iHandle,
uint16_t  uiHighGainThreshold,
uint16_t  uiMergeDifferenceThreshold 
)

Retrieve the current Hardware Merge Threshold values.

Note this functionality only exists on Host PCIE Fibre connections version 2 or later. If you use hardware merging, you must call this API prior to calling FPROFrame_ComputeFrameSize().

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiHighGainThreshold- The high gain pixel value threshold (when over, the Low gain pixel is used).
uiMergeDifferenceThreshold- When the High gain pixel value if below the High Gain Threshold, the Low pixel is used only if the difference between the is greater than the Merge Difference Threshold ((low - high) > merge_difference).
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAlgo_StackDeinitialize()

LIBFLIPRO_API FPROAlgo_StackDeinitialize ( int32_t  iHandle)

Returns all the resources allocated during the stacking process to the system.

This function must be called when you are done with the stacking process to return all of the resources allocated during the process to the system. This includes the buffers returned by FPROAlgo_StackFinish() so make sure you have saved the buffers if you need to prior to calling this function.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAlgo_StackFinish()

LIBFLIPRO_API FPROAlgo_StackFinish ( int32_t  iHandle,
uint16_t **  ppLowMeanFrame,
uint16_t **  ppHighMeanFrame,
uint32_t *  pNumPixels,
uint8_t **  ppMetaData,
uint32_t *  puiMetaSize 
)

Finish the stacking process and retrieve the mean frames.

This function retrieves finalizes the stack computations and returns the mean frames. Assuming you make no changes to the camera settings, after this call a new stack can be started by simply starting a new a sequence of FPROAlgo_StackNextFrame() calls. Any time you want to change camera settings, or you are done with the stacking process, you must call FPROAlgo_StackDeinitialize() to free the memory allocated during the stacking process.

NOTE: The returned buffer pointers are allocated by the API and must be free by calling the FPROAlgo_StackDeinitialize() function when you are finished with the stacking process. If you run multiple stacking procedures between FPROAlgo_Stacknitialize() and FPROAlgo_StackDeinitialize(), the API reuses these buffers, so make sure to save them if you need to prior to making subsequent FPROAlgo_StackNextFrame() calls.
The Image frames include the mean data only, no meta data.

If you receive a ppMetaData pointer, do not free it. The memory is handled by the API. Treat it as a static buffer.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
ppLowMeanFrame- Buffer pointer for Low Mean Frame.
ppHighMeanFrame- Buffer pointer for High Mean Frame.
pNumPixels- Buffer to return the number of pixels in each frame.
ppMetaData- Buffer pointer for returned meta data (may be NULL). Do not free!
puiMetaSize- Pointer for returned size of meta data (may be NULL).
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAlgo_StackInitialize()

LIBFLIPRO_API FPROAlgo_StackInitialize ( int32_t  iHandle)

Initialize the stacking process.

Merge algorithm related functions including Image Stacking

This function initializes the stacking process. It allocates memory based on the given size and the current imaging parameters on the camera. You must not change any camera parameters after making this call and completing the stacking process. This process, when complete, produces a high and low gain mean image from a stack of images. The result is suitable for merging images both by software or hardware when using the FLI PCIE Fibre connection.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAlgo_StackNextFrame()

LIBFLIPRO_API FPROAlgo_StackNextFrame ( int32_t  iHandle,
uint8_t *  pFrameData,
uint32_t *  pSize,
uint32_t  uiTimeoutMS 
)

Capture and retrieve the next frame to stack from the camera.

This function retrieves and applies the next frame to the stack computations. It is expected that you have already called FPROFrame_CaptureStart() to trigger the frame capture on the camera.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pFrameData- The buffer to store the original frame data that was stacked.
pSize- Size the of the pFrameData buffer. On return, the number of bytes actually received.
uiTimeoutMS- How long to wait for a frame to be available. Assuming you make this call very soon after the FPROFrame_CaptureStart() call, you should set this to the exposure time. Internally, the API blocks (i.e. no communication with the camera) for some time less than uiTimeoutMS and then attempts to retrieve the frame.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAuxIO_GetExposureActiveType()

LIBFLIPRO_API FPROAuxIO_GetExposureActiveType ( int32_t  iHandle,
FPROAUXIO  ePin,
FPROAUXIO_EXPACTIVETYPE pType,
bool *  pActiveHigh 
)

Get Exposure Active Type Signal.

This function gets the Exposure Type Signal for the Exposure Type Auxiliary output pin. Some camera models support choosing the AuxIO pin used for the Wxposure Active signal. In these cases, the ePin parameter is used to obtain the setting. For cameras that have a dedicated Exposure Active pin, this parameter is ignored. Consult your documentation for signal timing details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
ePin- If suppoerted by the camera, the pin used for exposure active signal. If it is not supported by the camera, this parameter is ignored.
pType- Exposure Active Signal Type.
pActiveHigh- The polarity of the Exposure Active Signal. True= active high.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAuxIO_GetPin()

LIBFLIPRO_API FPROAuxIO_GetPin ( int32_t  iHandle,
FPROAUXIO  eAuxIO,
FPROAUXIO_DIR pDirection,
FPROAUXIO_STATE pState 
)

Gets the direction and state for given Auxiliary I/O pin.

For Output pins, the state of the pin will be the value last set with the FPROAuxIO_GetPin() call. For Input pins, the state of the pin reflects the state of the physical input signal.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eAuxIO- Auxiliary I/O pin to retrieve.
pDirection- Pin direction.
pState- Pin state. May be NULL if you do not want the state.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAuxIO_SetExposureActiveType()

LIBFLIPRO_API FPROAuxIO_SetExposureActiveType ( int32_t  iHandle,
FPROAUXIO  ePin,
FPROAUXIO_EXPACTIVETYPE  eType,
bool  bActiveHigh 
)

Exposure Active Type Signal.

This function sets the Exposure Type Signal for the Exposure Type Auxiliary output pin. Some camera models support choosing the AuxIO pin used for the Exposure Active signal. In these cases, the ePin parameter is used to apply the setting. For cameras that have a dedicated Exposure Active pin, this parameter is ignored. Consult your documentation for signal timing details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
ePin- If suppoerted by the camera, the pin used for exposure active signal. If it is not supported by the camera, this parameter is ignored.
eType- Exposure Active Signal Type.
bActiveHigh- The polarity of the Exposure Active Signal. True= active high.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAuxIO_SetPin()

LIBFLIPRO_API FPROAuxIO_SetPin ( int32_t  iHandle,
FPROAUXIO  eAuxIO,
FPROAUXIO_DIR  eDirection,
FPROAUXIO_STATE  eState 
)

Sets the direction and state for given Auxiliary I/O pin.

Note that the state is only applicable to output pins. It is ignored for input pins.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eAuxIO- Auxiliary I/O pin to configure.
eDirection- Pin direction to set.
eState- Pin state to set for output pins.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCam_Close()

LIBFLIPRO_API FPROCam_Close ( int32_t  iHandle)

Disconnects from the camera an releases the handle.

Parameters
iHandle- Connected camera handle to close.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
CapabilitiesAndGainTables.cpp, SimpleAPIMerging.cpp, SimpleHWMerging.cpp, SimpleImageLoop.cpp, SimpleStreamer.cpp, StreamingAndHWMerge.cpp, and WorkingWithModes.cpp.

◆ FPROCam_GetAPIVersion()

LIBFLIPRO_API FPROCam_GetAPIVersion ( wchar_t *  pVersion,
uint32_t  uiLength 
)

Returns the version of this API Library.

This function may be called at any time, it does not need a device handle to report the API version.

Parameters
pVersion- Buffer for returned NULL terminated version string.
uiLength- Length of supplied buffer.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCam_GetCameraList()

LIBFLIPRO_API FPROCam_GetCameraList ( FPRODEVICEINFO pDeviceInfo,
uint32_t *  pNumDevices 
)

FPROCam_GetCameraList.

Returns a list of cameras detected on the host. Most often it is the first function called in the API in order to provide a list of available devices to the user. The information provided in the FPRODEVICEINFO structure allows unique names to be constructed for each camera. A pointer an FPRODEVICEINFO structure corresponding to a user selected device is passed to a subsequent call to FPROCam_Open() in order to connect to the camera.

Parameters
pDeviceInfo- Pointer to user allocated memory to hold the list of devices.
pNumDevices- On entry, the max number of devices that may be assigned to the list. Note that the pDeviceInfo pointer must point to enough memory to hold the given pNumDevices. On exit, it contains the number of devices detected and inserted in the list. This can be less than the requested number. If it returns the requested number, there may be additional devices connected.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
CapabilitiesAndGainTables.cpp, SimpleAPIMerging.cpp, SimpleHWMerging.cpp, SimpleImageLoop.cpp, SimpleStreamer.cpp, StreamingAndHWMerge.cpp, and WorkingWithModes.cpp.

◆ FPROCam_GetDeviceInfo()

LIBFLIPRO_API FPROCam_GetDeviceInfo ( int32_t  iHandle,
FPRODEVICEINFO pDeviceInfo 
)

FPROCam_GetDeviceInfo.

Returns the device information structure FPRODEVICEINFO for the connected camera.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open().
pDeviceInfo- Pointer to user allocated memory to hold the device connection information.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCam_GetDeviceVersion()

LIBFLIPRO_API FPROCam_GetDeviceVersion ( int32_t  iHandle,
FPRODEVICEVERS pVersion 
)

Returns the version information from the connected device.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open().
pVersion- Structure buffer to return version information.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCam_GetHostInterfaceInfo()

LIBFLIPRO_API FPROCam_GetHostInterfaceInfo ( FPROHOSTINFO pHostInfo,
uint32_t *  pNum 
)

Returns information pertaining to the installed host Fibre/PCIE cards.

Parameters
pHostInfo- Pointer to structure for return information.
pNum- On entry, the max number of entries to return. On return, the actual number of entries included. Note, currently only 1 entry is supported.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCam_Open()

LIBFLIPRO_API FPROCam_Open ( FPRODEVICEINFO pDevInfo,
int32_t *  pHandle 
)

Connects to the camera specified by the pDevInfo parameter.

This call must complete successfully in order to use any calls in the API that communicate with the camera. The returned handle is passed to all such subsequent API calls.

Parameters
pDevInfo- Pointer to device description as returned by FPROCam_GetCameraList().
pHandle- On successful completion, it contains the device handle to use in subsequent API calls.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
CapabilitiesAndGainTables.cpp, SimpleAPIMerging.cpp, SimpleHWMerging.cpp, SimpleImageLoop.cpp, SimpleStreamer.cpp, StreamingAndHWMerge.cpp, and WorkingWithModes.cpp.

◆ FPROCtrl_GetBurstModeEnable()

LIBFLIPRO_API FPROCtrl_GetBurstModeEnable ( int32_t  iHandle,
bool *  pEnable 
)

Get Camera Burst Mode enable.

Retrieves the current burst mode setting. See FPROCtrl_SetBurstModeEnable() for a description of this setting.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pEnable- True if burst mode is enabled, false otherwise.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetCameraBufferBypass()

LIBFLIPRO_API FPROCtrl_GetCameraBufferBypass ( int32_t  iHandle,
bool *  pCameraBypassEnable,
bool *  pHostBypassEnable 
)

Returns the current Camera Buffer Bypass state of the camera.

Internally, the camera and Host PCIE Fibre boards contain memory used to buffer image data prior to sending to the host over the connected interface. This is required to compensate for the inherent performance differences of the camera and external interfaces to the host (USB or Fibre). For USB connections, it is required to buffer the data internally on the camera or image data may be lost. For Fibre connections, the physical transfer rate is in theory fast enough to handle the full throughput of the camera. This of course depends on the camera and the actual reliability of your Fibre connection. In order to achieve absolute maximum throughput over a Fibre connection, the internal memory buffering may be turned off or bypassed using this feature. Note, enabling the memory bypass on either or both of the camera and host PCIE boards may result in lost data if your camera is set to deliver data at a higher rate that can be processed by your host computer. This is also highly dependent on the performance capability of your computer. See FPROCtrl_SetCameraBufferBypass() to set this feature.
NOTE: When a USB connection is established to a camera, this feature is turned off automatically. If you subsequently connect over Fibre and assuming you want the buffering turned off, you must set the enable again if it was set the last time you were connected over Fibre.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pCameraBypassEnable- Returned Buffering Bypass enable.
pHostBypassEnable- Returned Buffering Bypass enable.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetCoolerDutyCycle()

LIBFLIPRO_API FPROCtrl_GetCoolerDutyCycle ( int32_t  iHandle,
uint32_t *  pDutyCycle 
)

Reads the current duty cycle of the cooler.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pDutyCycle- Returned Cooler Duty Cycle 0-100%.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetElectricallyBlackPixelEnable()

LIBFLIPRO_API FPROCtrl_GetElectricallyBlackPixelEnable ( int32_t  iHandle,
bool *  pEnable 
)

Returns the current Electrically Black Pixel Enable state from the camera.

Some camera models support the ability to produce electrically black reference pixels rather than imaging reference pixels. The FPROCtrl_GetElectricallyBlackPixelEnable() and FPROCtrl_SetElectricallyBlackPixelEnable() API functions are used to enable and disable this feature. Consult your camera documentation for the availability of this feature.
This function will return failure if the connected camera does not support this feature.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pEnable- Returned Enable state.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetExposure()

LIBFLIPRO_API FPROCtrl_GetExposure ( int32_t  iHandle,
uint64_t *  pExposureTime,
uint64_t *  pFrameDelay,
bool *  pImmediate 
)

Reads the exposure time of the image sensor.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pExposureTime- Returned exposure time in nanoseconds.
pFrameDelay- Returned frame delay (end -to-start) time in nanoseconds. When performing multiple exposures with a single trigger, the frame delay is the time from the end of exposure of a frame to the start of exposure of the next frame.
pImmediate- This parameter affects the way exposure starts when the FPROFrame_CaptureStart() function is called. The camera image sensor is continually exposing its pixels on a row by row basis. When this parameter is set to true, the exposure for the frame begins at whatever image sensor row is currently being exposed. The raw image data returned by the FPROFrame_GetVideoFrame() call begins with this row (most likely not row 0). The row that starts the raw video frame is recorded in the meta data for the image frame.

When this parameter is set to false, the camera waits until row 0 is being exposed before starting the frame exposure. In this case, the image frame data returned by the FPROFrame_GetVideoFrame() call will start at row 0.

NOTE: The Exposure Time and Frame Delay values are translated to camera specific units which are in turn dependent on the current imaging mode of the camera (e.g. LDR vs HDR). The API does its best to perform the necessary conversions automatically when the modes are changed. It is recommended, however, to make sure the desired exposure times are set after imaging modes have changed using this and its counterpart API function FPROCtrl_SetExposure().

Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetExternalTriggerEnable()

LIBFLIPRO_API FPROCtrl_GetExternalTriggerEnable ( int32_t  iHandle,
FPROEXTTRIGINFO pTrigInfo 
)

Returns the external trigger settings of the camera.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pTrigInfo- External Trigger setup information. See FPROEXTTRIGINFO and FPROEXTTRIGTYPE.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetFanEnable()

LIBFLIPRO_API FPROCtrl_GetFanEnable ( int32_t  iHandle,
bool *  pOn 
)

Returns the current Fan status, on or off.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pOn- true: the fan is on, false: the fan is off
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetGPSState()

LIBFLIPRO_API FPROCtrl_GetGPSState ( int32_t  iHandle,
FPROGPSSTATE pState,
uint32_t *  pOptions 
)

Returns the current state of an optionally attached GPS unit.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pState- One of FPROGPSSTATE enumerations. See FPROGPSSTATE for the definitions of the states.
pOptions- The current options set up for tracking. This will be bitwise or'd values from the FPROGPSOPT enumeration.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetHeaterPower()

LIBFLIPRO_API FPROCtrl_GetHeaterPower ( int32_t  iHandle,
uint32_t *  pPwrPercentage 
)

Reads the current heater configuration.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pPwrPercentage- The setting of the heater in percent.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetIlluminationDelay()

LIBFLIPRO_API FPROCtrl_GetIlluminationDelay ( int32_t  iHandle,
uint32_t *  pOnDelay,
uint32_t *  pOffDelay 
)

Gets the delay between setting the Illumination on/off via FPROCtrl_SetIlluminationOn() and when the illumination actually activates. Each increment is TBD msecs.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pOnDelay- Delay for turning the illumination on in TBD msec increments
pOffDelay- Delay for turning the illumination off in TBD msec increments
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetIlluminationOn()

LIBFLIPRO_API FPROCtrl_GetIlluminationOn ( int32_t  iHandle,
bool *  pOn 
)

Returns the setting of External Illumination- on or off.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pOn- true: illumination on, false: illumination off
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetLED()

LIBFLIPRO_API FPROCtrl_GetLED ( int32_t  iHandle,
bool *  pOn 
)

Returns the state of the LED on or off setting.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pOn- true: LED on, false: LED off
See FPROCtrl_SetLED() for a description of the LED functionality.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetLEDDuration()

LIBFLIPRO_API FPROCtrl_GetLEDDuration ( int32_t  iHandle,
uint32_t *  pDurationUsec 
)

Get the LED Duration setting.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
*pDurationUsec- Duration in micro seconds. 0xFFFFFFFF = always on.

Note that each camera model may have different resolution capability on the duration (i.e. something larger than a micro-second). The FPROCtrl_SetLEDDuration() converts the micro-second value passed to the proper resolution for the camera. This call reverses the conversion. As such, the value returned by this call may not match the value exactly as that passed to FPROCtrl_SetLEDDuration(). On most cameras, the physical resolution for this duration is 10usecs.

Also see FPROCtrl_SetLEDDuration() for a description of the LED functionality.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetPCIETemperatures()

LIBFLIPRO_API FPROCtrl_GetPCIETemperatures ( int32_t  iHandle,
double *  pPcieFpga,
double *  pFibreFpga 
)

Returns the temperatures on the Host PCIE Fibre Interface card.

This function is only applicable to the Host PCIE Fibre Interface card. If the iHandle parameter is a valid handle to a connected camera over a Fibre interface, then iHandle is used to obtain the host PCIE card information. If iHandle is a negative number, then the API looks for an installed card and attempts to get the information from the first found card.

NOTE: This function only works on Host PCIE Fibre Interface cards version 2.0 or later.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pPcieFpga- The PCIE side FPGA Temperature in degC.
pFibreFpga- The Fibre side FPGA Temperature in degC.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetSensorTemperature()

LIBFLIPRO_API FPROCtrl_GetSensorTemperature ( int32_t  iHandle,
int32_t *  pTemp 
)

Reads the internal sensor temperature of the camera.

Note that if this function is called during an exposure and 'Read During Exposure' is not enabled, the internal sensor temperature is not explicitly read. The last value successfully read will be returned. See the FPROCtrl_SetSensorTemperatureReadEnable() API for more information.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pTemp- For the returned temperature, deg C.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetSensorTemperatureReadEnable()

LIBFLIPRO_API FPROCtrl_GetSensorTemperatureReadEnable ( int32_t  iHandle,
bool *  pEnable 
)

Returns the 'read sensor temperature during exposure' enabled flag.

See FPROCtrl_SetSensorTemperatureReadEnable() for more details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pEnable- true: 'read sensor temperature during exposure' Enabled false: 'read sensor temperature during exposure' Disabled
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetShutterOpen()

LIBFLIPRO_API FPROCtrl_GetShutterOpen ( int32_t  iHandle,
bool *  pOpen 
)

Gets the current shutter setting.

By default it is up to the user to control the shutter during exposures using the FPROCtrl_SetShutterOpen() API. Using this API, the user can retreive the currrent shutter open state when user control is enabled. See FPROCtrl_SetShutterOpen() and FPROCtrl_SetShutterOverride for additional information.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pOpen- true: Shutter open, false: Shutter closed
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetShutterOverride()

LIBFLIPRO_API FPROCtrl_GetShutterOverride ( int32_t  iHandle,
bool *  pOverride 
)

Gets the current shutter override setting.

By default it is up to the user to control the shutter during exposures using the FPROCtrl_SetShutterOpen() API. Using this API, the user can retreive the currrent shutter override state (user or camera controlled). See FPROCtrl_SetShutterOpen() and FPROCtrl_SetShutterOverride for additional information.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pOverride- true: Allows user control of shutter, false: Camera controls shutter
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetTemperatures()

LIBFLIPRO_API FPROCtrl_GetTemperatures ( int32_t  iHandle,
double *  pOtherTemp,
double *  pBaseTemp,
double *  pCoolerTemp 
)

Reads the various temperatures sensors of the camera.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pOtherTemp- For the returned device temperature, deg C.
pBaseTemp- For the returned Base temperature, deg C.
pCoolerTemp- For the returned Cooler temperature, deg C.

Not all cameras support all the temperatures. Consult you camera documentation for details. In addition, NULL may be passed for any of the temperature pointers. Tempeeratures are retrieved only for pointers that are not NULL. This can save a few milliseconds per temperature if timing is critical in your application.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_GetTemperatureSetPoint()

LIBFLIPRO_API FPROCtrl_GetTemperatureSetPoint ( int32_t  iHandle,
double *  pSetPoint 
)

Returns the Base Temperature Set Point.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pSetPoint- The setpoint value in -75 to 70 degC.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetBurstModeEnable()

LIBFLIPRO_API FPROCtrl_SetBurstModeEnable ( int32_t  iHandle,
bool  bEnable 
)

Set Camera Burst Mode enable.

Internally, the camera contains memory used to buffer image data prior to sending to the host over the connected interface. Burst Mode allows all of the memory to be used to buffer images providing a burst of images to the host. Disabling burst mode restricts the camera to buffer only a single image, not reading out another from the sensor until the image has been fully sent to the host. See FPROCtrl_GetBurstModeEnable() to retrieve the current setting.
The API sets the camera to burst mode when a connection is established. Disabling burst mode is useful for being able to make adjustments between frames such as re-focusing.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bEnable- True to enable burst mode, false to disable.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetCameraBufferBypass()

LIBFLIPRO_API FPROCtrl_SetCameraBufferBypass ( int32_t  iHandle,
bool  bCameraBypassEnable,
bool  bHostBypassEnable 
)

Set Camera Buffer Bypass state of the camera.

Internally, the camera contains memory used to buffer image data prior to sending to the host over the connected interface. See FPROCtrl_GetCameraBufferBypass() for a complete description of this feature.
This feature is only supported on Fibre connections and certain camera models. If you attempt to call this function on an unsupported connection, the call returns a failure.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bCameraBypassEnable- Buffering Bypass enable. Set to true to bypass internal buffering on the camera.
bHostBypassEnable- Buffering Bypass enable. Set to true to bypass internal buffering on the host PCIE card.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetElectricallyBlackPixelEnable()

LIBFLIPRO_API FPROCtrl_SetElectricallyBlackPixelEnable ( int32_t  iHandle,
bool  bEnable 
)

Returns the current Electrically Black Pixel Enable state from the camera.

See FPROCtrl_GetElectricallyBlackPixelEnable() for a description of this feature.
This function will return failure if the connected camera does not support this feature.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bEnable- Enable state to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetExposure()

LIBFLIPRO_API FPROCtrl_SetExposure ( int32_t  iHandle,
uint64_t  uiExposureTime,
uint64_t  uiFrameDelay,
bool  bImmediate 
)

Sets the exposure time of the image sensor.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiExposureTime- Exposure time in nanosecond increments.
uiFrameDelay- Frame delay (end - to - start) time in nanoseconds. When performing multiple exposures with a single trigger, the frame delay is the time from the end of exposure of a frame to the start of exposure of the next frame.
bImmediate- This parameter affects the way exposure starts when the FPROFrame_CaptureStart() function is called. The camera image sensor is continually exposing its pixels on a row by row basis. When this parameter is set to true, the exposure for the frame begins at whatever image sensor row is currently being exposed. The raw image data returned by the FPROFrame_GetVideoFrame() call begins with this row (most likely not row 0). The row that starts the raw video frame is recorded in the meta data for the image frame.

When this parameter is set to false, the camera waits until row 0 is being exposed before starting the frame exposure. In this case, the image frame data returned by the FPROFrame_GetVideoFrame() call will start at row 0.


NOTE: The Exposure Time and Frame Delay values are translated to camera specific units which are in turn dependent on the current imaging mode of the camera (e.g. LDR vs HDR), as well as the camera model. The API does its best to perform the necessary conversions automatically when the modes are changed. It is recommended, however, to make sure the desired exposure times are set after imaging modes have changed using this and its counterpart API function FPROCtrl_GetExposure(). You may also use FPROCtrl_SetExposureEx() to request exposure times and recieve the actuals in a single call.

Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp, SimpleHWMerging.cpp, SimpleImageLoop.cpp, SimpleStreamer.cpp, and StreamingAndHWMerge.cpp.

◆ FPROCtrl_SetExposureEx()

LIBFLIPRO_API FPROCtrl_SetExposureEx ( int32_t  iHandle,
uint64_t  uiExposureTime,
uint64_t  uiFrameDelay,
bool  bImmediate,
uint64_t *  pActualExposureTime,
uint64_t *  pActualFrameDelay 
)

Sets the exposure time of the image sensor.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiExposureTime- Exposure time in nanosecond increments.
uiFrameDelay- Frame delay (end - to - start) time in nanoseconds. When performing multiple exposures with a single trigger, the frame delay is the time from the end of exposure of a frame to the start of exposure of the next frame.
bImmediate- This parameter affects the way exposure starts when the FPROFrame_CaptureStart() function is called. The camera image sensor is continually exposing its pixels on a row by row basis. When this parameter is set to true, the exposure for the frame begins at whatever image sensor row is currently being exposed. The raw image data returned by the FPROFrame_GetVideoFrame() call begins with this row (most likely not row 0). The row that starts the raw video frame is recorded in the meta data for the image frame. When this parameter is set to false, the camera waits until row 0 is being exposed before starting the frame exposure. In this case, the image frame data returned by the FPROFrame_GetVideoFrame() call will start at row 0.
pActualExposureTime- If not NULL, the actual Exposure Time will be returned.
This is the same value that would be returned by FPROCtrl_GetExposure(). See NOTE below.
pActualFrameDelay- If not NULL, the actual Frame Delay will be returned. This is the same value that would be returned by FPROCtrl_GetExposure(). See NOTE below.


NOTE: The Exposure Time and Frame Delay values are translated to camera specific units which are in turn dependent on the current imaging mode of the camera (e.g. LDR vs HDR), as well as the camera model. The API does its best to perform the necessary conversions automatically when the modes are changed. It is recommended, however, to make sure the desired exposure times are set by checking the pActualExposurTime and pActualFrameDelay upon return of this function. You can also use FPROCtrl_GetExposure() to get the actual times.

Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetExternalTriggerEnable()

LIBFLIPRO_API FPROCtrl_SetExternalTriggerEnable ( int32_t  iHandle,
uint32_t  uiFrameCount,
FPROEXTTRIGINFO pTrigInfo 
)

Enables or disables the external trigger of the camera.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiFrameCount- The number of images to get (dependent on pTrigInfo setup).
pTrigInfo- External Trigger setup information. See FPROEXTTRIGINFO and FPROEXTTRIGTYPE.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetFanEnable()

LIBFLIPRO_API FPROCtrl_SetFanEnable ( int32_t  iHandle,
bool  bOn 
)

Turns the Fan on or off.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bOn- true: turns the fan on, false: turns the fan off
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetGPSOptions()

LIBFLIPRO_API FPROCtrl_SetGPSOptions ( int32_t  iHandle,
uint32_t  uiOptions 
)

Set the tracking options of an optionally attached GPS unit.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiOptions- The options to set up for tracking. This is bitwise or'd values from the FPROGPSOPT enumeration.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetHeaterPower()

LIBFLIPRO_API FPROCtrl_SetHeaterPower ( int32_t  iHandle,
uint32_t  uiPwrPercentage 
)

Turns the Heater on or off at the specified power level.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiPwrPercentage-Specifies the power level as a percentage (0-100)
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetIlluminationDelay()

LIBFLIPRO_API FPROCtrl_SetIlluminationDelay ( int32_t  iHandle,
uint16_t  uiOnDelay,
uint16_t  uiOffDelay 
)

Sets the illumination delay.

The illumination delay is the time between setting the Illumination on/off via FPROCtrl_SetIlluminationOn and when the illumination actually activates.
Each increment is TBD msecs.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiOnDelay- Delay for turning the illumination on in TBD msec increments
uiOffDelay- Delay for turning the illumination off in TBD msec increments
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetIlluminationOn()

LIBFLIPRO_API FPROCtrl_SetIlluminationOn ( int32_t  iHandle,
bool  bOn 
)

Turns External Illumination on or off.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bOn- true: turns illumination on, false: turns illumination off
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetLED()

LIBFLIPRO_API FPROCtrl_SetLED ( int32_t  iHandle,
bool  bOn 
)

Turn the LED on or off.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bOn- true: Turns the LED on, false: Turns the LED off

Based on the camera model, this function may work in conjunction with the FPROCtrl_SetLEDDuration() API. In those cases, this call must be made with a value of TRUE in order for the FPROCtrl_SetLEDDuration() to toggle the LED.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetLEDDuration()

LIBFLIPRO_API FPROCtrl_SetLEDDuration ( int32_t  iHandle,
uint32_t  uiDurationUSec 
)

Set LED Duration during exposure.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiDurationUSec- Duration in micro seconds. 0xFFFFFFFF = always on.

This call sets the duration of the LED flash during exposure. This call is not available on all camera models. It was introduced on the 4040 models. This call works in conjunction with the FPROCtrl_SetLED() API. In order for the camera to turn the LED on for the given duration, FPROCtrl_SetLED() must have been called with a value of TRUE.


To simply turn the LED on and leave it on, pass a value of 0xFFFFFFFF in the uiDurationUSec parameter. As with other duration values, FPROCtrl_SetLED() must be called with a value of TRUE.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetSensorTemperatureReadEnable()

LIBFLIPRO_API FPROCtrl_SetSensorTemperatureReadEnable ( int32_t  iHandle,
bool  bEnable 
)

Enables/disables physical reading of the image sensor temperature during exposures.

The sensor temperature is read using the FPROCtrl_GetSensorTemperature API call. If that call is made during an exposure, it will physically read the sensor temperature only if this call was made prior to enable the reading. If this 'read sensor temperature during exposure' is not enabled, then the FPROCtrl_GetSensorTemperature call will return the previous successful temperature read from the imaging sensor.
NOTE: This enable only pertains to requests during an exposure. If temperature readings are requested outside of an exposure boundary, this enable has no effect.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bEnable- true: Enable 'read sensor temperature during exposure'. false: Disable 'read sensor temperature during exposure'.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetShutterOpen()

LIBFLIPRO_API FPROCtrl_SetShutterOpen ( int32_t  iHandle,
bool  bOpen 
)

Opens/Close the shutter.

By default it is up to the user to control the shutter during exposures using this FPROCtrl_SetShutterOpen() API. This call works in conjunction with the shutter override setting. In order for this call to successfully control the shutter, the override setting must be set for user control (true). See FPROCtrl_SetShutterOverride.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bOpen- true: opens the shutter, false: closes the shutter
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROCtrl_SetShutterOverride()

LIBFLIPRO_API FPROCtrl_SetShutterOverride ( int32_t  iHandle,
bool  bOverride 
)

Sets the shutter control override.

By default it is up to the user to control the shutter during exposures using the FPROCtrl_SetShutterOpen() API. Using this API, the user can override that setting and allow the camera to control the shutter for exposures.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bOverride- true: Allows user control of shutter, false: Camera controls shutter
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleImageLoop.cpp.

◆ FPROCtrl_SetTemperatureSetPoint()

LIBFLIPRO_API FPROCtrl_SetTemperatureSetPoint ( int32_t  iHandle,
double  dblSetPoint 
)

Sets the Base Temperature Set Point.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
dblSetPoint- The setpoint value to set in -75 to 70 degC.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPRODebug_EnableLevel()

LIBFLIPRO_API FPRODebug_EnableLevel ( bool  bEnable,
FPRODBGLEVEL  eLevel 
)

Enables the given debug level and above.

Parameters
bEnable- Overall enable for debug output
eLevel- The level to enable if bEnable is true;
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleImageLoop.cpp.

◆ FPRODebug_SetLogPath()

LIBFLIPRO_API FPRODebug_SetLogPath ( const wchar_t *  pPath)

Sets the log file path to the given folder. The file name is auto generated.

Parameters
pPath- Path (folder) in which to place the log file.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPRODebug_Write()

LIBFLIPRO_VOID FPRODebug_Write ( FPRODBGLEVEL  eLevel,
const wchar_t *  format,
  ... 
)

FPRODebug_Write Writes the given information to the log file if the given level is enabled.
The parameters support the basic printf type of formatting.

Parameters
eLevel- Debug level of the log message.
format- printf style formatting string
...- printf arguments for the format string
Returns
None.

◆ FPROFAck_FlushImageQueue()

LIBFLIPRO_API FPROFAck_FlushImageQueue ( int32_t  iHandle)

Flush the in memory frame queue in Frame Acknowledgment Mode.

This function instructs the camera to flush all of the image frames contained in its internal image frame queue. See FPROFAck_GetEnable() for a description of this mode.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFAck_FrameAcknowledge()

LIBFLIPRO_API FPROFAck_FrameAcknowledge ( int32_t  iHandle)

Acknowledge the last frame sent in Frame Acknowledgment Mode.

This function acknowledges the last from sent to the host. See FPROFAck_GetEnable() for a description of this mode.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFAck_FrameResend()

LIBFLIPRO_API FPROFAck_FrameResend ( int32_t  iHandle)

Re-send the last frame in Frame Acknowledgment Mode.

This function instructs the camera to re-send the last image frame to the host. Is expected to be called by an application in the event of transmission errors or errors detected during parsing of the image data. See FPROFAck_GetEnable() for a description of this mode.
The frame data will be available immediately after this call so it is important to call FPROFrame_GetVideoFrame() with the proper parameters immediately after this call returns.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFAck_GetEnable()

LIBFLIPRO_API FPROFAck_GetEnable ( int32_t  iHandle,
bool *  pEnable 
)

Get Frame Acknowledgment Mode Enable.

This function gets the Frame Acknowledgment Mode Enable. If true, Frame Acknowledgment Mode is enabled.

Frame Acknowledgment Mode is a camera mode that instructs the camera to store each frame as it is exposed in an internal memory. The frame in the memory may be retransmitted to the host using the FPROFAck_FrameResend() API. Each frame -must- be explicitly acknowledged by the user using the FPROFAck_FrameAcknowledge() API. This allows the camera to delete the frame from its memory queue making it available for the next frame.
This mode is intended for users who require every image to be successfully transmitted to the host even in the face of cable and unrecoverable transmission errors. Because of the required acknowledgments, this mode is significantly slower with respect to achievable frame rate and dependent on the host computer.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pEnable- The Frame Acknowledgment Mode enable- true if enabled, false otherwise.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFAck_SetEnable()

LIBFLIPRO_API FPROFAck_SetEnable ( int32_t  iHandle,
bool  bEnable 
)

Set Frame Acknowledgment Mode Enable.

This function sets the Frame Acknowledgment Mode Enable. If true, Frame Acknowledgment Mode is enabled. See FPROFAck_GetEnable() for a description of this mode.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bEnable- The Frame Acknowledgment Mode enable- True if enabled, False otherwise.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_CaptureAbort()

LIBFLIPRO_API FPROFrame_CaptureAbort ( int32_t  iHandle)

Aborts the active image capture.

The abort function is meant to be called to abort the current image capture. It can be called from a different thread that is performing the image capture as long as the recommended calling pattern for image capture is followed. See FPROFrame_CaptureStart() for a description of the recommended image capture calling pattern.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp, and SimpleHWMerging.cpp.

◆ FPROFrame_CaptureStart()

LIBFLIPRO_API FPROFrame_CaptureStart ( int32_t  iHandle,
uint32_t  uiFrameCount 
)

Initiates the capture of the configured image.

The image is retrieved using the FPROFrame_GetVideoFrame() API.

NOTE: In order to ensure data pipe integrity, FPROFrame_CaptureStart(), FPROFrame_GetVideoFrame(), and FPROFrame_CaptureStop() must be called from the same thread in a pattern similar to below:

while (frames_to_get)
LIBFLIPRO_API FPROFrame_CaptureStop(int32_t iHandle)
Stops the active image capture.
LIBFLIPRO_API FPROFrame_GetVideoFrame(int32_t iHandle, uint8_t *pFrameData, uint32_t *pSize, uint32_t uiTimeoutMS)
Retrieves an image frame from the camera.
LIBFLIPRO_API FPROFrame_CaptureStart(int32_t iHandle, uint32_t uiFrameCount)
Initiates the capture of the configured image.
Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiFrameCount- Number of frames to capture. 0 == infinite stream.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp, SimpleHWMerging.cpp, and SimpleImageLoop.cpp.

◆ FPROFrame_CaptureStop()

LIBFLIPRO_API FPROFrame_CaptureStop ( int32_t  iHandle)

Stops the active image capture.

NOTE: In order to ensure data pipe integrity, FPROFrame_CaptureStart(), FPROFrame_GetVideoFrame(), and FPROFrame_CaptureStop() must be called from the same thread in a pattern similar to below:

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleImageLoop.cpp.

◆ FPROFrame_CaptureThumbnail()

LIBFLIPRO_API FPROFrame_CaptureThumbnail ( int32_t  iHandle)

Initiates the capture of a thumbnail image.

The image is transferred over the image endpoint and is retrieved using the FPROFrame_GetThumbnail() API. Thumbnail images are 512x512 pixels. No Metadata or dummy pixels are included in the image.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_ComputeFrameSize()

LIBFLIPRO_API FPROFrame_ComputeFrameSize ( int32_t  iHandle)

Computes the size in bytes of the image frame.

This function uses the actual camera settings to determine the size of the image data that will be received in bytes. As such, all camera settings must be set up for your image prior to calling this function. Since communications with the camera is required to complete this function successfully, it can fail on the communication. In addition, this function can take tens of milli-seconds to complete because of this communication so it should not be called in time critical situations.

IMPORTANT: On Fibre connections, when using the Hardware Merging capabilities of the PCIE card, this function MUST be called after you have set up the camera and enabled the Hardware Merging function. See FPROAlgo_SetHardwareMergeEnables(). If you do not call this function, the hardware merging function may be incorrectly initialized for the current setup and image corruption may result.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
The size of the expected image frame in bytes on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp, SimpleHWMerging.cpp, SimpleImageLoop.cpp, SimpleStreamer.cpp, and StreamingAndHWMerge.cpp.

◆ FPROFrame_ComputeFrameSizePixels()

LIBFLIPRO_API FPROFrame_ComputeFrameSizePixels ( int32_t  iHandle,
uint32_t *  pTotalWidth,
uint32_t *  pTotalHeight 
)

Computes the size in pixels of the image frame.

This function uses the actual camera settings to determine the size of the image data that will be received in pixels. As such, all camera settings must be set up for your image prior to calling this function. Since communications with the camera is required to complete this function successfully, it can fail on the communication. In addition, this function can take tens of milli-seconds to complete because of this communication so it should not be called in time critical situations.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pTotalWidth- If provided, the total width of the image (including reference pixels) is returned.
pTotalHeight- If provided, the total height of the image (including reference rows) is returned.
Returns
The size of the expected image frame in bytes on success, less than 0 on failure.

◆ FPROFrame_ConvertFile()

LIBFLIPRO_API FPROFrame_ConvertFile ( wchar_t *  pInRcdFile,
FPRO_CONV pConvInfo,
wchar_t *  pOutFile 
)

Convert (and possibly) merge the given RCD file.

Convert the given RCD file to the file type specified.
See FPROAlgo_SetHardwareMergeReferenceFiles and FPRO_CONV for more information.

Only RCD files may be supplied as the input file to convert. If a single plane file is provided, that plane is unpacked and converted to the output format. If a two plane RCD is provided (both Low Gain and High Gain frames), the frames are unpacked, merged, and all 3 frames are converted to the specified output format.

Parameters
pInRcdFile- The file to convert.
pConvInfo- Conversion specifications.
pOutFile- Ouput (converted) file name.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_FreeUnpackedBuffers()

LIBFLIPRO_VOID FPROFrame_FreeUnpackedBuffers ( FPROUNPACKEDIMAGES pUPBuffers)

Frees the Unpacked Buffers within the given structure.

See FPROFrame_GetVideoFrameUnpacked() for additional information.

Parameters
pUPBuffers- The buffers to free.
Returns
None.
Examples
SimpleAPIMerging.cpp.

◆ FPROFrame_FreeUnpackedStatistics()

LIBFLIPRO_VOID FPROFrame_FreeUnpackedStatistics ( FPROUNPACKEDSTATS pStats)

Frees the Unpacked Statistics Buffers within the given structure.

See FPROFrame_GetVideoFrameUnpacked() for additional information.

Parameters
pStats- The statistics buffers to free.
Returns
None.
Examples
SimpleAPIMerging.cpp.

◆ FPROFrame_GetDummyPixelEnable()

LIBFLIPRO_API FPROFrame_GetDummyPixelEnable ( int32_t  iHandle,
bool *  pEnable 
)

Retrieves the dummy pixel configuration to be appended row data.

If enabled, dummy pixels are appended to every other row of image data starting with the second row of data.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pEnable- true: Dummy pixels will be appended to every other image row false: Dummy pixels will NOT be appended to every other image row
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetFrameReferenceRows()

LIBFLIPRO_API FPROFrame_GetFrameReferenceRows ( int32_t  iHandle,
uint32_t *  pPreRows,
uint32_t *  pPostRows 
)

Retrieves the reference row count to be appended to frame data.

If the count is > 0, this number of reference rows are appended to the frame data. See FPROCAPS capabilities structure for details about reference rows.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pPreRows- Pointer to the number of pre-frame reference rows appended to the image frame data.
pPostRows- Pointer to the number of post-frame reference rows appended to the image frame data.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetFrameType()

LIBFLIPRO_API FPROFrame_GetFrameType ( int32_t  iHandle,
FPRO_FRAME_TYPE pType 
)

Retrieves the Frame Type setting.

Returns the frame type set by the FPROFrame_SetFrameType() API. The default frame type is FPRO_FRAMETYPE_NORMAL. Typically this is only used for testing purposes. Consult your documentation for a description and availability of the different frame types found on a given camera model. See also FPRO_FRAME_TYPE.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pType- The current frame type setting.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetImageArea()

LIBFLIPRO_API FPROFrame_GetImageArea ( int32_t  iHandle,
uint32_t *  pColOffset,
uint32_t *  pRowOffset,
uint32_t *  pWidth,
uint32_t *  pHeight 
)

Gets the area of the image sensor being used to produce image frame data.

Image frames are retrieved using the FPROFrame_GetVideoFrame() API.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pColOffset- Start column (pixel) of the image frame
pRowOffset- Start row (pixel) of the image frame
pWidth- Width of the image frame in pixels.
pHeight- Height of the image frame in pixels.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetImageDataEnable()

LIBFLIPRO_API FPROFrame_GetImageDataEnable ( int32_t  iHandle,
bool *  pEnable 
)

Enables image data imaging.

Image data may be disabled allowing only reference rows to be produced for image frames. Reference rows are configured with the FPROFrame_SetFrameReferenceRows() API call.


NOTE: Not all camera models support this feature. Consult your camera documentation.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pEnable- true: Image data pixels enabled, false: Image data pixels disabled.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetPixelFormat()

LIBFLIPRO_API FPROFrame_GetPixelFormat ( int32_t  iHandle,
FPRO_PIXEL_FORMAT pFormat,
uint32_t *  pPixelLSB 
)

Retrieves the current pixel format configuration.

See FPROFrame_GetSupportedPixelFormats() for additional information.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pFormat- The current pixel format.
pPixelLSB- The current Pixel LSB offset.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetSupportedPixelFormats()

LIBFLIPRO_API FPROFrame_GetSupportedPixelFormats ( int32_t  iHandle,
FPRO_PIXEL_FORMAT pFormats,
uint32_t *  pNumFormats 
)

Retrieves the supported pixel formats.

Ths function returns the list of supported pixel formats. If NULL is passed for the pFormats parameter and non NULL for the pNumFormats parameter, the pNumFormats parameter is updated with the number of formats that would be returned allowing the application to allocate a properly sized buffer and call this function again to obtain the actual list. The items in the list may then be used as a paramter to FPROFrame_SetPixelFormat(). Also see the FPROFrame_GetPixelFormat() API call to retrieve the current pixel format.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pFormats- The returned list of supported formats.
pNumFormats- On entry, the size of the pFormats list. On return, the actual number of entries returned.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetTestImageEnable()

LIBFLIPRO_API FPROFrame_GetTestImageEnable ( int32_t  iHandle,
bool *  pEnable,
FPROTESTIMAGETYPE pFormat 
)

Retrieves the test image data settings.

When enabled, the camera generates a test pattern rather than capturing image data from the image sensor. See FPROFrame_SetTestImageEnable().
NOTE: Not all camera models support a test image. Consult your camera documentation.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pEnable- true: Enable test image data false: Disables test image data- normal image data produced
pFormat- Format of the test image data to produce.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetThumbnailFrame()

LIBFLIPRO_API FPROFrame_GetThumbnailFrame ( int32_t  iHandle,
uint8_t *  pFrameData,
uint32_t *  pSize 
)

Retrieves the thumbnail image from the camera.

The image is transferred over the image endpoint and is retrieved using the FPROFrame_GetThumbnail() API. Thumbnail images are 512x512 12 bit pixels in size. That is, no Metadata, reference rows, or dummy pixels are included in the image.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pFrameData- The buffer to store the frame data
pSize- Size the of the pFrameData buffer. On return, the number of bytes actually received.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetVideoFrame()

LIBFLIPRO_API FPROFrame_GetVideoFrame ( int32_t  iHandle,
uint8_t *  pFrameData,
uint32_t *  pSize,
uint32_t  uiTimeoutMS 
)

Retrieves an image frame from the camera.

It is important to call this function with the appropriate size buffer for the frame. That is, the buffer size should be match the expected frame size. If it is too large, the function will try and read the given size and may stall the USB connection if no more frame data is available.

NOTE: In order to ensure data pipe integrity, FPROFrame_CaptureStart(), FPROFrame_GetVideoFrame(), and FPROFrame_CaptureStop() must be called from the same thread in a pattern similar to below:



NOTE: This function is only for use when triggering image capture using FPROFrame_CaptureStart() as described above. If you are using external triggers, use the the FPROFrame_GetVideoFrameExt() or FPROFrame_GetVideoFrameUnpackedExt() API calls.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pFrameData- The buffer to store the frame data.
pSize- Size the of the pFrameData buffer. On return, the number of bytes actually received.
uiTimeoutMS- How long to wait for a frame to be available. Assuming you make this call very soon after the FPROFrame_CaptureStart() call, you should set this to the exposure time. Internally, the API blocks (i.e. no communication with the camera) for some time less than uiTimeoutMS and then attempts to retrieve the frame.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleHWMerging.cpp, and SimpleImageLoop.cpp.

◆ FPROFrame_GetVideoFrameExt()

LIBFLIPRO_API FPROFrame_GetVideoFrameExt ( int32_t  iHandle,
uint8_t *  pFrameData,
uint32_t *  pSize 
)

Retrieves an externally triggered image frame from the camera.

This function is intended for use when using external trigger sources for image capture. Unlike FPROFrame_GetVideoFrame(), no timeout is specified. It waits forever until notification of image frame data availability from the camera. FPROFrame_CaptureAbort() can be used to cancel the exposure as described in those API calls.

FPROFrame_CaptureStart() is not expected to be called prior to this API because the External Trigger will be supplying the trigger source. However, if this call is awaiting image data, another thread may call FPROFrame_CaptureStart() to force a trigger. Once exposed, this function will return the data as if an external trigger occurred. If you do call FPROFrame_CaptureStart() to force a trigger, it is important to call FPROFrame_CaptureAbort() after the image is retrieved.

It is important to call this function with the appropriate size buffer for the frame. That is, the buffer size should be match the expected frame size. If it is too large, the function will try and read the given size and may stall the USB connection if no more frame data is available.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pFrameData- The buffer to store the frame data.
pSize- Size the of the pFrameData buffer. On return, the number of bytes actually received.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_GetVideoFrameUnpacked()

LIBFLIPRO_API FPROFrame_GetVideoFrameUnpacked ( int32_t  iHandle,
uint8_t *  pFrameData,
uint32_t *  pSize,
uint32_t  uiTimeoutMS,
FPROUNPACKEDIMAGES pUPBuffers,
FPROUNPACKEDSTATS pStats 
)

Retrieves an image frame from the camera and optionally unpacks and merges the image planes.

This function behaves identically as the FPROFrame_GetVideoFrame() call with respect to starting, stopping, and timeouts. See FPROFrame_GetVideoFrame() for details.
In addition, if you specify unpacking buffers, the function will also unpack the raw image data received and return the planes requested (Low Gain, High Gain, Merged). The planes to unpack are specified in the pUPBuffers parameter. If this parameter is NULL, the function behaves identically to that of FPROFrame_GetVideoFrame() call.


To allocate the buffers, the first time you call this function for a given frame setup, you must set the buffer pointers within the structure to NULL and set the corresponding 'request flag' in the structure to 'true'. For example, to receive a merged frame, set pUPBUffers->pMergedImage to NULL and set pUPBuffers->bMergedImageRequest to 'true'. The API will allocate the requested buffers and return the requested planes. If your frame setup does not change, you may reuse the buffers that have been allocated for subsequent exposures. If the buffers provided are of incorrect size, the API does it's best to re-allocate them. If it can not, the function will return an error. In this case the raw frame may still have been received correctly. Check the *pSize value to obtain the number of bytes in the raw frame that were successfully received. When you are done with the buffers, you must call FPROFrame_FreeUnpackedBuffers() to free the memory.

Similarly, when you call this function the first time and request statistics for the frames, the API allocates the needed memory within the statistics structure. Make sure you initialize the structure with 0's in order for this to work properly! The structure can then be reused in subsequent calls. When you are done with the statistics, you must call FPROFrame_FreeUnpackedStatistics() to free the memory.

The meta data returned in the pUPBuffers structure is not the raw meta data received from the camera. It has been modified to reflect the processing of the raw frame. The raw meta data for the image is at the start of the pFrameData buffer just as it is with FPROFrame_GetVideoFrame(). If you want to process the raw frame, or determine the original image characteristics, you must use the meta data in the pFrameData buffer.

Note that the eMergeFormat member of the FPROUNPACKEDIMAGES structure is the requested output format. If this format can not be produced, a TIFF format is produced and this field is modified to indicate that output/merged image is in TIFF format.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pFrameData- The buffer to store the frame data.
pSize- Size the of the pFrameData buffer. On return, the number of bytes actually received.
uiTimeoutMS- How long to wait for a frame to be available. Assuming you make this call very soon after the FPROFrame_CaptureStart() call, you should set this to the exposure time. Internally, the API blocks (i.e. no communication with the camera) for some time less than uiTimeoutMS and then attempts to retrieve the frame.
pUPBuffers- If specified, the call will return the unpacked buffers requested.
pStats- If specified, the call will return the statistics requested.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp.

◆ FPROFrame_GetVideoFrameUnpackedExt()

LIBFLIPRO_API FPROFrame_GetVideoFrameUnpackedExt ( int32_t  iHandle,
uint8_t *  pFrameData,
uint32_t *  pSize,
FPROUNPACKEDIMAGES pUPBuffers,
FPROUNPACKEDSTATS pStats 
)

Retrieves an externally triggered image frame from the camera and unpacks the image.

This function is intended for use when using external trigger sources for image capture. See FPROFrame_GetVideoFrameExt() for a complete description of the use of this API. See FPROFrame_GetVideoFrameUnpacked() for a complete description of the use of unpacking buffers for this API.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pFrameData- The buffer to store the frame data.
pSize- Size the of the pFrameData buffer. On return, the number of bytes actually received.
pUPBuffers- If specified, the call will return the unpacked buffers requested.
pStats- If specified, the call will return the statistics requested.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_MetaDataToString()

LIBFLIPRO_API FPROFrame_MetaDataToString ( wchar_t *  pFileName,
wchar_t *  pMetaString,
uint32_t  uiMaxChars 
)

Convert the meta data in the given file to string.

This function simply parses the meta data in the given file and returns a NULL terminated string representation. Like FPROFrame_UnpackFile, this function does not require an active camera connection to succeed. This function is intended primarily for trouble shooting purposes. Sufficient space must be provided in the pMetaString buffer to contain all of the data. 4K bytes is typically enough. Only RCD files may be supplied as the input file to parse.

Parameters
pFileName- The file to parse.
pMetaString- The string buffer.
uiMaxChars- The size of the string buffer pMetaString in characters.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_MetaDataToStringBin()

LIBFLIPRO_API FPROFrame_MetaDataToStringBin ( uint8_t *  pImageData,
uint32_t  uiImageSizeBytes,
wchar_t *  pMetaString,
uint32_t  uiMaxChars 
)

Convert the meta data in the given file to string.

Similar to FPROFrame_MetaDataToString() except this function operates on the binary image data provided. This function simply parses the meta data in the given binary image data and returns a NULL terminated string representation. Sufficient space must be provided in the pMetaString buffer to contain all of the data.
4K bytes is typically enough. Only RCD files may be supplied as the input file to parse.

Parameters
pImageData- The image data to parse.
uiImageSizeBytes- The size of the image data in bytes.
pMetaString- The string buffer.
uiMaxChars- The size of the string buffer pMetaString in characters.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_MetaValueGet()

LIBFLIPRO_API FPROFrame_MetaValueGet ( FPRO_META_KEYS  eMetaKey,
FPROMETAVALUE pMetaValue 
)

Retrieve the value for the given meta key.

This function returns the value of the given meta data key. The value is either a number represented by a double, or a character string. If the value is a character string, the iByteLength of the pMetaValue will be gretaer than or equal (>=) to zero. If the value is represented by a number, the iByteLength field will be less than (<) zero.

Parameters
eMetaKey- The meta data key to retrieve.
pMetaValue- Structure pointer for the value.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_MetaValueGetNext()

LIBFLIPRO_API FPROFrame_MetaValueGetNext ( FPROMETAVALUE pMetaValue)

Retrieve the next meta key value.

This function returns the value of the next meta key defined by the FPRO_META_KEYS enumeration. The next key is set to the start of the enumeration after one of the init functions FPROFrame_MetaValueInit() or FPROFrame_MetaValueInitBin() are called. If FPROFrame_MetaValueGet() is called, then FPROFrame_MetaValueGetNext() will return the value for he key following the one passed to FPROFrame_MetaValueGet(). The value is either a number represented by a double, or a character string. If the value is a character string, the iByteLength of the pMetaValue will be gretaer than or equal (>=) to zero. If the value is represented by a number, the iByteLength field will be less than (<) zero.

Parameters
pMetaValue- Structure pointer for the value.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_MetaValueInit()

LIBFLIPRO_API FPROFrame_MetaValueInit ( wchar_t *  pFileName)

Parses the meta data from the given file for access by the FPROFrame_MetaValueGet() and FPROFrame_MetaValueGetNext() API calls.

This function along with FPROFrame_MetaValueGet() and FPROFrame_MetaValueGetNext() provide a key-value access method for the meta data fields defined by the FPRO_META_KEYS enumeration. This function, or its companion FPROFrame_MetaValueInitBin() must be called prior to calling one of the Get functions.

Parameters
pFileName- The image file to parse.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_MetaValueInitBin()

LIBFLIPRO_API FPROFrame_MetaValueInitBin ( uint8_t *  pMetaData,
uint32_t  uiLength 
)

Parses the meta data from the given image data for access by the FPROFrame_MetaValueGet() and FPROFrame_MetaValueGetNext() API calls.

This function along with FPROFrame_MetaValueGet() and FPROFrame_MetaValueGetNext() provide a key-value access method for the meta data fields defined by the FPRO_META_KEYS enumeration. This function, or its companion FPROFrame_MetaValueInit() must be called prior to calling one of the Get functions.

Parameters
pMetaData- The image data to parse.
uiLength- Length of the data buffer in bytes.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_SetDummyPixelEnable()

LIBFLIPRO_API FPROFrame_SetDummyPixelEnable ( int32_t  iHandle,
bool  bEnable 
)

Returns whether or not Image Frame data is ready for retrieval.

This API is primarily used in conjunction with an external trigger setup. Since the external trigger is not natively synchronized with the software in any way, a method to determine when the image data is available for retrieval is required. Users can use this routine to query the camera and wait for image data to be available. When the function succeeds and *pAvailable is 'true', the user can call the normal FPROFrame_GetVideoFrame() API to retrieve the data.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pAvailable- Pointer for returned query. true: Image Frame data is available for retrieval false: Image Frame Data is not available.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

Sets the dummy pixel configuration to be appended row data.

For the FPRO_CAM_DEVICE_TYPE_GSENSE400 and FPRO_CAM_DEVICE_TYPE_GSENSE4040 model cameras, if enabled, dummy pixels are appended to every other row of image data starting with the second row of data. Consult your Camera Model user documentation as not all models support dummy pixels in the same way.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bEnable- true: Dummy pixels will be appended to every other image row false: Dummy pixels will NOT be appended to every other image row
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_SetFrameReferenceRows()

LIBFLIPRO_API FPROFrame_SetFrameReferenceRows ( int32_t  iHandle,
uint32_t  uiPreRows,
uint32_t  uiPostRows 
)

Sets the reference row count to be added to frame data.

If the count is > 0, this number of reference rows are added to the frame data. See FPROCAPS capabilities structure for details about reference rows.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiPreRows- The number of pre-frame reference rows added to the image frame data.
uiPostRows- The number of post-frame reference rows added to the image frame data.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_SetFrameType()

LIBFLIPRO_API FPROFrame_SetFrameType ( int32_t  iHandle,
FPRO_FRAME_TYPE  eType 
)

Sets Frame Type produced by the camera.

Sets Frame Type produced by the camera. The frame type can be retrieved using the FPROFrame_GetFrameType() API. The default frame type is FPRO_FRAMETYPE_NORMAL. Typically this is only used for testing purposes. Consult your documentation for a description and availability of the different frame types found on a given camera model. See also FPRO_FRAME_TYPE.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eType- The frame type to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_SetImageArea()

LIBFLIPRO_API FPROFrame_SetImageArea ( int32_t  iHandle,
uint32_t  uiColOffset,
uint32_t  uiRowOffset,
uint32_t  uiWidth,
uint32_t  uiHeight 
)

Sets the area of the image sensor to be used to produce image frame data.

Image frames are retrieved using the FPROFrame_GetVideoFrame() API.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiColOffset- Start column (pixel) of the image frame
uiRowOffset- Start row (pixel) of the image frame
uiWidth- Width of the image frame in pixels.
uiHeight- Height of the image frame in pixels.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp, SimpleHWMerging.cpp, SimpleImageLoop.cpp, SimpleStreamer.cpp, and StreamingAndHWMerge.cpp.

◆ FPROFrame_SetImageDataEnable()

LIBFLIPRO_API FPROFrame_SetImageDataEnable ( int32_t  iHandle,
bool  bEnable 
)

Enables image data imaging.

Image data may be disabled allowing only reference rows to be produced for image frames. Reference rows are configured with the FPROFrame_SetFrameReferenceRows() API call.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bEnable- true: Enables image data pixels, false: disables image data pixels.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleAPIMerging.cpp, SimpleHWMerging.cpp, and SimpleImageLoop.cpp.

◆ FPROFrame_SetPixelFormat()

LIBFLIPRO_API FPROFrame_SetPixelFormat ( int32_t  iHandle,
FPRO_PIXEL_FORMAT  pfPixelFormat,
uint32_t  uiPixelLSB 
)

Sets the current pixel configuration to the specified values.

See FPROFrame_GetPixelFormat() anc FPROFrame_GetSupportedPixelFormats() for additional information.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pfPixelFormat- The pixel format to set.
uiPixelLSB- The Pixel LSB offset.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_SetTestImageEnable()

LIBFLIPRO_API FPROFrame_SetTestImageEnable ( int32_t  iHandle,
bool  bEnable,
FPROTESTIMAGETYPE  eFormat 
)

Enables test image data to be generated rather than normal image data.

Use this to generate a test pattern rather than capturing image data from the image sensor.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bEnable- true: Enable test image data false: Disables test image data- normal image data produced
eFormat- Format of the test image data to produce. This parameter is ignored if bEnable == false.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_SetTrackingArea()

LIBFLIPRO_API FPROFrame_SetTrackingArea ( int32_t  iHandle,
uint32_t  uiStartRow,
uint32_t  uiEndRow 
)

Sets the area of the image sensor to be used for Tracking Frames during image capture.

The tracking frames are retrieved as normal image frames using the FPROFrame_GetVideoFrame() API. The image frame follow the tracking frames in the USB stream. The exposure time setting set with FPROCtrl_SetExposure() applies to the tracking frames. As such, the total exposure time for your image frame will be exposure_time * uiNumTrackingFrames.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiStartRow- Start row of the tracking frame (inclusive).
uiEndRow- End row of the tracking frame (inclusive).
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_SetTrackingAreaEnable()

LIBFLIPRO_API FPROFrame_SetTrackingAreaEnable ( int32_t  iHandle,
uint32_t  uiNumTrackingFrames 
)

Enables the production of Tracking Frames by the camera.

There will be uiNumTrackingFrames produced for every image frame produced. The image frame follow the tracking frames in the USB stream. The exposure time setting set with FPROCtrl_SetExposure() applies to the tracking frames. As such, the total exposure time for your image frame will be exposure_time * uiNumTrackingFrames.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiNumTrackingFrames- Number of Tracking frames to produce. 0 disables Tracking Frames.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_StreamDeinitialize()

LIBFLIPRO_API FPROFrame_StreamDeinitialize ( int32_t  iHandle)

Deinitializes the Streamer interfaces.

This function deinitializes the streamer interfaces. All streaming operations are stopped and streaming resources are returned to the system.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleStreamer.cpp, and StreamingAndHWMerge.cpp.

◆ FPROFrame_StreamGetPreviewImage()

LIBFLIPRO_API FPROFrame_StreamGetPreviewImage ( int32_t  iHandle,
uint8_t *  pImage,
uint32_t *  pLength,
uint32_t  uiTimeoutMSecs 
)

Retrieve the next image available for preview from the image stream.

This function is to be used while image streaming is taking place. It will retrieve the available preview from the image stream. The image returned is also written to disk as normal. If you call this function faster than the exposure time, you will receive the same preview image.
FPROFrame_StreamGetPreviewImageEx() operates the same as FPROFrame_StreamGetPreviewImage() with the exception of also returning information about the image and the current stream statistics.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pImage- The buffer for the image data.
pLength- On enter, the size of the buffer pointed to by pImage. On exit, the actual number of bytes stored in pImage.
uiTimeoutMSecs- Timeout to wait for an image in milli-seconds. Useful when streaming 1 image. Once the first image arrives, there will always be an image available for preview until FPROFrame_StreamDeinitialize is called.
Returns
Greater than or equal to 0 on success, less than 0 on failure. On timeout, the function returns success (0), and sets the *pLength parameter to 0.

◆ FPROFrame_StreamGetPreviewImageEx()

LIBFLIPRO_API FPROFrame_StreamGetPreviewImageEx ( int32_t  iHandle,
uint8_t *  pImage,
uint32_t *  pLength,
FPROPREVIEW pInfo,
uint32_t  uiTimeoutMSecs 
)

Retrieve the next image available for preview from the image stream.

See FPROFrame_StreamGetPreviewImage().

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pImage- The buffer for the image data.
pLength- On enter, the size of the buffer pointed to by pImage. On exit, the actual number of bytes stored in pImage.
pInfo- Optional. If provided it contains the requisite information about the image and the stream.
uiTimeoutMSecs- Timeout to wait for an image in milli-seconds. Useful when streaming 1 image. Once the first image arrives, there will always be an image available for preview until FPROFrame_StreamDeinitialize is called.
Returns
Greater than or equal to 0 on success, less than 0 on failure. On timeout, the function returns success (0), and sets the *pLength parameter to 0.

◆ FPROFrame_StreamGetStatistics()

LIBFLIPRO_API FPROFrame_StreamGetStatistics ( int32_t  iHandle,
FPROSTREAMSTATS pStats 
)

Stop the streaming operation.

This function stops the actual streaming operations.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pStats- The returned statistics. See FPROSTREAMSTATS.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleStreamer.cpp, and StreamingAndHWMerge.cpp.

◆ FPROFrame_StreamInitialize()

LIBFLIPRO_API FPROFrame_StreamInitialize ( int32_t  iHandle,
uint32_t  uiFrameSizeBytes,
wchar_t *  pRootPath,
wchar_t *  pFilePrefix 
)

Initializes the Streamer interfaces.

The Streamer interfaces enable an efficient stream-to-functionality. Frames are streamed directly from the camera to disk. This function initializes the various sub modules, allocates resources, and enables the streaming capability. This function must be called prior to FPROFrame_StreamStart().

The streaming operation streams frames of the same size. In order to change the frame size, the streaming must be stopped and deinitialized using the FPROFrame_StreamStop() and FPROFrame_StreamDeinitialize() API's respectively. Then a new stream can be initialized with a new frame size.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiFrameSizeBytes- Size of the frames that will be streamed.
pRootPath- Name of the root path to store the files on disk.
pFilePrefix- A file name prefix to be applied to each file being saved..
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleStreamer.cpp, and StreamingAndHWMerge.cpp.

◆ FPROFrame_StreamStart()

LIBFLIPRO_API FPROFrame_StreamStart ( int32_t  iHandle,
uint32_t  uiFrameCount,
uint64_t  uiFrameIntervalMS 
)

Start the streaming operation.

This function starts the actual streaming operations. The streaming interfaces must have been previously initialized by a successful call to FPROFrame_StreamInitialize().
This function returns immediately after the stream is started. You should call FPROFrame_StreamGetStatistics() to retrieve the current statistics of the stream and check the iStatus member of the FPROSTREAMERSTATUS structure for FPRO_STREAMER_STOPPED or an error. Note that FPRO_STREAMER_STOPPED indicates that streaming has stopped from from the camera (i.e. the number of expected images have been received). However, there still may be images queued internally waiting to be written to disk. If you need an explicit number of images to be captured and written to disk, also check the uiDiskFramesWritten of the FPROSTREAMERSTATUS structure to make sure all the images have indeed been written to disk.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiFrameCount- Number of frames to stream. Zero (0) == infinite (until the disk fills or FPROFrame_StreamStop is called.
uiFrameIntervalMS- The frame interval in milliseconds() (exposure time + delay).
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleStreamer.cpp, and StreamingAndHWMerge.cpp.

◆ FPROFrame_StreamStop()

LIBFLIPRO_API FPROFrame_StreamStop ( int32_t  iHandle)

Stop the streaming operation.

This function stops the actual streaming operations.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
SimpleStreamer.cpp, and StreamingAndHWMerge.cpp.

◆ FPROFrame_UnpackFile()

LIBFLIPRO_API FPROFrame_UnpackFile ( wchar_t *  pFileName,
FPROUNPACKEDIMAGES pUPBuffers,
FPROUNPACKEDSTATS pStats 
)

Unpack and merge the given file.

This function performs similarly as the FPROFrame_GetVideoFrameUnpacked() API except that it operates on the given file as opposed to the image data directly from the camera. As such, no connection to the camera is required for this API. If you have retrieved a frame with FPROFrame_GetVideoFrame() or FPROFrame_GetVideoFrameExt(), and saved it to a file, you may pass that file to this function to unpack and merge the image planes. For a description of the pUPBUffers and pStats parameters, see the FPROFrame_GetVideoFrameUnpacked() API function.

The FPROFrame_UnpackFileEx() API was introduced to accomodate the Reference Frame merging algorithm. The FPROFrame_UnpackFile() API simply calls FPROFrame_UnpackFileEx with NULL pointers for the reference file names. This causes Identity Frames to be used for the merge. For a description of the pDSNUFile and pPRNUFile parameters, see FPROAlgo_SetHardwareMergeReferenceFiles.

Parameters
pFileName- The file to unpack and merge.
pUPBuffers- The unpacked buffers.
pStats- The unpacked statistics.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_UnpackFileEx()

LIBFLIPRO_API FPROFrame_UnpackFileEx ( wchar_t *  pFileName,
FPROUNPACKEDIMAGES pUPBuffers,
FPROUNPACKEDSTATS pStats,
const wchar_t *  pDSNUFile,
const wchar_t *  pPRNUFile 
)

Unpack and merge the given file.

See FPROFrame_UnpackFile for a complete description.
One or both of the pDSNUFile and pPRNUFile parameters may be NULL. In that case, an identity reference frame will be used for the missing (NULL) frame. For a description of the pDSNUFile and pPRNUFile parameters, see FPROAlgo_SetHardwareMergeReferenceFiles.

Parameters
pFileName- The file to unpack and merge.
pUPBuffers- The unpacked buffers.
pStats- The unpacked statistics.
pDSNUFile- DSNU Reference file to use (may be NULL)
pPRNUFile- PRNU Reference File to use (may be NULL)
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPRONV_ReadNVStorage()

LIBFLIPRO_API FPRONV_ReadNVStorage ( int32_t  iHandle,
uint32_t  uiOffset,
uint8_t *  pData,
uint32_t  uiLength 
)

Read the non volatile storage area on the camera.

This function simply reads the non volatile storage area on the camera and returns it in the provided buffer. See # FPRONV_WriteNVStorage for more information.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiOffset- The offset within the NV area to begin the read.
pData- The buffer for the data.
uiLength- The number of bytes to read.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPRONV_WriteNVStorage()

LIBFLIPRO_API FPRONV_WriteNVStorage ( int32_t  iHandle,
uint32_t  uiOffset,
uint8_t *  pData,
uint32_t  uiLength 
)

Write the given data to the non volatile storage area on the camera.

This function simply writes the given data to the non volatile storage area on the camera. This API allows users to keep proprietary settings linked with a given camera. No structure is imposed on the data by this API nor the camera. That is, the data is simply treated as a byte stream. It is up to the user to format the data as required for their application.

Note that not all cameras may support a non-volatile memory area. You can determine if it is available and the size by reading the capabilities of the camera using the FPROSensor_GetCapabilityList API. The uiNVStorageAvailable field in this structure contains the size in bytes of the NV storage area.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiOffset- The offset within the NV area to begin the write.
pData- The data to write.
uiLength- The number of bytes to write.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetBinning()

LIBFLIPRO_API FPROSensor_GetBinning ( int32_t  iHandle,
uint32_t *  pXBin,
uint32_t *  pYBin 
)

Retrieves the current pixel bin settings.

The bin setting for horizontal (x direction) and vertical (Y direction) binning.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pXBin- For returned horizontal bin setting.
pYBin- For returned vertical bin setting.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetBinningTable()

LIBFLIPRO_API FPROSensor_GetBinningTable ( int32_t  iHandle,
uint32_t *  pBinTable,
uint32_t *  pTableSizeBytes 
)

Retrieves the Binning table capability from the camera.

The available bin settings for horizontal (x direction) and vertical (Y direction) binning.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pBinTable- User allocated buffer for the bin settings. The size of the table is reported in the Capabilities structure returned by FPROSensor_GetCapabilityList().
pTableSizeBytes- On entry, the size of the buffer. On exit, the number of bytes used.
Returns
Greater than or equal to 0 on success, less than 0 on failure. On success, the returned size may be 0 indicating no binning table exists and the only available binning is 1:1.
Each binning table entry is 32 bits wide. The horizontal binning value is contained in the upper 16 bits and the vertical binning value is contained in the lower 16 bits. There is a binning table entry for each of the horizontal and vertical binning combinations available for the camera. One to one (1:1) binning is always allowed. For example, if 2x2 and 2x4 binning (horizontal x vertical) is supported, the two binning table entries would be in the binning table as follows: 0x00020002, 0x00020004.
If the high bit is set for a given binning, then all binnings up to and including the value with the high bit masked are valid. For example, a binning table entry of 0x88008800 would allow all combinations of binning values from 1:1 through 2048x2048. A binning table entry of 0x88000001 indicates that all horizontal binning values from 1 through 2048 are valid with a vertical binning value of 1;
If not enough room is given for the buffer, the function fails and the size required is returned in pTableSizeBytes. If a different failure occurs, the returned size is set to zero (0).

◆ FPROSensor_GetBlackLevelAdjust()

LIBFLIPRO_API FPROSensor_GetBlackLevelAdjust ( int32_t  iHandle,
FPROBLACKADJUSTCHAN  eChan,
uint32_t *  pAdjustValue 
)

Retrieves the current Black Level Adjustment values for the given channel.


Note that not all cameras support multiple channels for the Black Level Adjustment values. Consult your users manual for specifics on your device. If you call this function on a camera that does not support multiple channels, the eChan parameter is ignored and the single supported channel is retrieved.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eChan- The adjustment channel to retrieve.
pAdjustValue- For returned adjustment values.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetBlackSunAdjust()

LIBFLIPRO_API FPROSensor_GetBlackSunAdjust ( int32_t  iHandle,
FPROBLACKADJUSTCHAN  eChan,
uint32_t *  pAdjustValue 
)

Retrieves the current Black Sun Adjustment values for the given channel.


Note that not all cameras support multiple channels for the Black Sun Adjustment values. Consult your users manual for specifics on your device. If you call the FPROSensor_GetBlackSunAdjust() API for a camera that does support multiple channels, the channel defaults to the first channel on the device.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eChan- The adjustment channel to retrieve.
pAdjustValue- For returned adjustment values.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetCapabilityList()

LIBFLIPRO_API FPROSensor_GetCapabilityList ( int32_t  iHandle,
uint32_t *  pCapList,
uint32_t *  pNumCaps 
)

Retrieves the capabilities list for the connected camera.

The list you pass in is expected to be a list that can be indexed by the FPROCAPS enumeration. It is filled in up to the max number of capabilities specified by the pNumCaps parameter.

If pNumCaps specifies a number larger than the actual number of capabilities present on the camera, on return it contains the actual number of capabilities obtained. In all cases, the list is indexed by the FPROCAPS enumeration.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pCapList- User allocated buffer to store the capabilities list.
pNumCaps- On entry the number of capabilities able to be stored in pCapList. On exit, the actual number of capabilities returned.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
CapabilitiesAndGainTables.cpp, SimpleAPIMerging.cpp, SimpleHWMerging.cpp, SimpleImageLoop.cpp, and SimpleStreamer.cpp.

◆ FPROSensor_GetGainIndex()

LIBFLIPRO_API FPROSensor_GetGainIndex ( int32_t  iHandle,
FPROGAINTABLE  eTable,
uint32_t *  pGainIndex 
)

Retrieves the current setting for the Gain for the specified table.

Note: The index returned is the index into the table as returned by FPROSensor_GetGainTable().

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eTable- The table to retrieve.
pGainIndex- Buffer for the returned index.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
CapabilitiesAndGainTables.cpp.

◆ FPROSensor_GetGainTable()

LIBFLIPRO_API FPROSensor_GetGainTable ( int32_t  iHandle,
FPROGAINTABLE  eTable,
FPROGAINVALUE pGainValues,
uint32_t *  pNumEntries 
)

Retrieves the specified Gain Table.

The pNumEntries command should be derived from the uiLDRGain, uiHDRGain, or uiGlobalGain values in the FPROCAPS capabilities structure.

Note: Each gain that is returned is scaled to produce an integer number. The scale factor is defined as FPRO_GAIN_SCALE_FACTOR in the API.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eTable- The table to retrieve.
pGainValues- Buffer for the returned values.
pNumEntries- On entry, the number of locations available in the buffer. On exit, the actual number of values inserted in the table.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
CapabilitiesAndGainTables.cpp.

◆ FPROSensor_GetHDREnable()

LIBFLIPRO_API FPROSensor_GetHDREnable ( int32_t  iHandle,
FPROHDR pHDREnable 
)

Retrieves the current setting for HDR enable.

See FPROHDR enumeration for details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pHDREnable- Buffer for the returned HDR enable flag.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetHighGainOnlyEnable()

LIBFLIPRO_API FPROSensor_GetHighGainOnlyEnable ( int32_t  iHandle,
bool *  pHighGainOnly 
)

Retrieves the High Gain Only Mode.

Returns the High Gain Only Mode setting.
Note: The High Gain Only Mode is not applicable to all camera models.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pHighGainOnly- High Gain only mode flag.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetMode()

LIBFLIPRO_API FPROSensor_GetMode ( int32_t  iHandle,
uint32_t  uiModeIndex,
FPROSENSMODE pMode 
)

Retrieves the current mode name for the specified index.

The number of available modes are retrieved using the FPROSensor_GetModeCount API.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiModeIndex- The index of the mode to retrieve.
pMode- Buffer for the returned mode information.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
WorkingWithModes.cpp.

◆ FPROSensor_GetModeCount()

LIBFLIPRO_API FPROSensor_GetModeCount ( int32_t  iHandle,
uint32_t *  pCount,
uint32_t *  pCurrentMode 
)

Retrieves the current mode count and current mode index setting.

Mode information for a given index is retrieved using the FPROSensor_GetMode() API.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pCount- Buffer for the number of available modes.
pCurrentMode- Buffer for index of the currently assigned mode.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
WorkingWithModes.cpp.

◆ FPROSensor_GetReadoutConfiguration()

LIBFLIPRO_API FPROSensor_GetReadoutConfiguration ( int32_t  iHandle,
FPROSENSREADCFG pReadCfg 
)

Retrieves the current sensor read out configuration on supported models.

For camera models that support sensor channel read out configuration, this API retrieves the current setting. For models that do not support this feature, this function always returns success with a value of 0 for the configuration.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pReadCfg- Buffer for the configuration.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetSamplesPerPixel()

LIBFLIPRO_API FPROSensor_GetSamplesPerPixel ( int32_t  iHandle,
FPROCMS pSamplesPerPixel 
)

Retrieves the Samples Per Pixel settings on the sensor.

NOTE: This function is not supported on on all camera models. Consult your documentation for your specific camera.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pSamplesPerPixel- Returned Samples Per Pixel Setting.
Returns
Greater than or equal to 0 on success, less than 0 on failure. On devices that do not support this setting, 0 is always returned with pSamplesPerPixel set to FPROCMS_1.

◆ FPROSensor_GetScanDirection()

LIBFLIPRO_API FPROSensor_GetScanDirection ( int32_t  iHandle,
bool *  pHInverted,
bool *  pVInverted 
)

Retrieves the current pixel scan direction settings on the sensor.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pHInverted- Returned horizontal scan direction: False = Normal, True = Inverted.
pVInverted- Returned vertical scan direction: False = Normal, True = Inverted.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetTrainingEnable()

LIBFLIPRO_API FPROSensor_GetTrainingEnable ( int32_t  iHandle,
bool *  pEnable 
)

Returns the sensor re-training setting.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pEnable- true: Forces sensor to undergo training. False - stops the sensor training.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetAnalogGain()

LIBFLIPRO_API FPROSensor_SetAnalogGain ( int32_t  iHandle,
int32_t  iGainValue 
)

Sets the analog gain for the sensor.

Note: Not all camera models support this feature. Consult you camera documentation for details. In addition, cameras do not currently support read back of this value so there is no corresponding FPROSensor_GetAnalogGain() API.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
iGainValue- The analog gain value to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetBinning()

LIBFLIPRO_API FPROSensor_SetBinning ( int32_t  iHandle,
uint32_t  uiXBin,
uint32_t  uiYBin 
)

Sets the desired horizontal and vertical binning.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiXBin- Horizontal bin setting.
uiYBin- Vertical bin setting.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetBlackLevelAdjust()

LIBFLIPRO_API FPROSensor_SetBlackLevelAdjust ( int32_t  iHandle,
FPROBLACKADJUSTCHAN  eChan,
uint32_t  uiAdjustValue 
)

Sets the current Black Level Adjustment values.


Note that not all cameras support multiple channels for the Black Level Adjustment values. Consult your users manual for specifics on your device. If you call the FPROSensor_SetBlackLevelAdjust() API for a camera that does support multiple channels, the channel defaults to the first channel on the device.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eChan- The adjustment channel to set.
uiAdjustValue- Value to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetBlackSunAdjust()

LIBFLIPRO_API FPROSensor_SetBlackSunAdjust ( int32_t  iHandle,
FPROBLACKADJUSTCHAN  eChan,
uint32_t  uiAdjustValue 
)

Sets the current Black Sun Adjustment value.


Note that not all cameras support multiple channels for the Black Sun Adjustment values. Consult your users manual for specifics on your device. If you call the FPROSensor_SetBlackSunAdjust() API for a camera that does support multiple channels, the channel defaults to the first channel on the device.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eChan- The adjustment channel to set.
uiAdjustValue- Value to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetGainIndex()

LIBFLIPRO_API FPROSensor_SetGainIndex ( int32_t  iHandle,
FPROGAINTABLE  eTable,
uint32_t  uiGainIndex 
)

Sets the current setting for the Gain for the specified table.

Note: The index is the index into the table as returned by FPROSensor_GetGainTable(). Note: When setting an LDR gain table index, if the camera is in an LDR mode, as set by FPROSensor_SetMode(), the HDR gain index is set to match to maintain image integrity. If you attempt to set an HDR index when in an LDR mode, the function will return an error. Set the mode first using FPROSensor_SetMode(), then override the gain settings as desired using this function.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eTable- The table to retrieve.
uiGainIndex- Index value to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
CapabilitiesAndGainTables.cpp.

◆ FPROSensor_SetHDREnable()

LIBFLIPRO_API FPROSensor_SetHDREnable ( int32_t  iHandle,
FPROHDR  eHDREnable 
)

Sets the setting for HDR enable.

See FPROHDR enumeration for details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eHDREnable- The HDR setting.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetHighGainOnlyEnable()

LIBFLIPRO_API FPROSensor_SetHighGainOnlyEnable ( int32_t  iHandle,
bool  bHighGainOnly 
)

Sets the High Gain Only Mode.

Note: The High Gain Only Mode is not applicable to all camera models. In addition, it is only applicable in HDR modes. When in an HDR mode, if the High Gain Only flag is set, only the High Gain image will be returned by the camera.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bHighGainOnly- High Gain only mode flag.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetMode()

LIBFLIPRO_API FPROSensor_SetMode ( int32_t  iHandle,
uint32_t  uiModeIndex 
)

Sets the current mode specified by the given index.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiModeIndex- The index of the mode to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples
WorkingWithModes.cpp.

◆ FPROSensor_SetReadoutConfiguration()

LIBFLIPRO_API FPROSensor_SetReadoutConfiguration ( int32_t  iHandle,
FPROSENSREADCFG  eReadCfg 
)

Sets the sensor read out configuration on supported models.

For camera models that support sensor channel read out configuration, this API sets the given setting. The function will return failure if the given configuration is invalid for the camera model connected. For models that do not support this feature, this function has no effect.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eReadCfg- The configuration to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetSamplesPerPixel()

LIBFLIPRO_API FPROSensor_SetSamplesPerPixel ( int32_t  iHandle,
FPROCMS  eSamplesPerPixel 
)

Sets the Samples Per Pixel settings on the sensor.

NOTE: This function is not supported on on all camera models. Consult your documentation for your specific camera.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eSamplesPerPixel- The Samples Per Pixel Setting to set.
Returns
Greater than or equal to 0 on success, less than 0 on failure. On devices that do not support this setting, 0 is always returned.

◆ FPROSensor_SetScanDirection()

LIBFLIPRO_API FPROSensor_SetScanDirection ( int32_t  iHandle,
bool  bHInverted,
bool  bVInverted 
)

Retrieves the current pixel scan direction settings on the sensor.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bHInverted- Horizontal scan direction: False = Normal, True = Inverted.
bVInverted- Vertical scan direction: False = Normal, True = Inverted..
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_SetTrainingEnable()

LIBFLIPRO_API FPROSensor_SetTrainingEnable ( int32_t  iHandle,
bool  bEnable 
)

Enables/Disables sensor re-training.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
bEnable- true: Forces sensor to undergo training. False - stops the sensor training.
Returns
Greater than or equal to 0 on success, less than 0 on failure.