FLI libflipro API
Classes | Macros | Typedefs | Enumerations | Functions
/home/tom/projects/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  device_info_t
 
struct  device_version_info_t
 
struct  ext_trigger_info_t
 
struct  sensor_mode_t
 
struct  gain_value_t
 
struct  camera_capabilities_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
 

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_GET_MAX_PIXEL_DEPTH(__pCapCam, __uiMax)
 Max pixel depth. More...
 
#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_SENSOR_MODE_NAME_LENGTH   (32)
 Sensor Mode Name Length. More...
 
#define FPRO_GAIN_SCALE_FACTOR   (1000)
 Gain Scale Factor. More...
 

Typedefs

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 struct sensor_mode_t FPROSENSMODE
 Sensor Modes. More...
 
typedef struct gain_value_t FPROGAINVALUE
 Gain Value. More...
 
typedef struct camera_capabilities_t FPROCAP
 Camera Capabilities. 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...
 

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_KODAK47051 = 0x02047051, FPRO_CAM_DEVICE_TYPE_KODAK29050 = 0x02029050, 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
}
 Known Device Types. More...
 
enum  FPROCONNECTION { FPRO_CONNECTION_USB, FPRO_CONNECTION_FIBRE }
 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  FPRODBGLEVEL {
  FPRO_DEBUG_NONE, FPRO_DEBUG_ERROR, FPRO_DEBUG_WARNING, FPRO_DEBUG_INFO,
  FPRO_DEBUG_REGRW, FPRO_DEBUG_DEBUG, FPRO_DEBUG_TRACE
}
 Debug Capability. More...
 
enum  FPROGPSSTATE { FPRO_GPS_NOT_DETECTED = 0, FPRO_GPS_DETECTED_NO_SAT_LOCK, FPRO_GPS_DETECTED_AND_SAT_LOCK }
 GPS Connection State. 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  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 }
 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_HWMERGEFRAMES { HWMERGE_FRAME_BOTH = 0, HWMERGE_FRAME_LOWONLY, HWMERGE_FRAME_HIGHONLY }
 Enables for Hardware Image Merging. More...
 
enum  FPRO_MERGEALGO { FPROMERGE_ALGO = 0, FPROMERGE_ALGO_REF_FRAME }
 Merging algorithms available in the API. 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_GetHostSerialNumbers (int32_t iHandle, wchar_t *pFibre, wchar_t *pPcie, uint32_t uiLength)
 Returns the version information from the connected device. 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_GetFrameType (int32_t iHandle, FPRO_FRAME_TYPE *pType)
 Retrieves the Frame Type setting. More...
 
LIBFLIPRO_API FPROFrame_GetReferenceRowPostFrameCount (int32_t iHandle, uint32_t *pNumRows)
 Retrieves the reference row count to be appended to frame data. More...
 
LIBFLIPRO_API FPROFrame_GetReferenceRowPreFrameCount (int32_t iHandle, uint32_t *pNumRows)
 Retrieves the reference row count to be prepended to frame data. 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_GetPixelConfig (int32_t iHandle, uint32_t *pPixelDepth, uint32_t *pPixelLSB)
 Retrieves the current pixel configuration. 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_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 uiMaxSize)
 Convert the meta data in the given file to string. More...
 
LIBFLIPRO_API FPROFrame_IsAvailable (int32_t iHandle, bool *pAvailable)
 Returns whether or not Image Frame data is ready for retrieval. More...
 
LIBFLIPRO_API FPROFrame_SetDummyPixelEnable (int32_t iHandle, bool bEnable)
 Sets the dummy pixel configuration to be appended row data. More...
 
LIBFLIPRO_API FPROFrame_SetFrameType (int32_t iHandle, FPRO_FRAME_TYPE eType)
 Sets Frame Type produced by the camera. More...
 
LIBFLIPRO_API FPROFrame_SetReferenceRowPostFrameCount (int32_t iHandle, uint32_t uiNumRows)
 Sets the reference row count to be appended to frame data. More...
 
