peak_ipl_backend.h

Go to the documentation of this file.

#pragma once

#include <peak_ipl/backend/peak_ipl_dll_defines.h>

#if __cplusplus >= 201703L || _MSVC_LANG >= 201703L
#    define PEAK_IPL_NO_DISCARD [[nodiscard]]
#    define PEAK_IPL_MAYBE_UNUSED [[maybe_unused]]
#else
#    ifdef _MSC_VER
#        define PEAK_IPL_NO_DISCARD _Check_return_
#        define PEAK_IPL_MAYBE_UNUSED
#    elif defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
#        define PEAK_IPL_NO_DISCARD __attribute__((warn_unused_result))
#        define PEAK_IPL_MAYBE_UNUSED __attribute__((unused))
#    else
#        define PEAK_IPL_NO_DISCARD
#        define PEAK_IPL_MAYBE_UNUSED
#    endif
#endif

#ifdef __cplusplus
#    include <cstddef>
#    include <cstdint>

extern "C" {
#else
#    include <stddef.h>
#    include <stdint.h>
#endif

typedef int8_t PEAK_IPL_BOOL8;

enum PEAK_IPL_RETURN_CODE_t
{
    PEAK_IPL_RETURN_CODE_SUCCESS = 0,
    PEAK_IPL_RETURN_CODE_ERROR = 1,
    PEAK_IPL_RETURN_CODE_INVALID_HANDLE = 2,
    PEAK_IPL_RETURN_CODE_IO_ERROR = 3,
    PEAK_IPL_RETURN_CODE_BUFFER_TOO_SMALL = 4,
    PEAK_IPL_RETURN_CODE_INVALID_ARGUMENT = 5,
    PEAK_IPL_RETURN_CODE_OUT_OF_RANGE = 6,
    PEAK_IPL_RETURN_CODE_IMAGE_FORMAT_NOT_SUPPORTED = 7,
    PEAK_IPL_RETURN_CODE_FORMAT_INTERPRETATION_ERROR = 8,
    PEAK_IPL_RETURN_CODE_NOT_SUPPORTED = 9,
    PEAK_IPL_RETURN_CODE_NOT_PERMITTED = 10,
    PEAK_IPL_RETURN_CODE_BUSY = 11,
    PEAK_IPL_RETURN_CODE_TIMEOUT = 12

};
typedef int32_t PEAK_IPL_RETURN_CODE;

enum PEAK_IPL_CONVERSION_MODE_t
{
    PEAK_IPL_CONVERSION_MODE_FAST = 1,
    PEAK_IPL_CONVERSION_MODE_HIGH_QUALITY = 2,
    PEAK_IPL_CONVERSION_MODE_CLASSIC = 3,
};
typedef int32_t PEAK_IPL_CONVERSION_MODE;

enum PEAK_IPL_PIXEL_FORMAT_t
{
    PEAK_IPL_PIXEL_FORMAT_INVALID = 0,

    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_8 = 0x01080008,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_10 = 0x0110000C,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_12 = 0x01100010,

    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_8 = 0x01080009,
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_10 = 0x0110000D,
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_12 = 0x01100011,

    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_8 = 0x0108000A,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_10 = 0x0110000E,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_12 = 0x01100012,

    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_8 = 0x0108000B,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_10 = 0x0110000F,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_12 = 0x01100013,

    PEAK_IPL_PIXEL_FORMAT_MONO_8 = 0x01080001,
    PEAK_IPL_PIXEL_FORMAT_MONO_10 = 0x01100003,
    PEAK_IPL_PIXEL_FORMAT_MONO_12 = 0x01100005,

    PEAK_IPL_PIXEL_FORMAT_YUV420_8_YY_UV_SemiplanarIDS = 0x420C0001,
    PEAK_IPL_PIXEL_FORMAT_YUV420_8_YY_VU_SemiplanarIDS = 0x420C0002,

    PEAK_IPL_PIXEL_FORMAT_RGB_8 = 0x02180014,
    PEAK_IPL_PIXEL_FORMAT_RGB_10 = 0x02300018,
    PEAK_IPL_PIXEL_FORMAT_RGB_12 = 0x0230001A,

    PEAK_IPL_PIXEL_FORMAT_BGR_8 = 0x02180015,
    PEAK_IPL_PIXEL_FORMAT_BGR_10 = 0x02300019,
    PEAK_IPL_PIXEL_FORMAT_BGR_12 = 0x0230001B,

    PEAK_IPL_PIXEL_FORMAT_RGBA_8 = 0x02200016,
    PEAK_IPL_PIXEL_FORMAT_RGBA_10 = 0x0240005F,
    PEAK_IPL_PIXEL_FORMAT_RGBA_12 = 0x02400061,

    PEAK_IPL_PIXEL_FORMAT_BGRA_8 = 0x02200017,
    PEAK_IPL_PIXEL_FORMAT_BGRA_10 = 0x0240004C,
    PEAK_IPL_PIXEL_FORMAT_BGRA_12 = 0x0240004E,

    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_10_PACKED = 0x010A0052,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_12_PACKED = 0x010C0053,

    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_10_PACKED = 0x010A0054,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_12_PACKED = 0x010C0055,

    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_10_PACKED = 0x010A0056,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_12_PACKED = 0x010C0057,

    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_10_PACKED = 0x010A0058,
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_12_PACKED = 0x010C0059,

    PEAK_IPL_PIXEL_FORMAT_MONO_10_PACKED = 0x010A0046,
    PEAK_IPL_PIXEL_FORMAT_MONO_12_PACKED = 0x010C0047,

    PEAK_IPL_PIXEL_FORMAT_RGB_10_PACKED_32 = 0x0220001D,

    PEAK_IPL_PIXEL_FORMAT_BGR_10_PACKED_32 = 0x0220001E,

    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_10_GROUPED_40_IDS = 0x40000001,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_10_GROUPED_40_IDS = 0x40000002,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_10_GROUPED_40_IDS = 0x40000003,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_10_GROUPED_40_IDS = 0x40000004,
    PEAK_IPL_PIXEL_FORMAT_BAYER_RG_12_GROUPED_24_IDS = 0x40000011,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GB_12_GROUPED_24_IDS = 0x40000012,
    PEAK_IPL_PIXEL_FORMAT_BAYER_GR_12_GROUPED_24_IDS = 0x40000013,
    PEAK_IPL_PIXEL_FORMAT_BAYER_BG_12_GROUPED_24_IDS = 0x40000014,
    PEAK_IPL_PIXEL_FORMAT_MONO_10_GROUPED_40_IDS = 0x4000000f,
    PEAK_IPL_PIXEL_FORMAT_MONO_12_GROUPED_24_IDS = 0x4000001f,
};
typedef int32_t PEAK_IPL_PIXEL_FORMAT;

enum PEAK_IPL_BAYER_PATTERN_t
{
    PEAK_IPL_BAYER_PATTERN_UNKNOWN,
    PEAK_IPL_BAYER_PATTERN_NONE,
    PEAK_IPL_BAYER_PATTERN_BAYER_GR,
    PEAK_IPL_BAYER_PATTERN_BAYER_RG,
    PEAK_IPL_BAYER_PATTERN_BAYER_GB,
    PEAK_IPL_BAYER_PATTERN_BAYER_BG
};
typedef int32_t PEAK_IPL_BAYER_PATTERN;

enum PEAK_IPL_ENDIANNESS_t
{
    PEAK_IPL_ENDIANNESS_UNKNOWN,
    PEAK_IPL_ENDIANNESS_LITTLE_ENDIAN,
    PEAK_IPL_ENDIANNESS_BIG_ENDIAN
};
typedef int32_t PEAK_IPL_ENDIANNESS;

enum PEAK_IPL_ORIENTATION_t
{
    PEAK_IPL_ORIENTATION_HORIZONTAL,
    PEAK_IPL_ORIENTATION_VERTICAL
};
typedef int32_t PEAK_IPL_ORIENTATION;

enum PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_t
{
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_INVALID,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL1,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL2,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL3,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL4,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY_LEVEL5
};
typedef int32_t PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY;

enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t
{
    LIMGTYPEIMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_90_COUNTERCLOCKWISE = 90,
    LIMGTYPEIMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_90_CLOCKWISE = 270,
    LIMGTYPEIMAGE_TRANSFORMER_ROTATION_ANGLE_DEGREE_180 = 180
};
typedef uint16_t PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE;

enum PEAK_IPL_BINNINGMODE_t
{
    Average = 0,
    Sum = 1
};
typedef uint16_t PEAK_IPL_BINNINGMODE;

enum PEAK_IPL_VIDEO_CONTAINER_t
{
    PEAK_IPL_VIDEO_CONTAINER_AVI = 0
};
typedef uint16_t PEAK_IPL_VIDEO_CONTAINER;

enum PEAK_IPL_VIDEO_ENCODER_t
{
    PEAK_IPL_VIDEO_ENCODER_RAW = 0,
    PEAK_IPL_VIDEO_ENCODER_MJPEG = 1
};
typedef uint16_t PEAK_IPL_VIDEO_ENCODER;

enum PEAK_IPL_VIDEO_ENCODER_OPTION_t
{
    PEAK_IPL_VIDEO_ENCODER_OPTION_QUALITY = 0
};
typedef uint16_t PEAK_IPL_VIDEO_ENCODER_OPTION;

enum PEAK_IPL_VIDEO_CONTAINER_OPTION_t
{
    PEAK_IPL_VIDEO_CONTAINER_OPTION_FRAMERATE = 0
};
typedef uint16_t PEAK_IPL_VIDEO_CONTAINER_OPTION;

struct PEAK_IPL_POINT_2D
{
    size_t x;
    size_t y;
};

struct PEAK_IPL_SIZE_2D
{
    size_t width;
    size_t height;
};

struct PEAK_IPL_RECT_2D
{
    struct PEAK_IPL_POINT_2D position;
    struct PEAK_IPL_SIZE_2D size;
};

enum PEAK_IPL_SHARPNESS_ALGORITHM_t
{
    PEAK_IPL_SHARPNESS_ALGORITHM_TENENGRAD,
    PEAK_IPL_SHARPNESS_ALGORITHM_MEAN_SCORE,
    PEAK_IPL_SHARPNESS_ALGORITHM_HISTOGRAM_VARIANCE,
    PEAK_IPL_SHARPNESS_ALGORITHM_SOBEL
};
typedef uint16_t PEAK_IPL_SHARPNESS_ALGORITHM;

enum PEAK_IPL_SHARPNESS_ROI_WEIGHT_t
{
    PEAK_IPL_SHARPNESS_ROI_WEIGHT_WEAK = 0x0021,
    PEAK_IPL_SHARPNESS_ROI_WEIGHT_MEDIUM = 0x0042,
    PEAK_IPL_SHARPNESS_ROI_WEIGHT_STRONG = 0x0063
};
typedef uint16_t PEAK_IPL_SHARPNESS_ROI_WEIGHT;

enum PEAK_IPL_INTERPOLATION_ALGORITHM_t
{
    PEAK_IPL_INTERPOLATION_NEAREST,
    PEAK_IPL_INTERPOLATION_LINEAR,
    PEAK_IPL_INTERPOLATION_CUBIC,
    PEAK_IPL_INTERPOLATION_AREA,
    PEAK_IPL_INTERPOLATION_LANCZOS4,
    PEAK_IPL_INTERPOLATION_LINEAR_EXACT,
    PEAK_IPL_INTERPOLATION_NEAREST_EXACT
};
typedef int32_t PEAK_IPL_INTERPOLATION_ALGORITHM;

struct PEAK_IPL_SHARPNESS_ROI
{
    struct PEAK_IPL_RECT_2D rect;
    uint8_t xSamplingInterval;
    uint8_t ySamplingInterval;
    PEAK_IPL_SHARPNESS_ROI_WEIGHT weight;
};

struct PEAK_IPL_RANGE
{
    uint32_t min;
    uint32_t max;
    uint32_t inc;
};

struct PEAK_IPL_IMAGE_CONVERTER;
typedef struct PEAK_IPL_IMAGE_CONVERTER* PEAK_IPL_IMAGE_CONVERTER_HANDLE;

struct PEAK_IPL_IMAGE_transformer;
typedef struct PEAK_IPL_IMAGE_transformer* PEAK_IPL_IMAGE_TRANSFORMER_HANDLE;

struct PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR;
typedef struct PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR* PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE;

struct PEAK_IPL_BINNING;
typedef struct PEAK_IPL_BINNING* PEAK_IPL_BINNING_HANDLE;

struct PEAK_IPL_DECIMATION;
typedef struct PEAK_IPL_DECIMATION* PEAK_IPL_DECIMATION_HANDLE;

struct PEAK_IPL_COLOR_CORRECTOR;
typedef struct PEAK_IPL_COLOR_CORRECTOR* PEAK_IPL_COLOR_CORRECTOR_HANDLE;

struct PEAK_IPL_GAIN;
typedef struct PEAK_IPL_GAIN* PEAK_IPL_GAIN_HANDLE;

struct PEAK_IPL_GAMMA_CORRECTOR;
typedef struct PEAK_IPL_GAMMA_CORRECTOR* PEAK_IPL_GAMMA_CORRECTOR_HANDLE;

struct PEAK_IPL_IMAGE;
typedef struct PEAK_IPL_IMAGE* PEAK_IPL_IMAGE_HANDLE;

struct PEAK_IPL_HISTOGRAM;
typedef struct PEAK_IPL_HISTOGRAM* PEAK_IPL_HISTOGRAM_HANDLE;

struct PEAK_IPL_PIXEL_LINE;
typedef struct PEAK_IPL_PIXEL_LINE* PEAK_IPL_PIXEL_LINE_HANDLE;

struct PEAK_IPL_VIDEO;
typedef struct PEAK_IPL_VIDEO* PEAK_IPL_VIDEO_HANDLE;

struct PEAK_IPL_SHARPNESS;
typedef struct PEAK_IPL_SHARPNESS* PEAK_IPL_SHARPNESS_HANDLE;

struct PEAK_IPL_EDGE_ENHANCEMENT;
typedef struct PEAK_IPL_EDGE_ENHANCEMENT* PEAK_IPL_EDGE_ENHANCEMENT_HANDLE;


#define PEAK_IPL_C_API PEAK_IPL_NO_DISCARD PEAK_IPL_PUBLIC PEAK_IPL_RETURN_CODE PEAK_IPL_CALL_CONV

#ifndef PEAK_IPL_DYNAMIC_LOADING

PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMajor(uint32_t* libraryVersionMajor);

PEAK_IPL_C_API PEAK_IPL_Library_GetVersionMinor(uint32_t* libraryVersionMinor);

PEAK_IPL_C_API PEAK_IPL_Library_GetVersionSubminor(uint32_t* libraryVersionSubminor);

PEAK_IPL_C_API PEAK_IPL_Library_GetMaxConcurrentThreads(size_t* concurrentThreads);

PEAK_IPL_C_API PEAK_IPL_Library_SetMaxConcurrentThreads(size_t concurrentThreads);

PEAK_IPL_C_API PEAK_IPL_Library_GetMultiThreadingEnabled(PEAK_IPL_BOOL8* enabled);

PEAK_IPL_C_API PEAK_IPL_Library_SetMultiThreadingEnabled(PEAK_IPL_BOOL8 enabled);

PEAK_IPL_C_API PEAK_IPL_Library_GetSIMDEnabled(PEAK_IPL_BOOL8* enabled);

PEAK_IPL_C_API PEAK_IPL_Library_SetSIMDEnabled(PEAK_IPL_BOOL8 enabled);

PEAK_IPL_C_API PEAK_IPL_Library_GetLastError(
    PEAK_IPL_RETURN_CODE* lastErrorCode, char* lastErrorDescription, size_t* lastErrorDescriptionSize);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_Construct(PEAK_IPL_IMAGE_CONVERTER_HANDLE* imageConverterHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_Acquire(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_PreAllocateConversion(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_PIXEL_FORMAT inputPixelFormat, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, size_t width, size_t height,
    size_t imageCount);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_GetConversionMode(
    PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE* conversionMode);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_SetConversionMode(
    PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle, PEAK_IPL_CONVERSION_MODE conversionMode);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_PIXEL_FORMAT inputPixelFormat, PEAK_IPL_PIXEL_FORMAT* outputPixelFormats, size_t* outputPixelFormatsSize);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_Convert(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_ConvertToBuffer(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle,
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat, uint8_t* outputImageBuffer,
    size_t outputImageBufferSize, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageConverter_Destruct(PEAK_IPL_IMAGE_CONVERTER_HANDLE imageConverterHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Construct(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE* adaptiveHotpixelCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Acquire(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel);
PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle,
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY* sensitivityLevel);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t gainFactorPercent);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, uint32_t* gainFactorPercent);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Detect(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, struct PEAK_IPL_POINT_2D* hotpixels,
    size_t* hotpixelsSize);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Correct(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle,
    const struct PEAK_IPL_POINT_2D* hotpixels, size_t hotpixelsSize, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle,
    const struct PEAK_IPL_POINT_2D* hotpixels, size_t hotpixelsSize);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle, PEAK_IPL_IMAGE_HANDLE inputImageHandle);

PEAK_IPL_C_API PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE adaptiveHotpixelCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Construct(PEAK_IPL_COLOR_CORRECTOR_HANDLE* colorCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Acquire(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetColorCorrectionFactors(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float* colorCorrectorFactors);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetColorCorrectionFactors(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle,
    float* colorCorrectorFactors, size_t* colorCorrectorFactorsSize);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetIsPixelFormatSupported(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle,
    PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Process(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_ProcessInPlace(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_Destruct(PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturation(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float* saturation);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturationMin(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float* saturationMin);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_GetSaturationMax(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float* saturationMax);

PEAK_IPL_C_API PEAK_IPL_ColorCorrector_SetSaturation(
    PEAK_IPL_COLOR_CORRECTOR_HANDLE colorCorrectorHandle, float saturation);

PEAK_IPL_C_API PEAK_IPL_Binning_Construct(PEAK_IPL_BINNING_HANDLE* binningHandle);

PEAK_IPL_C_API PEAK_IPL_Binning_Acquire(PEAK_IPL_BINNING_HANDLE binningHandle);

PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningXValue);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningX(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningXValue);

PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningYValue);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningY(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningYValue);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMin(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningMin);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMax(PEAK_IPL_BINNING_HANDLE binningHandle, uint8_t* binningMax);

PEAK_IPL_C_API PEAK_IPL_Binning_ExpectedOutputSize(PEAK_IPL_BINNING_HANDLE binningHandle, size_t* outputWidth,
    size_t* outputHeight, size_t inputWidth, size_t inputHeight, PEAK_IPL_PIXEL_FORMAT pixelFormat);

PEAK_IPL_C_API PEAK_IPL_Binning_IsPixelformatSupported(
    PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_Binning_SetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE* mode);

PEAK_IPL_C_API PEAK_IPL_Binning_GetBinningMode(PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_BINNINGMODE* mode);

PEAK_IPL_C_API PEAK_IPL_Binning_Process(
    PEAK_IPL_BINNING_HANDLE binningHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Binning_Destruct(PEAK_IPL_BINNING_HANDLE binningHandle);

PEAK_IPL_C_API PEAK_IPL_Decimation_Construct(PEAK_IPL_DECIMATION_HANDLE* decimationHandle);

PEAK_IPL_C_API PEAK_IPL_Decimation_Acquire(PEAK_IPL_DECIMATION_HANDLE decimationHandle);

PEAK_IPL_C_API PEAK_IPL_Decimation_SetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationXValue);

PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationX(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationXValue);

PEAK_IPL_C_API PEAK_IPL_Decimation_SetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationYValue);

PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationY(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationYValue);

PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationMin(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationMin);

PEAK_IPL_C_API PEAK_IPL_Decimation_GetDecimationMax(PEAK_IPL_DECIMATION_HANDLE decimationHandle, uint8_t* decimationMax);

PEAK_IPL_C_API PEAK_IPL_Decimation_ExpectedOutputSize(PEAK_IPL_DECIMATION_HANDLE decimationHandle, size_t* outputWidth,
    size_t* outputHeight, size_t inputWidth, size_t inputHeight, PEAK_IPL_PIXEL_FORMAT pixelFormat);

PEAK_IPL_C_API PEAK_IPL_Decimation_IsPixelformatSupported(PEAK_IPL_DECIMATION_HANDLE decimationHandle,
    PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_Decimation_Process(PEAK_IPL_DECIMATION_HANDLE decimationHandle, PEAK_IPL_IMAGE_HANDLE imageHandle,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Decimation_Destruct(PEAK_IPL_DECIMATION_HANDLE decimationHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_Construct(PEAK_IPL_GAIN_HANDLE* gainHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_Acquire(PEAK_IPL_GAIN_HANDLE gainHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_SetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* masterGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* masterGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float* masterGainMax);

PEAK_IPL_C_API PEAK_IPL_Gain_GetMasterGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float* masterGainMin);

PEAK_IPL_C_API PEAK_IPL_Gain_SetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* redGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* redGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float* redGainMax);

PEAK_IPL_C_API PEAK_IPL_Gain_GetRedGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float* redGainMin);

PEAK_IPL_C_API PEAK_IPL_Gain_SetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* greenGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* greenGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float* greenGainMax);

PEAK_IPL_C_API PEAK_IPL_Gain_GetGreenGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float* greenGainMin);

PEAK_IPL_C_API PEAK_IPL_Gain_SetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* blueGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainValue(PEAK_IPL_GAIN_HANDLE gainHandle, float* blueGainValue);

PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMax(PEAK_IPL_GAIN_HANDLE gainHandle, float* blueGainMax);

PEAK_IPL_C_API PEAK_IPL_Gain_GetBlueGainMin(PEAK_IPL_GAIN_HANDLE gainHandle, float* blueGainMin);

PEAK_IPL_C_API PEAK_IPL_Gain_GetIsPixelFormatSupported(
    PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_Gain_Process(
    PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_ProcessInPlace(PEAK_IPL_GAIN_HANDLE gainHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_Gain_Destruct(PEAK_IPL_GAIN_HANDLE gainHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Construct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE* gammaCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Acquire(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* gammaValue);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* gammaValue);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* gammaMax);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, float* gammaMin);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle,
    PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Process(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_ProcessInPlace(
    PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_GammaCorrector_Destruct(PEAK_IPL_GAMMA_CORRECTOR_HANDLE gammaCorrectorHandle);

PEAK_IPL_C_API PEAK_IPL_Image_Construct(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t width, size_t height, PEAK_IPL_IMAGE_HANDLE* imageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_Acquire(PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConstructFromBuffer(PEAK_IPL_PIXEL_FORMAT pixelFormat, uint8_t* buffer, uint64_t bufferSize,
    size_t width, size_t height, PEAK_IPL_IMAGE_HANDLE* imageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_GetWidth(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t* width);

PEAK_IPL_C_API PEAK_IPL_Image_GetHeight(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t* height);

PEAK_IPL_C_API PEAK_IPL_Image_GetPixelPointer(
    PEAK_IPL_IMAGE_HANDLE imageHandle, size_t xPos, size_t yPos, uint8_t** pixelPointer);

PEAK_IPL_C_API PEAK_IPL_Image_GetByteCount(PEAK_IPL_IMAGE_HANDLE imageHandle, size_t* byteCount);

PEAK_IPL_C_API PEAK_IPL_Image_GetPixelFormat(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT* pixelFormat);

PEAK_IPL_C_API PEAK_IPL_Image_GetData(PEAK_IPL_IMAGE_HANDLE imageHandle, uint8_t** data);

PEAK_IPL_C_API PEAK_IPL_Image_Clone(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertTo(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    PEAK_IPL_CONVERSION_MODE conversionMode, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_Scale(PEAK_IPL_IMAGE_HANDLE imageHandle, const struct PEAK_IPL_SIZE_2D* size,
    PEAK_IPL_INTERPOLATION_ALGORITHM algorithm, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ScaleInto(PEAK_IPL_IMAGE_HANDLE imageHandle, const struct PEAK_IPL_SIZE_2D* size,
    uint8_t* buffer, size_t bufferSize, PEAK_IPL_INTERPOLATION_ALGORITHM algorithm);


PEAK_IPL_C_API PEAK_IPL_Image_Crop(PEAK_IPL_IMAGE_HANDLE imageHandle, const struct PEAK_IPL_POINT_2D* pos,
    const struct PEAK_IPL_SIZE_2D* size, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_ConvertToBuffer(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_PIXEL_FORMAT outputPixelFormat,
    uint8_t* outputImageBuffer, size_t outputImageBufferSize, PEAK_IPL_CONVERSION_MODE conversionMode,
    PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_Image_Destruct(PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Construct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE* imageTransformerHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Acquire(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);

PEAK_IPL_C_API PEAK_IPL_Image_SetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t timestamp_ns);

PEAK_IPL_C_API PEAK_IPL_Image_GetTimestamp(PEAK_IPL_IMAGE_HANDLE imageHandle, uint64_t* timestamp_ns);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDown(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorLeftRight(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownLeftRight(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownInPlace(
    PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorLeftRightInPlace(
    PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_MirrorUpDownLeftRightInPlace(
    PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Rotate(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle,
    enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_RotateInPlace(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle,
    PEAK_IPL_IMAGE_HANDLE imageHandle, enum PEAK_IPL_IMAGE_TRANSFORMER_ROTATION_ANGLE_t rotationAngle);

PEAK_IPL_C_API PEAK_IPL_ImageTransformer_Destruct(PEAK_IPL_IMAGE_TRANSFORMER_HANDLE imageTransformerHandle);

PEAK_IPL_C_API PEAK_IPL_Histogram_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_HISTOGRAM_HANDLE* histogramHandle);

PEAK_IPL_C_API PEAK_IPL_Histogram_Acquire(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelFormat(
    PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, PEAK_IPL_PIXEL_FORMAT* pixelFormat);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetNumChannels(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t* numChannels);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelSumForChannel(
    PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t* pixelSum);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetPixelCountForChannel(
    PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t* pixelCount);

PEAK_IPL_C_API PEAK_IPL_Histogram_GetBinsForChannel(
    PEAK_IPL_HISTOGRAM_HANDLE histogramHandle, size_t channelIndex, uint64_t* bins, size_t* binsSize);

PEAK_IPL_C_API PEAK_IPL_Histogram_Destruct(PEAK_IPL_HISTOGRAM_HANDLE histogramHandle);

PEAK_IPL_C_API PEAK_IPL_PixelLine_Construct(PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_ORIENTATION orientation,
    size_t offset, PEAK_IPL_PIXEL_LINE_HANDLE* pixelLineHandle);

PEAK_IPL_C_API PEAK_IPL_PixelLine_Acquire(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetPixelFormat(
    PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_PIXEL_FORMAT* pixelFormat);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOrientation(
    PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, PEAK_IPL_ORIENTATION* orientation);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetOffset(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t* offset);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetNumChannels(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t* numChannels);

PEAK_IPL_C_API PEAK_IPL_PixelLine_GetValuesForChannel(
    PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle, size_t channelIndex, uint32_t* values, size_t* valuesSize);

PEAK_IPL_C_API PEAK_IPL_PixelLine_Destruct(PEAK_IPL_PIXEL_LINE_HANDLE pixelLineHandle);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumChannels(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numChannels);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numSignificantBits);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numStorageBits);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, uint32_t* channelMaximumValue);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numSignificantBits);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(PEAK_IPL_PIXEL_FORMAT pixelFormat, size_t* numStorageBits);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetEndianness(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_ENDIANNESS* endianness);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(
    PEAK_IPL_PIXEL_FORMAT pixelFormat, uint64_t numPixels, uint64_t* size);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsPacked(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPacked);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsBayered(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isBayered);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_IsYUV(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isYUV);

PEAK_IPL_C_API PEAK_IPL_PixelFormat_GetBayerPattern(PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BAYER_PATTERN* pattern);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsRAW(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsBMP(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsPNG(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_WriteAsJPG(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, uint32_t quality, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageWriter_Write(
    PEAK_IPL_IMAGE_HANDLE inputImageHandle, const char* filePath, size_t filePathSize);

PEAK_IPL_C_API PEAK_IPL_ImageReader_Read(
    const char* filePath, size_t filePathSize, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_ImageReaderRead_ReadAsPixelFormat(const char* filePath, size_t filePathSize,
    PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Open(PEAK_IPL_VIDEO_HANDLE* videoHandle, const char* filePath,
    PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER encoder);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_IsOpen(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_BOOL8* isOpen);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Close(PEAK_IPL_VIDEO_HANDLE videoHandle);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_Append(PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_SetOption(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, const void* value, size_t count);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_GetOption(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void* value, size_t count, size_t* outCount);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_OptionRange(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void* min, void* max, void* inc);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer(
    PEAK_IPL_VIDEO_CONTAINER container, PEAK_IPL_VIDEO_ENCODER* encoders, size_t* size);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Container_SetOption(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_CONTAINER_OPTION option, const void* value, size_t count);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Container_GetOption(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void* value, size_t count, size_t* outCount);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Container_OptionRange(
    PEAK_IPL_VIDEO_HANDLE videoHandle, PEAK_IPL_VIDEO_ENCODER_OPTION option, void* min, void* max, void* inc);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder(
    PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_VIDEO_CONTAINER* containers, size_t* size);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats(
    PEAK_IPL_VIDEO_ENCODER encoder, PEAK_IPL_PIXEL_FORMAT* pixelFormatList, size_t* pixelFormatListSize);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetEncodedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t* numFrames);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetDroppedFrames(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t* numFrames);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_GetFileSize(PEAK_IPL_VIDEO_HANDLE videoHandle, uint64_t* fileSize);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_ResetFrameCounters(PEAK_IPL_VIDEO_HANDLE videoHandle);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_SetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t size);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetSize(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t* size);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetRange(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t* minSize, int32_t* maxSize);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Queue_GetQueued(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t* queued);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms);

PEAK_IPL_C_API PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty(PEAK_IPL_VIDEO_HANDLE videoHandle, int32_t timeout_ms);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Construct(PEAK_IPL_SHARPNESS_HANDLE* handle);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Acquire(PEAK_IPL_SHARPNESS_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Destruct(PEAK_IPL_SHARPNESS_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_Measure(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, double* calculated_value);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_PIXEL_FORMAT* pixelFormatList, size_t* pixelFormatListSize);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_SetAlgorithm(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM algorithm);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetAlgorithm(
    PEAK_IPL_SHARPNESS_HANDLE handle, PEAK_IPL_SHARPNESS_ALGORITHM* algorithm);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetROIMinimumSize(
    PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SIZE_2D* min_size);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_SetROIs(
    PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI* roiList, size_t roiListSize);

PEAK_IPL_C_API PEAK_IPL_ImageSharpness_GetROIs(
    PEAK_IPL_SHARPNESS_HANDLE handle, struct PEAK_IPL_SHARPNESS_ROI* roiList, size_t* roiListSize);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Construct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE* handle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Acquire(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Destruct(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_ProcessInPlace(
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_Process(
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_IMAGE_HANDLE imageHandle, PEAK_IPL_IMAGE_HANDLE* outputImageHandle);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetFactorRange(
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, struct PEAK_IPL_RANGE* range);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_SetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t factor);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t* factor);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_GetDefaultFactor(PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, uint32_t* factor);

PEAK_IPL_C_API PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported(
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE handle, PEAK_IPL_PIXEL_FORMAT pixelFormat, PEAK_IPL_BOOL8* isPixelFormatSupported);

#    ifdef __cplusplus
} // extern "C"
#    endif

#else
#    ifdef __cplusplus
} // extern "C"
#    endif

#    include <peak_ipl/backend/peak_ipl_dynamic_loader.h>
#endif // !PEAK_IPL_DYNAMIC_LOADING