LIBFLIPRO_API FPROFrame_SetReferenceRowPreFrameCount (int32_t iHandle, uint32_t uiNumRows)
 Sets the reference row count to be prepended to frame data. 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_SetPixelConfig (int32_t iHandle, uint32_t uiPixelDepth, 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_SetUnpackingBiasFrames (int32_t iHandle, uint32_t uiWidth, uint32_t uiHeight, uint16_t *pLowFrame, uint16_t *pHighFrame)
 Sets Bias frame correction to be used during unpacking. More...
 
LIBFLIPRO_API FPROFrame_SetUnpackingFlatFieldFrames (int32_t iHandle, uint32_t uiWidth, uint32_t uiHeight, uint16_t *pLowFrame, uint16_t *pHighFrame)
 Sets Flat Field correction to be used during unpacking. 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)
 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 *pAmbientTemp, 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_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, uint32_t *pAdjustValue)
 Retrieves the current Black Level Adjustment values. More...
 
LIBFLIPRO_API FPROSensor_GetBlackLevelAdjustEx (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, uint32_t *pAdjustValue)
 Retrieves the current Black Sun Adjustment values. More...
 
LIBFLIPRO_API FPROSensor_GetBlackSunAdjustEx (int32_t iHandle, FPROBLACKADJUSTCHAN eChan, uint32_t *pAdjustValue)
 Retrieves the current Black Sun Adjustment values for the given channel. More...
 
LIBFLIPRO_API FPROSensor_GetCapabilities (int32_t iHandle, FPROCAP *pCap, uint32_t *pCapLength)
 Retrieves the sensor capabilities structure from the 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, bool *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, uint32_t uiAdjustValue)
 Sets the current Black Level Adjustment values. More...
 
LIBFLIPRO_API FPROSensor_SetBlackLevelAdjustEx (int32_t iHandle, FPROBLACKADJUSTCHAN eChan, uint32_t uiAdjustValue)
 Sets the current Black Level Adjustment value for the given channel. More...
 
LIBFLIPRO_API FPROSensor_SetBlackSunAdjust (int32_t iHandle, uint32_t uiAdjustValue)
 Sets the current Black Sun Adjustment value. More...
 
LIBFLIPRO_API FPROSensor_SetBlackSunAdjustEx (int32_t iHandle, FPROBLACKADJUSTCHAN eChan, uint32_t uiAdjustValue)
 Sets the current Black Sun Adjustment value for the given channel. 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_GetExposureActivePolarity (int32_t iHandle, bool *pActiveHigh)
 Get the Exposure Active Signal Polarity. More...
 
LIBFLIPRO_API FPROAuxIO_GetExposureActiveType (int32_t iHandle, FPROAUXIO_EXPACTIVETYPE *pType)
 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_SetExposureActivePolarity (int32_t iHandle, bool bActiveHigh)
 Exposure Active Signal Polarity. More...
 
LIBFLIPRO_API FPROAuxIO_SetExposureActiveType (int32_t iHandle, FPROAUXIO_EXPACTIVETYPE eType)
 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_GET_MAX_PIXEL_DEPTH

#define FPRO_GET_MAX_PIXEL_DEPTH (   __pCapCam,
  __uiMax 
)
Value:
{ \
if (__pCapCam) \
{ \
for (int __ix = 0; __ix < 32; ++__ix) \
if (__pCapCam->uiAvailablePixelDepths & (1 << __ix)) \
__uiMax = __ix + 1; \
} \
else \
{ \
__uiMax = 12; \
} \
}

Max pixel depth.

Use this macro to extract the Max Pixel depth supported by the device from the FPROCAP capabilities structure.

◆ 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.

◆ FPROCAP

Camera Capabilities.

The camera capabilities structure is a structure provided by the camera that publishes a set of camera capabilities. The structure is retrieved using the FPROSensor_GetCapabilities API.

Different camera models offer different sets of capabilities based on the imaging sensor and other hardware attributes. The values in this structure can be used by an application to configure settings and user interfaces based on the specific camera model that is connected. The uiDeviceType member is a specific device type, one of FPRODEVICETYPE, that allows further checking by an application as it can cover specific functionality not described by this structure. 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.

Reference Rows: The Pre and Post frame reference row fields in the capabilities structure is the number of physical pre/post imaging sensor cells available for the camera model. For pre-frame reference row, this is a hard number. That is, no more pre-frame reference rows may be requested in an image frame than specified by this number. For post-frame reference rows, additional reference rows may be requested in an image frame. The post-frame number is just provided to indicate the number of physical rows available.

Dummy Pixels: For API versions up to 1.10.x, the uiDummyPixelNum field contained the Dummy pixels pixels appended to specified rows (post row). From API versions 1.11.x and onward, the value is divided into two 16 bit quantities. The upper 16 bits contains the Pre-Row Dummy Pixels and the lower 16 bits contains the Post Row Dummy Pixels. Note for this to be completely functional, your camera firmware version must also be version 1.11.x or newer.

Examples:
CapabilitiesAndGainTables.cpp, SimpleAPIMerging.cpp, SimpleImageLoop.cpp, and SimpleStreamer.cpp.

◆ 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.

◆ 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.

◆ 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_MERGEALGO

Merging algorithms available in the API.

This enum is for use with the FPROFrame_GetVideoFrameUnpacked() API to retrieve unpacked and merged image data. This enum tells the API which algorithm to use when merging data. See FPROUNPACKEDIMAGES for more information on unpacking and merging in general. See FPROAlgo_SetHardwareMergeEnables(), FPROAlgo_SetHardwareMergeReferenceFrames() and FPRO_REFFRAMES for more information on the hardware merge (and API emulation) setup.

Enumerator
FPROMERGE_ALGO 

Original merge algorithm based on camera settings.

FPROMERGE_ALGO_REF_FRAME 

Emulates the hardware merge algorithm found on the FLI PCIE Fibre cards. Reference frames are required to be sent to the API for this to function correctly. Identity reference frames are used if none are sent.

◆ 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- consult your camera documentation for timing details.

FPRO_AUXIO_EXPTYPE_GLOBAL_EXPOSURE_ACTIVE 

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

FPRO_AUXIO_EXPTYPE_FIRST_ROW_SYNC 

First Row Sync- 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_GetBlackLevelAdjustEx, FPROSensor_GetBlackSunAdjustEx, FPROSensor_SetBlackLevelAdjustEx, and FPROSensor_SetBlackSunAdjustEx 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.

◆ 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.

◆ FPRODBGLEVEL

Debug Capability.

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

Enumerator
FPRO_DEBUG_NONE 

All debug disabled.

FPRO_DEBUG_ERROR 

Only ERROR level debug is output.

FPRO_DEBUG_WARNING 

WARNING and ERROR debug is output.

FPRO_DEBUG_INFO 

INFO, WARNING, and ERROR debug is output.

FPRO_DEBUG_REGRW 

REGWR, INFO, WARNING, and ERROR debug is output.

FPRO_DEBUG_DEBUG 

DEBUG, REGRW, INFO, WARNING, and ERROR debug is output.

FPRO_DEBUG_TRACE 

TRACE, DEBUG, REGRW, INFO, WARNING, and ERROR debug is output.

◆ FPRODEVICETYPE

Known Device Types.

These constants are returned in the Device Capabilities Structure FPROCAP in the uiDeviceType field. 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_KODAK47051 

Enum value = 0x02047051.

FPRO_CAM_DEVICE_TYPE_KODAK29050 

Enum value = 0x02029050.

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.

◆ 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. The number of gain settings for the camera are stored in the device Capabilities structure FPROCAP.

◆ 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.

◆ 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, 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.

See FPRO_REFFRAMES for a description on how to use this function.

The examples code also provides guidance for building this structure from your reference images. See the StreamingAndHWMerge example for further 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, 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.

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).
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_GetExposureActivePolarity()

LIBFLIPRO_API FPROAuxIO_GetExposureActivePolarity ( int32_t  iHandle,
bool *  pActiveHigh 
)

Get the Exposure Active Signal Polarity.

This function gets the Exposure Active Signal polarity for the Exposure Type Auxiliary output pin. See FPROAuxIO_SetExposureActiveType for additional information. Consult your documentation for signal timing details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eType- Exposure Active Polarity: true= Active High, false= Active Low.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAuxIO_GetExposureActiveType()

LIBFLIPRO_API FPROAuxIO_GetExposureActiveType ( int32_t  iHandle,
FPROAUXIO_EXPACTIVETYPE pType 
)

Get Exposure Active Type Signal.

This function gets the Exposure Type Signal for the Exposure Type Auxiliary output pin. Consult your documentation for signal timing details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pType- Exposure Active Signal Type.
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_SetExposureActivePolarity()

LIBFLIPRO_API FPROAuxIO_SetExposureActivePolarity ( int32_t  iHandle,
bool  bActiveHigh 
)

Exposure Active Signal Polarity.

This function sets the Exposure Active Signal polarity for the Exposure Type Auxiliary output pin. See FPROAuxIO_SetExposureActiveType for additional information. Consult your documentation for signal timing details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eType- Exposure Active Polarity: true= Active High, false= Active Low.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROAuxIO_SetExposureActiveType()

LIBFLIPRO_API FPROAuxIO_SetExposureActiveType ( int32_t  iHandle,
FPROAUXIO_EXPACTIVETYPE  eType 
)

Exposure Active Type Signal.

This function sets the Exposure Type Signal for the Exposure Type Auxiliary output pin. Consult your documentation for signal timing details.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
eType- Exposure Active Signal Type.
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, 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, 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_GetHostSerialNumbers()

LIBFLIPRO_API FPROCam_GetHostSerialNumbers ( int32_t  iHandle,
wchar_t *  pFibre,
wchar_t *  pPcie,
uint32_t  uiLength 
)

Returns the version information from the connected device.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open().
pFibre- Buffer for the Fibre FPGA serial number on the Host PCIE card.
pPcie- Buffer for the PCIE FPGA serial number on the Host PCIE card.
uiLength- Length of each of the buffers (they must be the same length). Serial numbers are limited to 32 characters by the API.
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, 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 
)

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.
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 the camera controls the shutter during exposures. In order for the FPROCtrl_SetShutterOpen() API to correctly control the shutter, the FPROCtrl_SetShutterOverride() API must be called prior with the override parameter set to True.

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 the camera controls the shutter during exposures. In order for the FPROCtrl_SetShutterOpen() API to correctly control the shutter, the shutter override must be set to True.

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 *  pAmbientTemp,
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()
pAmbientTemp- For the returned Ambient temperature, deg C.
pBaseTemp- For the returned Base temperature, deg C.
pCoolerTemp- For the returned Cooler temperature, deg C.
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().

Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples:
SimpleAPIMerging.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.

Parameters
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 after imaging modes have changed using this and its counterpart API function FPROCtrl_GetExposure().

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_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 the camera controls the shutter during exposures. In order for the FPROCtrl_SetShutterOpen() API to correctly control the shutter, the FPROCtrl_SetShutterOverride() API must be called prior with the override parameter set to True.

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 the camera controls the shutter during exposures. In order for the FPROCtrl_SetShutterOpen() API to correctly control the shutter, the shutter override must be set to True.

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.

◆ 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.

◆ 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:

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, 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:
SimpleAPIMerging.cpp, and 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, 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_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_SetReferenceRowPostFrameCount() and FPROFrame_SetReferenceRowPreFrameCount() API calls.

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_GetPixelConfig()

LIBFLIPRO_API FPROFrame_GetPixelConfig ( int32_t  iHandle,
uint32_t *  pPixelDepth,
uint32_t *  pPixelLSB 
)

Retrieves the current pixel configuration.

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

◆ FPROFrame_GetReferenceRowPostFrameCount()

LIBFLIPRO_API FPROFrame_GetReferenceRowPostFrameCount ( int32_t  iHandle,
uint32_t *  pNumRows 
)

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 FPROCAP capabilities structure for details about reference rows.

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

◆ FPROFrame_GetReferenceRowPreFrameCount()

LIBFLIPRO_API FPROFrame_GetReferenceRowPreFrameCount ( int32_t  iHandle,
uint32_t *  pNumRows 
)

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

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

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pNumRows- Pointer to the number of reference rows to prepend to the image frame data.
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().

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:

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:
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.

This function will also perform Bias and Flat Field correction on the Low Gain and High Gain frames if those operations are set up prior to this call with the FPROFrame_SetUnpackingBiasFrames() and FPROFrame_SetUnpackingFlatFieldFrames() API's.

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_IsAvailable()

LIBFLIPRO_API FPROFrame_IsAvailable ( int32_t  iHandle,
bool *  pAvailable 
)

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.

◆ FPROFrame_MetaDataToString()

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

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.

Parameters
pFileName- The file to parse.
pMetaString- The string buffer.
uiMaxSize- The size of the string buffer pMetaString.
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 
)

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_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, 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_SetReferenceRowPreFrameCount() and FPROFrame_SetReferenceRowPostFrameCount() API calls.

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, and SimpleImageLoop.cpp.

◆ FPROFrame_SetPixelConfig()

LIBFLIPRO_API FPROFrame_SetPixelConfig ( int32_t  iHandle,
uint32_t  uiPixelDepth,
uint32_t  uiPixelLSB 
)

Sets the current pixel configuration to the specified values.

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

◆ FPROFrame_SetReferenceRowPostFrameCount()

LIBFLIPRO_API FPROFrame_SetReferenceRowPostFrameCount ( int32_t  iHandle,
uint32_t  uiNumRows 
)

Sets 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 FPROCAP capabilities structure for details about reference rows.

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

◆ FPROFrame_SetReferenceRowPreFrameCount()

LIBFLIPRO_API FPROFrame_SetReferenceRowPreFrameCount ( int32_t  iHandle,
uint32_t  uiNumRows 
)

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

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

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiNumRows- The number of reference rows to prepend to the image frame data.
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_SetUnpackingBiasFrames()

LIBFLIPRO_API FPROFrame_SetUnpackingBiasFrames ( int32_t  iHandle,
uint32_t  uiWidth,
uint32_t  uiHeight,
uint16_t *  pLowFrame,
uint16_t *  pHighFrame 
)

Sets Bias frame correction to be used during unpacking.

This function is meant to be used when you intend to use the FPROFrame_GetVideoFrameUnpacked() API to retrieve image data. During unpacking, the specified Bias frames will be applied to the raw image data. The operation is a simple subtraction on the raw image data. See FPROFrame_GetVideoFrameUnpacked() for more information.

The dimensions of the frames you pass must match the dimensions of the image frames you are collecting including pre and prost row reference pixels and pre and post frame reference rows. If they do not match, then the correction is not applied by the FPROFrame_GetVideoFrameUnpacked() and FPROFrame_GetVideoFrameUnpacked() will return a failure.

The frame data you pass must be in row major order. The API copies the passed frames to an internal buffer so you may discard the buffers on return. Passing NULL for a frame pointer disables the correction for the given frame (and deletes the internal buffer copy).

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiWidth- The width of the bias frames in pixels.
uiHeight- The height of the bias frames in pixels.
pLowFrame- The bias correction to be applied to the Low Gain Image.
pHighFrame- The bias correction to be applied to the High Gain Image.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROFrame_SetUnpackingFlatFieldFrames()

LIBFLIPRO_API FPROFrame_SetUnpackingFlatFieldFrames ( int32_t  iHandle,
uint32_t  uiWidth,
uint32_t  uiHeight,
uint16_t *  pLowFrame,
uint16_t *  pHighFrame 
)

Sets Flat Field correction to be used during unpacking.

This function is meant to be used when you intend to use the FPROFrame_GetVideoFrameUnpacked() API to retrieve image data. During unpacking, the specified Flat Field Correction frames will be applied to the raw image data. See FPROFrame_GetVideoFrameUnpacked() for more information.

The dimensions of the frames you pass must match the dimensions of the image frames you are collecting including pre and prost row reference pixels and pre and post frame reference rows. If they do not match, then the correction is not applied by the FPROFrame_GetVideoFrameUnpacked() and FPROFrame_GetVideoFrameUnpacked() will return a failure.

The frame data you pass must be in row major order. The API copies the passed frames to an internal buffer so you may discard the buffers on return. Passing NULL for a frame pointer disables the correction for the given frame (and deletes the internal buffer copy).

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
uiWidth- The width of the Flat Field frames in pixels.
uiHeight- The height of the Flat Field frames in pixels.
pLowFrame- The Flat Field correction to be applied to the Low Gain Image.
pHighFrame- The Flat Field correction to be applied to the High Gain Image.
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. If the FPROMERGE_ALGO_REF_FRAME, algorithm is specified in the pUPBuffers parameter, 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 the case where the FPROMERGE_ALGO_REF_FRAME algorithm is specified in the pUPBuffers parameter, 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_GetCapabilities 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_GetCapabilities().
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,
uint32_t *  pAdjustValue 
)

Retrieves the current Black Level Adjustment values.

For the ex (extended) function, a channel must be specified, on of the FPROBLACKADJUSTCHAN enumeration 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_GetBlackLevelAdjust() API for a camera that does support multiple channels, the channel defaults to the first channel on the device.
If you call the 'ex' (extended) 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()
pAdjustValue- For returned adjustment values.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetBlackLevelAdjustEx()

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

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


See FPROSensor_GetBlackLevelAdjust().

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,
uint32_t *  pAdjustValue 
)

Retrieves the current Black Sun Adjustment values.

For the ex (extended) function, a channel must be specified, on of the FPROBLACKADJUSTCHAN enumeration values. 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.

If you call the 'ex' (extended) 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()
pAdjustValue- For returned adjustment values.
Returns
Greater than or equal to 0 on success, less than 0 on failure.

◆ FPROSensor_GetBlackSunAdjustEx()

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

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


See FPROSensor_GetBlackSunAdjust().

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_GetCapabilities()

LIBFLIPRO_API FPROSensor_GetCapabilities ( int32_t  iHandle,
FPROCAP pCap,
uint32_t *  pCapLength 
)

Retrieves the sensor capabilities structure from the camera.

Note that you may pass in a generic buffer in which to store the capabilities rather than a strict FPROCAP structure pointer. The pCapLength parameter is the length of the buffer you are passing. It is used to determine if there is enough space in the buffer prior to reading the capabilities.

The camera is asked for the size of the capabilities prior to retrieving them. If sufficient space exists (as specified by the pCapLength parameter), then the capabilities are retrieved. This sequence allows older API's to work with newer cameras and different capabilities structures. The length and version fields should be parsed by the caller in order to determine the proper structure format.

In the event of failure, if the *pCapLength value is > 0, the call failed because the buffer passed in was too small. In this case, the *pCapLength value is the size of the buffer required to read the capabilities successfully.

Parameters
iHandle- The handle to an open camera device returned from FPROCam_Open()
pCap- Buffer to store the capabilities structure
pCapLength- On entry the size of the buffer pointed to by pCap. On exit, the actual size of the structure returned.
Returns
Greater than or equal to 0 on success, less than 0 on failure.
Examples:
CapabilitiesAndGainTables.cpp, SimpleAPIMerging.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 FPROCAP 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,
bool *  pHDREnable 
)

Retrieves the current setting for HDR enable.

The HDR setting is enabled/disabled by setting the appropriate mode using the FPROSensor_SetMode API. As such there is no corresponding 'set' function for HDR enable. This API is simply a convenience function to allow a user to determine if the selected mode has enabled HDR frames. Knowing this is of course critical to determining how much image data will be supplied by the camera for each exposure. When HDR is enabled, there will be twice the image data returned for a frame (including dummy pixels).

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,
uint32_t  uiAdjustValue 
)

Sets the current Black Level Adjustment values.

For the ex (extended) function, a channel must be specified, on of the FPROBLACKADJUSTCHAN enumeration 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.
If you call the ex (extended) function on a camera that does not support multiple channels, the eChan parameter is ignored and the single support channel is set.

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

◆ FPROSensor_SetBlackLevelAdjustEx()

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

Sets the current Black Level Adjustment value for the given channel.

See FPROSensor_SetBlackLevelAdjust.

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,
uint32_t  uiAdjustValue 
)

Sets the current Black Sun Adjustment value.

For the ex (extended) function, a channel must be specified, on of the FPROBLACKADJUSTCHAN enumeration values. 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.
If you call the 'ex' (extended) function on a camera that does not support multiple channels, the eChan parameter is ignored and the single support channel is set.

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

◆ FPROSensor_SetBlackSunAdjustEx()

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

Sets the current Black Sun Adjustment value for the given channel.

See FPROSensor_SetBlackSunAdjust.

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_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.