IDS peak AFL v1.6.0
Loading...
Searching...
No Matches
peak_afl_dynamic_loader.h
Go to the documentation of this file.
1
10#pragma once
11
12#include "peak_afl.h"
13#include <string>
14#include <cstdint>
15
16#ifdef __linux__
17 #include <dlfcn.h>
18#else
19 #include <vector>
20 #include <windows.h>
21 #include <tchar.h>
22#endif
23
24#include <stdexcept>
25
26#undef PEAK_AFL_EXPORT
27#define PEAK_AFL_EXPORT
28#undef PEAK_AFL_CALLCONV
29#define PEAK_AFL_CALLCONV
30
31namespace peak
32{
33namespace afl
34{
35namespace dynamic
36{
37
38typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_Init)(void );
39typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_Exit)(void );
40typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_GetLastError)(peak_afl_status * lastErrorCode, char * lastErrorMessage, size_t * lastErrorMessageSize);
41typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_GetVersion)(uint32_t * majorVersion, uint32_t * minorVersion, uint32_t * subminorVersion, uint32_t * patchVersion);
42typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_Create)(peak_afl_manager_handle * handle, PEAK_NODE_MAP_HANDLE nodeMapHandle);
43typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_Destroy)(peak_afl_manager_handle handle);
44typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_AddController)(peak_afl_manager_handle handle, peak_afl_manager_handle controller);
45typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_RemoveController)(peak_afl_manager_handle handle, peak_afl_manager_handle controller);
46typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_Process)(peak_afl_manager_handle handle, PEAK_IPL_IMAGE_HANDLE imageHandle);
47typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_CreateController)(peak_afl_manager_handle handle, peak_afl_controller_handle * controller, peak_afl_controllerType controllerType);
48typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_DestroyAllController)(peak_afl_manager_handle handle);
49typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_DestroyController)(peak_afl_manager_handle handle, peak_afl_controller_handle controller);
50typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_SetGainIPL)(peak_afl_manager_handle handle, PEAK_IPL_GAIN_HANDLE gainHandle);
51typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoFeatureManager_Status)(peak_afl_manager_handle handle, peak_afl_BOOL8 * running);
52typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Create)(peak_afl_controller_handle * controller, peak_afl_controllerType controllerType);
53typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Destroy)(peak_afl_controller_handle controller);
54typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_SkipFrames_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
55typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_SkipFrames_Set)(peak_afl_controller_handle controller, uint32_t count);
56typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_SkipFrames_Get)(peak_afl_controller_handle controller, uint32_t * count);
57typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_SkipFrames_GetRange)(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc);
58typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_ROI_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
59typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_ROI_Set)(peak_afl_controller_handle controller, peak_afl_rectangle roi);
60typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_ROI_Get)(peak_afl_controller_handle controller, peak_afl_rectangle * roi);
61typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_ROI_Preset_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
62typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_ROI_Preset_Set)(peak_afl_controller_handle controller, peak_afl_roi_preset roiPreset);
63typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Mode_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
64typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Mode_Set)(peak_afl_controller_handle controller, peak_afl_controller_automode mode);
65typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Mode_Get)(peak_afl_controller_handle controller, peak_afl_controller_automode * mode);
66typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessAlgorithm_Set)(peak_afl_controller_handle controller, peak_afl_controller_brightness_algorithm algorithm);
67typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessAlgorithm_Get)(peak_afl_controller_handle controller, peak_afl_controller_brightness_algorithm * algorithm);
68typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessAlgorithm_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
69typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessComponent_Mode_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
70typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessComponent_Unit_IsSupported)(peak_afl_controller_handle controller, peak_afl_controller_brightness_component unit, peak_afl_BOOL8 * supported);
71typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessComponent_Mode_Set)(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_automode mode);
72typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessComponent_Mode_Get)(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_automode * mode);
73typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessComponent_Status)(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_status * status);
74typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_BrightnessComponent_Callback_Set)(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_callback_type type, void * funcPtr, void * context);
75typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_ExposureLimit_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
76typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_ExposureLimit_Set)(peak_afl_controller_handle controller, peak_afl_double_limit limit);
77typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_ExposureLimit_Get)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
78typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Status)(peak_afl_controller_handle controller, peak_afl_controller_status * status);
79typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GetLastAutoAverage)(peak_afl_controller_handle controller, uint8_t * average);
80typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GetLastAutoAverages)(peak_afl_controller_handle controller, uint8_t * averageRed, uint8_t * averageGreen, uint8_t * averageBlue);
81typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoTarget_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
82typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoTarget_Set)(peak_afl_controller_handle controller, uint32_t target);
83typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoTarget_Get)(peak_afl_controller_handle controller, uint32_t * target);
84typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoTarget_GetRange)(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc);
85typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoTolerance_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
86typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoTolerance_Set)(peak_afl_controller_handle controller, uint32_t tolerance);
87typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoTolerance_Get)(peak_afl_controller_handle controller, uint32_t * tolerance);
88typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoTolerance_GetRange)(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc);
89typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoPercentile_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
90typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoPercentile_Set)(peak_afl_controller_handle controller, double percentile);
91typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoPercentile_Get)(peak_afl_controller_handle controller, double * percentile);
92typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_AutoPercentile_GetRange)(peak_afl_controller_handle controller, double * min, double * max, double * inc);
93typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Type_Get)(peak_afl_controller_handle controller, peak_afl_controllerType * type);
94typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Algorithm_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
95typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Algorithm_Set)(peak_afl_controller_handle controller, peak_afl_controller_algorithm algorithm);
96typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Algorithm_Get)(peak_afl_controller_handle controller, peak_afl_controller_algorithm * algorithm);
97typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Algorithm_GetList)(peak_afl_controller_handle controller, peak_afl_controller_algorithm * typeList, uint32_t * listSize);
98typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_SharpnessAlgorithm_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
99typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_SharpnessAlgorithm_Set)(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm algorithm);
100typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_SharpnessAlgorithm_Get)(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm * algorithm);
101typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_SharpnessAlgorithm_GetList)(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm * typeList, uint32_t * listSize);
102typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Callback_Set)(peak_afl_controller_handle controller, peak_afl_callback_type type, void * funcPtr, void * context);
103typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Weighted_ROI_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
104typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Weighted_ROI_Min_Size)(peak_afl_controller_handle controller, peak_afl_size * size);
105typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Weighted_ROI_Set)(peak_afl_controller_handle controller, const peak_afl_weighted_rectangle * weightedRoiList, uint32_t listSize);
106typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Weighted_ROI_Get)(peak_afl_controller_handle controller, peak_afl_weighted_rectangle * weightedRoiList, uint32_t * listSize);
107typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Limit_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
108typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Limit_Default)(peak_afl_controller_handle controller, peak_afl_controller_limit * limit);
109typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Limit_Set)(peak_afl_controller_handle controller, peak_afl_controller_limit limit);
110typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Limit_Get)(peak_afl_controller_handle controller, peak_afl_controller_limit * limit);
111typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Hysteresis_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
112typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Hysteresis_Default)(peak_afl_controller_handle controller, uint8_t * hysteresis);
113typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Hysteresis_Set)(peak_afl_controller_handle controller, uint8_t hysteresis);
114typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Hysteresis_Get)(peak_afl_controller_handle controller, uint8_t * hysteresis);
115typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_Hysteresis_GetRange)(peak_afl_controller_handle controller, uint8_t * min, uint8_t * max, uint8_t * inc);
116typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainLimit_IsSupported)(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
117typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainLimit_Set)(peak_afl_controller_handle controller, peak_afl_double_limit limit);
118typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainLimit_Get)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
119typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainLimit_GetRange)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
120typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainAnalogLimit_Set)(peak_afl_controller_handle controller, peak_afl_double_limit limit);
121typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainAnalogLimit_Get)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
122typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainAnalogLimit_GetRange)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
123typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainDigitalLimit_Set)(peak_afl_controller_handle controller, peak_afl_double_limit limit);
124typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainDigitalLimit_Get)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
125typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainDigitalLimit_GetRange)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
126typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainCombinedLimit_Set)(peak_afl_controller_handle controller, peak_afl_double_limit limit);
127typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainCombinedLimit_Get)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
128typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainCombinedLimit_GetRange)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
129typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainHostLimit_Set)(peak_afl_controller_handle controller, peak_afl_double_limit limit);
130typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainHostLimit_Get)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
131typedef PEAK_AFL_API_STATUS (*dyn_peak_afl_AutoController_GainHostLimit_GetRange)(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
132
133
134class DynamicLoader
135{
136private:
137 DynamicLoader();
138
139 static DynamicLoader& instance()
140 {
141 static DynamicLoader dynamicLoader{};
142 return dynamicLoader;
143 }
144 bool loadLib(const char* file);
145 void unload();
146 bool setPointers(bool load);
147
148public:
149 ~DynamicLoader();
150
151 static bool isLoaded();
152
153 static PEAK_AFL_API_STATUS peak_afl_Init(void );
154 static PEAK_AFL_API_STATUS peak_afl_Exit(void );
155 static PEAK_AFL_API_STATUS peak_afl_GetLastError(peak_afl_status * lastErrorCode, char * lastErrorMessage, size_t * lastErrorMessageSize);
156 static PEAK_AFL_API_STATUS peak_afl_GetVersion(uint32_t * majorVersion, uint32_t * minorVersion, uint32_t * subminorVersion, uint32_t * patchVersion);
157 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_Create(peak_afl_manager_handle * handle, PEAK_NODE_MAP_HANDLE nodeMapHandle);
158 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_Destroy(peak_afl_manager_handle handle);
159 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_AddController(peak_afl_manager_handle handle, peak_afl_manager_handle controller);
160 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_RemoveController(peak_afl_manager_handle handle, peak_afl_manager_handle controller);
161 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_Process(peak_afl_manager_handle handle, PEAK_IPL_IMAGE_HANDLE imageHandle);
162 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_CreateController(peak_afl_manager_handle handle, peak_afl_controller_handle * controller, peak_afl_controllerType controllerType);
163 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_DestroyAllController(peak_afl_manager_handle handle);
164 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_DestroyController(peak_afl_manager_handle handle, peak_afl_controller_handle controller);
165 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_SetGainIPL(peak_afl_manager_handle handle, PEAK_IPL_GAIN_HANDLE gainHandle);
166 static PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_Status(peak_afl_manager_handle handle, peak_afl_BOOL8 * running);
167 static PEAK_AFL_API_STATUS peak_afl_AutoController_Create(peak_afl_controller_handle * controller, peak_afl_controllerType controllerType);
168 static PEAK_AFL_API_STATUS peak_afl_AutoController_Destroy(peak_afl_controller_handle controller);
169 static PEAK_AFL_API_STATUS peak_afl_AutoController_SkipFrames_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
170 static PEAK_AFL_API_STATUS peak_afl_AutoController_SkipFrames_Set(peak_afl_controller_handle controller, uint32_t count);
171 static PEAK_AFL_API_STATUS peak_afl_AutoController_SkipFrames_Get(peak_afl_controller_handle controller, uint32_t * count);
172 static PEAK_AFL_API_STATUS peak_afl_AutoController_SkipFrames_GetRange(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc);
173 static PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
174 static PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_Set(peak_afl_controller_handle controller, peak_afl_rectangle roi);
175 static PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_Get(peak_afl_controller_handle controller, peak_afl_rectangle * roi);
176 static PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_Preset_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
177 static PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_Preset_Set(peak_afl_controller_handle controller, peak_afl_roi_preset roiPreset);
178 static PEAK_AFL_API_STATUS peak_afl_AutoController_Mode_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
179 static PEAK_AFL_API_STATUS peak_afl_AutoController_Mode_Set(peak_afl_controller_handle controller, peak_afl_controller_automode mode);
180 static PEAK_AFL_API_STATUS peak_afl_AutoController_Mode_Get(peak_afl_controller_handle controller, peak_afl_controller_automode * mode);
181 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessAlgorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_algorithm algorithm);
182 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessAlgorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_brightness_algorithm * algorithm);
183 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessAlgorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
184 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Mode_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
185 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Unit_IsSupported(peak_afl_controller_handle controller, peak_afl_controller_brightness_component unit, peak_afl_BOOL8 * supported);
186 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Mode_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_automode mode);
187 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Mode_Get(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_automode * mode);
188 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Status(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_status * status);
189 static PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Callback_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_callback_type type, void * funcPtr, void * context);
190 static PEAK_AFL_API_STATUS peak_afl_AutoController_ExposureLimit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
191 static PEAK_AFL_API_STATUS peak_afl_AutoController_ExposureLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit);
192 static PEAK_AFL_API_STATUS peak_afl_AutoController_ExposureLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
193 static PEAK_AFL_API_STATUS peak_afl_AutoController_Status(peak_afl_controller_handle controller, peak_afl_controller_status * status);
194 static PEAK_AFL_API_STATUS peak_afl_AutoController_GetLastAutoAverage(peak_afl_controller_handle controller, uint8_t * average);
195 static PEAK_AFL_API_STATUS peak_afl_AutoController_GetLastAutoAverages(peak_afl_controller_handle controller, uint8_t * averageRed, uint8_t * averageGreen, uint8_t * averageBlue);
196 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTarget_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
197 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTarget_Set(peak_afl_controller_handle controller, uint32_t target);
198 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTarget_Get(peak_afl_controller_handle controller, uint32_t * target);
199 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTarget_GetRange(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc);
200 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTolerance_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
201 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTolerance_Set(peak_afl_controller_handle controller, uint32_t tolerance);
202 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTolerance_Get(peak_afl_controller_handle controller, uint32_t * tolerance);
203 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTolerance_GetRange(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc);
204 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoPercentile_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
205 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoPercentile_Set(peak_afl_controller_handle controller, double percentile);
206 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoPercentile_Get(peak_afl_controller_handle controller, double * percentile);
207 static PEAK_AFL_API_STATUS peak_afl_AutoController_AutoPercentile_GetRange(peak_afl_controller_handle controller, double * min, double * max, double * inc);
208 static PEAK_AFL_API_STATUS peak_afl_AutoController_Type_Get(peak_afl_controller_handle controller, peak_afl_controllerType * type);
209 static PEAK_AFL_API_STATUS peak_afl_AutoController_Algorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
210 static PEAK_AFL_API_STATUS peak_afl_AutoController_Algorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_algorithm algorithm);
211 static PEAK_AFL_API_STATUS peak_afl_AutoController_Algorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_algorithm * algorithm);
212 static PEAK_AFL_API_STATUS peak_afl_AutoController_Algorithm_GetList(peak_afl_controller_handle controller, peak_afl_controller_algorithm * typeList, uint32_t * listSize);
213 static PEAK_AFL_API_STATUS peak_afl_AutoController_SharpnessAlgorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
214 static PEAK_AFL_API_STATUS peak_afl_AutoController_SharpnessAlgorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm algorithm);
215 static PEAK_AFL_API_STATUS peak_afl_AutoController_SharpnessAlgorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm * algorithm);
216 static PEAK_AFL_API_STATUS peak_afl_AutoController_SharpnessAlgorithm_GetList(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm * typeList, uint32_t * listSize);
217 static PEAK_AFL_API_STATUS peak_afl_AutoController_Callback_Set(peak_afl_controller_handle controller, peak_afl_callback_type type, void * funcPtr, void * context);
218 static PEAK_AFL_API_STATUS peak_afl_AutoController_Weighted_ROI_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
219 static PEAK_AFL_API_STATUS peak_afl_AutoController_Weighted_ROI_Min_Size(peak_afl_controller_handle controller, peak_afl_size * size);
220 static PEAK_AFL_API_STATUS peak_afl_AutoController_Weighted_ROI_Set(peak_afl_controller_handle controller, const peak_afl_weighted_rectangle * weightedRoiList, uint32_t listSize);
221 static PEAK_AFL_API_STATUS peak_afl_AutoController_Weighted_ROI_Get(peak_afl_controller_handle controller, peak_afl_weighted_rectangle * weightedRoiList, uint32_t * listSize);
222 static PEAK_AFL_API_STATUS peak_afl_AutoController_Limit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
223 static PEAK_AFL_API_STATUS peak_afl_AutoController_Limit_Default(peak_afl_controller_handle controller, peak_afl_controller_limit * limit);
224 static PEAK_AFL_API_STATUS peak_afl_AutoController_Limit_Set(peak_afl_controller_handle controller, peak_afl_controller_limit limit);
225 static PEAK_AFL_API_STATUS peak_afl_AutoController_Limit_Get(peak_afl_controller_handle controller, peak_afl_controller_limit * limit);
226 static PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
227 static PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_Default(peak_afl_controller_handle controller, uint8_t * hysteresis);
228 static PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_Set(peak_afl_controller_handle controller, uint8_t hysteresis);
229 static PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_Get(peak_afl_controller_handle controller, uint8_t * hysteresis);
230 static PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_GetRange(peak_afl_controller_handle controller, uint8_t * min, uint8_t * max, uint8_t * inc);
231 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainLimit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported);
232 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit);
233 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
234 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
235 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainAnalogLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit);
236 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainAnalogLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
237 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainAnalogLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
238 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainDigitalLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit);
239 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainDigitalLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
240 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainDigitalLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
241 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainCombinedLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit);
242 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainCombinedLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
243 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainCombinedLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
244 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainHostLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit);
245 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainHostLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
246 static PEAK_AFL_API_STATUS peak_afl_AutoController_GainHostLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit);
247
248private:
249 void* m_handle = nullptr;
250 dyn_peak_afl_Init m_peak_afl_Init{};
251 dyn_peak_afl_Exit m_peak_afl_Exit{};
252 dyn_peak_afl_GetLastError m_peak_afl_GetLastError{};
253 dyn_peak_afl_GetVersion m_peak_afl_GetVersion{};
254 dyn_peak_afl_AutoFeatureManager_Create m_peak_afl_AutoFeatureManager_Create{};
255 dyn_peak_afl_AutoFeatureManager_Destroy m_peak_afl_AutoFeatureManager_Destroy{};
256 dyn_peak_afl_AutoFeatureManager_AddController m_peak_afl_AutoFeatureManager_AddController{};
257 dyn_peak_afl_AutoFeatureManager_RemoveController m_peak_afl_AutoFeatureManager_RemoveController{};
258 dyn_peak_afl_AutoFeatureManager_Process m_peak_afl_AutoFeatureManager_Process{};
259 dyn_peak_afl_AutoFeatureManager_CreateController m_peak_afl_AutoFeatureManager_CreateController{};
260 dyn_peak_afl_AutoFeatureManager_DestroyAllController m_peak_afl_AutoFeatureManager_DestroyAllController{};
261 dyn_peak_afl_AutoFeatureManager_DestroyController m_peak_afl_AutoFeatureManager_DestroyController{};
262 dyn_peak_afl_AutoFeatureManager_SetGainIPL m_peak_afl_AutoFeatureManager_SetGainIPL{};
263 dyn_peak_afl_AutoFeatureManager_Status m_peak_afl_AutoFeatureManager_Status{};
264 dyn_peak_afl_AutoController_Create m_peak_afl_AutoController_Create{};
265 dyn_peak_afl_AutoController_Destroy m_peak_afl_AutoController_Destroy{};
266 dyn_peak_afl_AutoController_SkipFrames_IsSupported m_peak_afl_AutoController_SkipFrames_IsSupported{};
267 dyn_peak_afl_AutoController_SkipFrames_Set m_peak_afl_AutoController_SkipFrames_Set{};
268 dyn_peak_afl_AutoController_SkipFrames_Get m_peak_afl_AutoController_SkipFrames_Get{};
269 dyn_peak_afl_AutoController_SkipFrames_GetRange m_peak_afl_AutoController_SkipFrames_GetRange{};
270 dyn_peak_afl_AutoController_ROI_IsSupported m_peak_afl_AutoController_ROI_IsSupported{};
271 dyn_peak_afl_AutoController_ROI_Set m_peak_afl_AutoController_ROI_Set{};
272 dyn_peak_afl_AutoController_ROI_Get m_peak_afl_AutoController_ROI_Get{};
273 dyn_peak_afl_AutoController_ROI_Preset_IsSupported m_peak_afl_AutoController_ROI_Preset_IsSupported{};
274 dyn_peak_afl_AutoController_ROI_Preset_Set m_peak_afl_AutoController_ROI_Preset_Set{};
275 dyn_peak_afl_AutoController_Mode_IsSupported m_peak_afl_AutoController_Mode_IsSupported{};
276 dyn_peak_afl_AutoController_Mode_Set m_peak_afl_AutoController_Mode_Set{};
277 dyn_peak_afl_AutoController_Mode_Get m_peak_afl_AutoController_Mode_Get{};
278 dyn_peak_afl_AutoController_BrightnessAlgorithm_Set m_peak_afl_AutoController_BrightnessAlgorithm_Set{};
279 dyn_peak_afl_AutoController_BrightnessAlgorithm_Get m_peak_afl_AutoController_BrightnessAlgorithm_Get{};
280 dyn_peak_afl_AutoController_BrightnessAlgorithm_IsSupported m_peak_afl_AutoController_BrightnessAlgorithm_IsSupported{};
281 dyn_peak_afl_AutoController_BrightnessComponent_Mode_IsSupported m_peak_afl_AutoController_BrightnessComponent_Mode_IsSupported{};
282 dyn_peak_afl_AutoController_BrightnessComponent_Unit_IsSupported m_peak_afl_AutoController_BrightnessComponent_Unit_IsSupported{};
283 dyn_peak_afl_AutoController_BrightnessComponent_Mode_Set m_peak_afl_AutoController_BrightnessComponent_Mode_Set{};
284 dyn_peak_afl_AutoController_BrightnessComponent_Mode_Get m_peak_afl_AutoController_BrightnessComponent_Mode_Get{};
285 dyn_peak_afl_AutoController_BrightnessComponent_Status m_peak_afl_AutoController_BrightnessComponent_Status{};
286 dyn_peak_afl_AutoController_BrightnessComponent_Callback_Set m_peak_afl_AutoController_BrightnessComponent_Callback_Set{};
287 dyn_peak_afl_AutoController_ExposureLimit_IsSupported m_peak_afl_AutoController_ExposureLimit_IsSupported{};
288 dyn_peak_afl_AutoController_ExposureLimit_Set m_peak_afl_AutoController_ExposureLimit_Set{};
289 dyn_peak_afl_AutoController_ExposureLimit_Get m_peak_afl_AutoController_ExposureLimit_Get{};
290 dyn_peak_afl_AutoController_Status m_peak_afl_AutoController_Status{};
291 dyn_peak_afl_AutoController_GetLastAutoAverage m_peak_afl_AutoController_GetLastAutoAverage{};
292 dyn_peak_afl_AutoController_GetLastAutoAverages m_peak_afl_AutoController_GetLastAutoAverages{};
293 dyn_peak_afl_AutoController_AutoTarget_IsSupported m_peak_afl_AutoController_AutoTarget_IsSupported{};
294 dyn_peak_afl_AutoController_AutoTarget_Set m_peak_afl_AutoController_AutoTarget_Set{};
295 dyn_peak_afl_AutoController_AutoTarget_Get m_peak_afl_AutoController_AutoTarget_Get{};
296 dyn_peak_afl_AutoController_AutoTarget_GetRange m_peak_afl_AutoController_AutoTarget_GetRange{};
297 dyn_peak_afl_AutoController_AutoTolerance_IsSupported m_peak_afl_AutoController_AutoTolerance_IsSupported{};
298 dyn_peak_afl_AutoController_AutoTolerance_Set m_peak_afl_AutoController_AutoTolerance_Set{};
299 dyn_peak_afl_AutoController_AutoTolerance_Get m_peak_afl_AutoController_AutoTolerance_Get{};
300 dyn_peak_afl_AutoController_AutoTolerance_GetRange m_peak_afl_AutoController_AutoTolerance_GetRange{};
301 dyn_peak_afl_AutoController_AutoPercentile_IsSupported m_peak_afl_AutoController_AutoPercentile_IsSupported{};
302 dyn_peak_afl_AutoController_AutoPercentile_Set m_peak_afl_AutoController_AutoPercentile_Set{};
303 dyn_peak_afl_AutoController_AutoPercentile_Get m_peak_afl_AutoController_AutoPercentile_Get{};
304 dyn_peak_afl_AutoController_AutoPercentile_GetRange m_peak_afl_AutoController_AutoPercentile_GetRange{};
305 dyn_peak_afl_AutoController_Type_Get m_peak_afl_AutoController_Type_Get{};
306 dyn_peak_afl_AutoController_Algorithm_IsSupported m_peak_afl_AutoController_Algorithm_IsSupported{};
307 dyn_peak_afl_AutoController_Algorithm_Set m_peak_afl_AutoController_Algorithm_Set{};
308 dyn_peak_afl_AutoController_Algorithm_Get m_peak_afl_AutoController_Algorithm_Get{};
309 dyn_peak_afl_AutoController_Algorithm_GetList m_peak_afl_AutoController_Algorithm_GetList{};
310 dyn_peak_afl_AutoController_SharpnessAlgorithm_IsSupported m_peak_afl_AutoController_SharpnessAlgorithm_IsSupported{};
311 dyn_peak_afl_AutoController_SharpnessAlgorithm_Set m_peak_afl_AutoController_SharpnessAlgorithm_Set{};
312 dyn_peak_afl_AutoController_SharpnessAlgorithm_Get m_peak_afl_AutoController_SharpnessAlgorithm_Get{};
313 dyn_peak_afl_AutoController_SharpnessAlgorithm_GetList m_peak_afl_AutoController_SharpnessAlgorithm_GetList{};
314 dyn_peak_afl_AutoController_Callback_Set m_peak_afl_AutoController_Callback_Set{};
315 dyn_peak_afl_AutoController_Weighted_ROI_IsSupported m_peak_afl_AutoController_Weighted_ROI_IsSupported{};
316 dyn_peak_afl_AutoController_Weighted_ROI_Min_Size m_peak_afl_AutoController_Weighted_ROI_Min_Size{};
317 dyn_peak_afl_AutoController_Weighted_ROI_Set m_peak_afl_AutoController_Weighted_ROI_Set{};
318 dyn_peak_afl_AutoController_Weighted_ROI_Get m_peak_afl_AutoController_Weighted_ROI_Get{};
319 dyn_peak_afl_AutoController_Limit_IsSupported m_peak_afl_AutoController_Limit_IsSupported{};
320 dyn_peak_afl_AutoController_Limit_Default m_peak_afl_AutoController_Limit_Default{};
321 dyn_peak_afl_AutoController_Limit_Set m_peak_afl_AutoController_Limit_Set{};
322 dyn_peak_afl_AutoController_Limit_Get m_peak_afl_AutoController_Limit_Get{};
323 dyn_peak_afl_AutoController_Hysteresis_IsSupported m_peak_afl_AutoController_Hysteresis_IsSupported{};
324 dyn_peak_afl_AutoController_Hysteresis_Default m_peak_afl_AutoController_Hysteresis_Default{};
325 dyn_peak_afl_AutoController_Hysteresis_Set m_peak_afl_AutoController_Hysteresis_Set{};
326 dyn_peak_afl_AutoController_Hysteresis_Get m_peak_afl_AutoController_Hysteresis_Get{};
327 dyn_peak_afl_AutoController_Hysteresis_GetRange m_peak_afl_AutoController_Hysteresis_GetRange{};
328 dyn_peak_afl_AutoController_GainLimit_IsSupported m_peak_afl_AutoController_GainLimit_IsSupported{};
329 dyn_peak_afl_AutoController_GainLimit_Set m_peak_afl_AutoController_GainLimit_Set{};
330 dyn_peak_afl_AutoController_GainLimit_Get m_peak_afl_AutoController_GainLimit_Get{};
331 dyn_peak_afl_AutoController_GainLimit_GetRange m_peak_afl_AutoController_GainLimit_GetRange{};
332 dyn_peak_afl_AutoController_GainAnalogLimit_Set m_peak_afl_AutoController_GainAnalogLimit_Set{};
333 dyn_peak_afl_AutoController_GainAnalogLimit_Get m_peak_afl_AutoController_GainAnalogLimit_Get{};
334 dyn_peak_afl_AutoController_GainAnalogLimit_GetRange m_peak_afl_AutoController_GainAnalogLimit_GetRange{};
335 dyn_peak_afl_AutoController_GainDigitalLimit_Set m_peak_afl_AutoController_GainDigitalLimit_Set{};
336 dyn_peak_afl_AutoController_GainDigitalLimit_Get m_peak_afl_AutoController_GainDigitalLimit_Get{};
337 dyn_peak_afl_AutoController_GainDigitalLimit_GetRange m_peak_afl_AutoController_GainDigitalLimit_GetRange{};
338 dyn_peak_afl_AutoController_GainCombinedLimit_Set m_peak_afl_AutoController_GainCombinedLimit_Set{};
339 dyn_peak_afl_AutoController_GainCombinedLimit_Get m_peak_afl_AutoController_GainCombinedLimit_Get{};
340 dyn_peak_afl_AutoController_GainCombinedLimit_GetRange m_peak_afl_AutoController_GainCombinedLimit_GetRange{};
341 dyn_peak_afl_AutoController_GainHostLimit_Set m_peak_afl_AutoController_GainHostLimit_Set{};
342 dyn_peak_afl_AutoController_GainHostLimit_Get m_peak_afl_AutoController_GainHostLimit_Get{};
343 dyn_peak_afl_AutoController_GainHostLimit_GetRange m_peak_afl_AutoController_GainHostLimit_GetRange{};
344
345};
346
347inline void* import_function(void *module, const char* proc_name)
348{
349#ifdef __linux__
350 return dlsym(module, proc_name);
351#else
352 return GetProcAddress(static_cast<HMODULE>(module), proc_name);
353#endif
354}
355
356inline DynamicLoader::DynamicLoader()
357{
358#if defined _WIN32 || defined _WIN64
359 size_t sz = 0;
360 if (_wgetenv_s(&sz, NULL, 0, L"IDS_PEAK_GENERIC_SDK_PATH") == 0
361 && sz > 0)
362 {
363 std::vector<wchar_t> env_ids_peak_afl(sz);
364 if (_wgetenv_s(&sz, env_ids_peak_afl.data(), sz, L"IDS_PEAK_GENERIC_SDK_PATH") == 0)
365 {
366 if (_wgetenv_s(&sz, NULL, 0, L"PATH") == 0
367 && sz > 0)
368 {
369 std::vector<wchar_t> env_path(sz);
370 if (_wgetenv_s(&sz, env_path.data(), sz, L"PATH") == 0)
371 {
372 std::wstring ids_peak_afl_path(env_ids_peak_afl.data());
373#ifdef _WIN64
374 ids_peak_afl_path.append(L"\\afl\\lib\\x86_64");
375#else
376 ids_peak_afl_path.append(L"\\afl\\lib\\x86_32");
377#endif
378 AddDllDirectory(ids_peak_afl_path.c_str());
379 }
380 }
381 }
382 }
383
384 loadLib("ids_peak_afl.dll");
385#else
386 loadLib("libids_peak_afl.so");
387#endif
388}
389
390inline DynamicLoader::~DynamicLoader()
391{
392 if(m_handle != nullptr)
393 {
394 unload();
395 }
396}
397
398inline bool DynamicLoader::isLoaded()
399{
400 auto&& inst = instance();
401 return inst.m_handle != nullptr;
402}
403
404inline void DynamicLoader::unload()
405{
406 setPointers(false);
407
408 if (m_handle != nullptr)
409 {
410#ifdef __linux__
411 dlclose(m_handle);
412#else
413 FreeLibrary(static_cast<HMODULE>(m_handle));
414#endif
415 }
416 m_handle = nullptr;
417}
418
419
420inline bool DynamicLoader::loadLib(const char* file)
421{
422 bool ret = false;
423
424 if (file)
425 {
426#ifdef __linux__
427 m_handle = dlopen(file, RTLD_NOW);
428#else
429 m_handle = LoadLibraryExA(file, nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
430#endif
431 if (m_handle != nullptr)
432 {
433 try {
434 setPointers(true);
435 ret = true;
436 } catch (const std::exception&) {
437 unload();
438 throw;
439 }
440 }
441 else
442 {
443 throw std::runtime_error(std::string("Lib load failed: ") + file);
444 }
445 }
446 else
447 {
448 throw std::runtime_error("Filename empty");
449 }
450
451 return ret;
452}
453
454inline bool DynamicLoader::setPointers(bool load)
455{
456
457 m_peak_afl_Init = (dyn_peak_afl_Init) (load ? import_function(m_handle, "peak_afl_Init") : nullptr);
458 if(m_peak_afl_Init == nullptr && load)
459 {
460 throw std::runtime_error("Failed to load peak_afl_Init");
461 }
462
463 m_peak_afl_Exit = (dyn_peak_afl_Exit) (load ? import_function(m_handle, "peak_afl_Exit") : nullptr);
464 if(m_peak_afl_Exit == nullptr && load)
465 {
466 throw std::runtime_error("Failed to load peak_afl_Exit");
467 }
468
469 m_peak_afl_GetLastError = (dyn_peak_afl_GetLastError) (load ? import_function(m_handle, "peak_afl_GetLastError") : nullptr);
470 if(m_peak_afl_GetLastError == nullptr && load)
471 {
472 throw std::runtime_error("Failed to load peak_afl_GetLastError");
473 }
474
475 m_peak_afl_GetVersion = (dyn_peak_afl_GetVersion) (load ? import_function(m_handle, "peak_afl_GetVersion") : nullptr);
476 if(m_peak_afl_GetVersion == nullptr && load)
477 {
478 throw std::runtime_error("Failed to load peak_afl_GetVersion");
479 }
480
481 m_peak_afl_AutoFeatureManager_Create = (dyn_peak_afl_AutoFeatureManager_Create) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_Create") : nullptr);
482 if(m_peak_afl_AutoFeatureManager_Create == nullptr && load)
483 {
484 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_Create");
485 }
486
487 m_peak_afl_AutoFeatureManager_Destroy = (dyn_peak_afl_AutoFeatureManager_Destroy) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_Destroy") : nullptr);
488 if(m_peak_afl_AutoFeatureManager_Destroy == nullptr && load)
489 {
490 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_Destroy");
491 }
492
493 m_peak_afl_AutoFeatureManager_AddController = (dyn_peak_afl_AutoFeatureManager_AddController) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_AddController") : nullptr);
494 if(m_peak_afl_AutoFeatureManager_AddController == nullptr && load)
495 {
496 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_AddController");
497 }
498
499 m_peak_afl_AutoFeatureManager_RemoveController = (dyn_peak_afl_AutoFeatureManager_RemoveController) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_RemoveController") : nullptr);
500 if(m_peak_afl_AutoFeatureManager_RemoveController == nullptr && load)
501 {
502 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_RemoveController");
503 }
504
505 m_peak_afl_AutoFeatureManager_Process = (dyn_peak_afl_AutoFeatureManager_Process) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_Process") : nullptr);
506 if(m_peak_afl_AutoFeatureManager_Process == nullptr && load)
507 {
508 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_Process");
509 }
510
511 m_peak_afl_AutoFeatureManager_CreateController = (dyn_peak_afl_AutoFeatureManager_CreateController) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_CreateController") : nullptr);
512 if(m_peak_afl_AutoFeatureManager_CreateController == nullptr && load)
513 {
514 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_CreateController");
515 }
516
517 m_peak_afl_AutoFeatureManager_DestroyAllController = (dyn_peak_afl_AutoFeatureManager_DestroyAllController) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_DestroyAllController") : nullptr);
518 if(m_peak_afl_AutoFeatureManager_DestroyAllController == nullptr && load)
519 {
520 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_DestroyAllController");
521 }
522
523 m_peak_afl_AutoFeatureManager_DestroyController = (dyn_peak_afl_AutoFeatureManager_DestroyController) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_DestroyController") : nullptr);
524 if(m_peak_afl_AutoFeatureManager_DestroyController == nullptr && load)
525 {
526 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_DestroyController");
527 }
528
529 m_peak_afl_AutoFeatureManager_SetGainIPL = (dyn_peak_afl_AutoFeatureManager_SetGainIPL) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_SetGainIPL") : nullptr);
530 if(m_peak_afl_AutoFeatureManager_SetGainIPL == nullptr && load)
531 {
532 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_SetGainIPL");
533 }
534
535 m_peak_afl_AutoFeatureManager_Status = (dyn_peak_afl_AutoFeatureManager_Status) (load ? import_function(m_handle, "peak_afl_AutoFeatureManager_Status") : nullptr);
536 if(m_peak_afl_AutoFeatureManager_Status == nullptr && load)
537 {
538 throw std::runtime_error("Failed to load peak_afl_AutoFeatureManager_Status");
539 }
540
541 m_peak_afl_AutoController_Create = (dyn_peak_afl_AutoController_Create) (load ? import_function(m_handle, "peak_afl_AutoController_Create") : nullptr);
542 if(m_peak_afl_AutoController_Create == nullptr && load)
543 {
544 throw std::runtime_error("Failed to load peak_afl_AutoController_Create");
545 }
546
547 m_peak_afl_AutoController_Destroy = (dyn_peak_afl_AutoController_Destroy) (load ? import_function(m_handle, "peak_afl_AutoController_Destroy") : nullptr);
548 if(m_peak_afl_AutoController_Destroy == nullptr && load)
549 {
550 throw std::runtime_error("Failed to load peak_afl_AutoController_Destroy");
551 }
552
553 m_peak_afl_AutoController_SkipFrames_IsSupported = (dyn_peak_afl_AutoController_SkipFrames_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_SkipFrames_IsSupported") : nullptr);
554 if(m_peak_afl_AutoController_SkipFrames_IsSupported == nullptr && load)
555 {
556 throw std::runtime_error("Failed to load peak_afl_AutoController_SkipFrames_IsSupported");
557 }
558
559 m_peak_afl_AutoController_SkipFrames_Set = (dyn_peak_afl_AutoController_SkipFrames_Set) (load ? import_function(m_handle, "peak_afl_AutoController_SkipFrames_Set") : nullptr);
560 if(m_peak_afl_AutoController_SkipFrames_Set == nullptr && load)
561 {
562 throw std::runtime_error("Failed to load peak_afl_AutoController_SkipFrames_Set");
563 }
564
565 m_peak_afl_AutoController_SkipFrames_Get = (dyn_peak_afl_AutoController_SkipFrames_Get) (load ? import_function(m_handle, "peak_afl_AutoController_SkipFrames_Get") : nullptr);
566 if(m_peak_afl_AutoController_SkipFrames_Get == nullptr && load)
567 {
568 throw std::runtime_error("Failed to load peak_afl_AutoController_SkipFrames_Get");
569 }
570
571 m_peak_afl_AutoController_SkipFrames_GetRange = (dyn_peak_afl_AutoController_SkipFrames_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_SkipFrames_GetRange") : nullptr);
572 if(m_peak_afl_AutoController_SkipFrames_GetRange == nullptr && load)
573 {
574 throw std::runtime_error("Failed to load peak_afl_AutoController_SkipFrames_GetRange");
575 }
576
577 m_peak_afl_AutoController_ROI_IsSupported = (dyn_peak_afl_AutoController_ROI_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_ROI_IsSupported") : nullptr);
578 if(m_peak_afl_AutoController_ROI_IsSupported == nullptr && load)
579 {
580 throw std::runtime_error("Failed to load peak_afl_AutoController_ROI_IsSupported");
581 }
582
583 m_peak_afl_AutoController_ROI_Set = (dyn_peak_afl_AutoController_ROI_Set) (load ? import_function(m_handle, "peak_afl_AutoController_ROI_Set") : nullptr);
584 if(m_peak_afl_AutoController_ROI_Set == nullptr && load)
585 {
586 throw std::runtime_error("Failed to load peak_afl_AutoController_ROI_Set");
587 }
588
589 m_peak_afl_AutoController_ROI_Get = (dyn_peak_afl_AutoController_ROI_Get) (load ? import_function(m_handle, "peak_afl_AutoController_ROI_Get") : nullptr);
590 if(m_peak_afl_AutoController_ROI_Get == nullptr && load)
591 {
592 throw std::runtime_error("Failed to load peak_afl_AutoController_ROI_Get");
593 }
594
595 m_peak_afl_AutoController_ROI_Preset_IsSupported = (dyn_peak_afl_AutoController_ROI_Preset_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_ROI_Preset_IsSupported") : nullptr);
596 if(m_peak_afl_AutoController_ROI_Preset_IsSupported == nullptr && load)
597 {
598 throw std::runtime_error("Failed to load peak_afl_AutoController_ROI_Preset_IsSupported");
599 }
600
601 m_peak_afl_AutoController_ROI_Preset_Set = (dyn_peak_afl_AutoController_ROI_Preset_Set) (load ? import_function(m_handle, "peak_afl_AutoController_ROI_Preset_Set") : nullptr);
602 if(m_peak_afl_AutoController_ROI_Preset_Set == nullptr && load)
603 {
604 throw std::runtime_error("Failed to load peak_afl_AutoController_ROI_Preset_Set");
605 }
606
607 m_peak_afl_AutoController_Mode_IsSupported = (dyn_peak_afl_AutoController_Mode_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_Mode_IsSupported") : nullptr);
608 if(m_peak_afl_AutoController_Mode_IsSupported == nullptr && load)
609 {
610 throw std::runtime_error("Failed to load peak_afl_AutoController_Mode_IsSupported");
611 }
612
613 m_peak_afl_AutoController_Mode_Set = (dyn_peak_afl_AutoController_Mode_Set) (load ? import_function(m_handle, "peak_afl_AutoController_Mode_Set") : nullptr);
614 if(m_peak_afl_AutoController_Mode_Set == nullptr && load)
615 {
616 throw std::runtime_error("Failed to load peak_afl_AutoController_Mode_Set");
617 }
618
619 m_peak_afl_AutoController_Mode_Get = (dyn_peak_afl_AutoController_Mode_Get) (load ? import_function(m_handle, "peak_afl_AutoController_Mode_Get") : nullptr);
620 if(m_peak_afl_AutoController_Mode_Get == nullptr && load)
621 {
622 throw std::runtime_error("Failed to load peak_afl_AutoController_Mode_Get");
623 }
624
625 m_peak_afl_AutoController_BrightnessAlgorithm_Set = (dyn_peak_afl_AutoController_BrightnessAlgorithm_Set) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessAlgorithm_Set") : nullptr);
626 if(m_peak_afl_AutoController_BrightnessAlgorithm_Set == nullptr && load)
627 {
628 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessAlgorithm_Set");
629 }
630
631 m_peak_afl_AutoController_BrightnessAlgorithm_Get = (dyn_peak_afl_AutoController_BrightnessAlgorithm_Get) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessAlgorithm_Get") : nullptr);
632 if(m_peak_afl_AutoController_BrightnessAlgorithm_Get == nullptr && load)
633 {
634 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessAlgorithm_Get");
635 }
636
637 m_peak_afl_AutoController_BrightnessAlgorithm_IsSupported = (dyn_peak_afl_AutoController_BrightnessAlgorithm_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessAlgorithm_IsSupported") : nullptr);
638 if(m_peak_afl_AutoController_BrightnessAlgorithm_IsSupported == nullptr && load)
639 {
640 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessAlgorithm_IsSupported");
641 }
642
643 m_peak_afl_AutoController_BrightnessComponent_Mode_IsSupported = (dyn_peak_afl_AutoController_BrightnessComponent_Mode_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessComponent_Mode_IsSupported") : nullptr);
644 if(m_peak_afl_AutoController_BrightnessComponent_Mode_IsSupported == nullptr && load)
645 {
646 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessComponent_Mode_IsSupported");
647 }
648
649 m_peak_afl_AutoController_BrightnessComponent_Unit_IsSupported = (dyn_peak_afl_AutoController_BrightnessComponent_Unit_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessComponent_Unit_IsSupported") : nullptr);
650 if(m_peak_afl_AutoController_BrightnessComponent_Unit_IsSupported == nullptr && load)
651 {
652 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessComponent_Unit_IsSupported");
653 }
654
655 m_peak_afl_AutoController_BrightnessComponent_Mode_Set = (dyn_peak_afl_AutoController_BrightnessComponent_Mode_Set) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessComponent_Mode_Set") : nullptr);
656 if(m_peak_afl_AutoController_BrightnessComponent_Mode_Set == nullptr && load)
657 {
658 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessComponent_Mode_Set");
659 }
660
661 m_peak_afl_AutoController_BrightnessComponent_Mode_Get = (dyn_peak_afl_AutoController_BrightnessComponent_Mode_Get) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessComponent_Mode_Get") : nullptr);
662 if(m_peak_afl_AutoController_BrightnessComponent_Mode_Get == nullptr && load)
663 {
664 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessComponent_Mode_Get");
665 }
666
667 m_peak_afl_AutoController_BrightnessComponent_Status = (dyn_peak_afl_AutoController_BrightnessComponent_Status) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessComponent_Status") : nullptr);
668 if(m_peak_afl_AutoController_BrightnessComponent_Status == nullptr && load)
669 {
670 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessComponent_Status");
671 }
672
673 m_peak_afl_AutoController_BrightnessComponent_Callback_Set = (dyn_peak_afl_AutoController_BrightnessComponent_Callback_Set) (load ? import_function(m_handle, "peak_afl_AutoController_BrightnessComponent_Callback_Set") : nullptr);
674 if(m_peak_afl_AutoController_BrightnessComponent_Callback_Set == nullptr && load)
675 {
676 throw std::runtime_error("Failed to load peak_afl_AutoController_BrightnessComponent_Callback_Set");
677 }
678
679 m_peak_afl_AutoController_ExposureLimit_IsSupported = (dyn_peak_afl_AutoController_ExposureLimit_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_ExposureLimit_IsSupported") : nullptr);
680 if(m_peak_afl_AutoController_ExposureLimit_IsSupported == nullptr && load)
681 {
682 throw std::runtime_error("Failed to load peak_afl_AutoController_ExposureLimit_IsSupported");
683 }
684
685 m_peak_afl_AutoController_ExposureLimit_Set = (dyn_peak_afl_AutoController_ExposureLimit_Set) (load ? import_function(m_handle, "peak_afl_AutoController_ExposureLimit_Set") : nullptr);
686 if(m_peak_afl_AutoController_ExposureLimit_Set == nullptr && load)
687 {
688 throw std::runtime_error("Failed to load peak_afl_AutoController_ExposureLimit_Set");
689 }
690
691 m_peak_afl_AutoController_ExposureLimit_Get = (dyn_peak_afl_AutoController_ExposureLimit_Get) (load ? import_function(m_handle, "peak_afl_AutoController_ExposureLimit_Get") : nullptr);
692 if(m_peak_afl_AutoController_ExposureLimit_Get == nullptr && load)
693 {
694 throw std::runtime_error("Failed to load peak_afl_AutoController_ExposureLimit_Get");
695 }
696
697 m_peak_afl_AutoController_Status = (dyn_peak_afl_AutoController_Status) (load ? import_function(m_handle, "peak_afl_AutoController_Status") : nullptr);
698 if(m_peak_afl_AutoController_Status == nullptr && load)
699 {
700 throw std::runtime_error("Failed to load peak_afl_AutoController_Status");
701 }
702
703 m_peak_afl_AutoController_GetLastAutoAverage = (dyn_peak_afl_AutoController_GetLastAutoAverage) (load ? import_function(m_handle, "peak_afl_AutoController_GetLastAutoAverage") : nullptr);
704 if(m_peak_afl_AutoController_GetLastAutoAverage == nullptr && load)
705 {
706 throw std::runtime_error("Failed to load peak_afl_AutoController_GetLastAutoAverage");
707 }
708
709 m_peak_afl_AutoController_GetLastAutoAverages = (dyn_peak_afl_AutoController_GetLastAutoAverages) (load ? import_function(m_handle, "peak_afl_AutoController_GetLastAutoAverages") : nullptr);
710 if(m_peak_afl_AutoController_GetLastAutoAverages == nullptr && load)
711 {
712 throw std::runtime_error("Failed to load peak_afl_AutoController_GetLastAutoAverages");
713 }
714
715 m_peak_afl_AutoController_AutoTarget_IsSupported = (dyn_peak_afl_AutoController_AutoTarget_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_AutoTarget_IsSupported") : nullptr);
716 if(m_peak_afl_AutoController_AutoTarget_IsSupported == nullptr && load)
717 {
718 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoTarget_IsSupported");
719 }
720
721 m_peak_afl_AutoController_AutoTarget_Set = (dyn_peak_afl_AutoController_AutoTarget_Set) (load ? import_function(m_handle, "peak_afl_AutoController_AutoTarget_Set") : nullptr);
722 if(m_peak_afl_AutoController_AutoTarget_Set == nullptr && load)
723 {
724 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoTarget_Set");
725 }
726
727 m_peak_afl_AutoController_AutoTarget_Get = (dyn_peak_afl_AutoController_AutoTarget_Get) (load ? import_function(m_handle, "peak_afl_AutoController_AutoTarget_Get") : nullptr);
728 if(m_peak_afl_AutoController_AutoTarget_Get == nullptr && load)
729 {
730 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoTarget_Get");
731 }
732
733 m_peak_afl_AutoController_AutoTarget_GetRange = (dyn_peak_afl_AutoController_AutoTarget_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_AutoTarget_GetRange") : nullptr);
734 if(m_peak_afl_AutoController_AutoTarget_GetRange == nullptr && load)
735 {
736 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoTarget_GetRange");
737 }
738
739 m_peak_afl_AutoController_AutoTolerance_IsSupported = (dyn_peak_afl_AutoController_AutoTolerance_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_AutoTolerance_IsSupported") : nullptr);
740 if(m_peak_afl_AutoController_AutoTolerance_IsSupported == nullptr && load)
741 {
742 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoTolerance_IsSupported");
743 }
744
745 m_peak_afl_AutoController_AutoTolerance_Set = (dyn_peak_afl_AutoController_AutoTolerance_Set) (load ? import_function(m_handle, "peak_afl_AutoController_AutoTolerance_Set") : nullptr);
746 if(m_peak_afl_AutoController_AutoTolerance_Set == nullptr && load)
747 {
748 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoTolerance_Set");
749 }
750
751 m_peak_afl_AutoController_AutoTolerance_Get = (dyn_peak_afl_AutoController_AutoTolerance_Get) (load ? import_function(m_handle, "peak_afl_AutoController_AutoTolerance_Get") : nullptr);
752 if(m_peak_afl_AutoController_AutoTolerance_Get == nullptr && load)
753 {
754 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoTolerance_Get");
755 }
756
757 m_peak_afl_AutoController_AutoTolerance_GetRange = (dyn_peak_afl_AutoController_AutoTolerance_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_AutoTolerance_GetRange") : nullptr);
758 if(m_peak_afl_AutoController_AutoTolerance_GetRange == nullptr && load)
759 {
760 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoTolerance_GetRange");
761 }
762
763 m_peak_afl_AutoController_AutoPercentile_IsSupported = (dyn_peak_afl_AutoController_AutoPercentile_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_AutoPercentile_IsSupported") : nullptr);
764 if(m_peak_afl_AutoController_AutoPercentile_IsSupported == nullptr && load)
765 {
766 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoPercentile_IsSupported");
767 }
768
769 m_peak_afl_AutoController_AutoPercentile_Set = (dyn_peak_afl_AutoController_AutoPercentile_Set) (load ? import_function(m_handle, "peak_afl_AutoController_AutoPercentile_Set") : nullptr);
770 if(m_peak_afl_AutoController_AutoPercentile_Set == nullptr && load)
771 {
772 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoPercentile_Set");
773 }
774
775 m_peak_afl_AutoController_AutoPercentile_Get = (dyn_peak_afl_AutoController_AutoPercentile_Get) (load ? import_function(m_handle, "peak_afl_AutoController_AutoPercentile_Get") : nullptr);
776 if(m_peak_afl_AutoController_AutoPercentile_Get == nullptr && load)
777 {
778 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoPercentile_Get");
779 }
780
781 m_peak_afl_AutoController_AutoPercentile_GetRange = (dyn_peak_afl_AutoController_AutoPercentile_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_AutoPercentile_GetRange") : nullptr);
782 if(m_peak_afl_AutoController_AutoPercentile_GetRange == nullptr && load)
783 {
784 throw std::runtime_error("Failed to load peak_afl_AutoController_AutoPercentile_GetRange");
785 }
786
787 m_peak_afl_AutoController_Type_Get = (dyn_peak_afl_AutoController_Type_Get) (load ? import_function(m_handle, "peak_afl_AutoController_Type_Get") : nullptr);
788 if(m_peak_afl_AutoController_Type_Get == nullptr && load)
789 {
790 throw std::runtime_error("Failed to load peak_afl_AutoController_Type_Get");
791 }
792
793 m_peak_afl_AutoController_Algorithm_IsSupported = (dyn_peak_afl_AutoController_Algorithm_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_Algorithm_IsSupported") : nullptr);
794 if(m_peak_afl_AutoController_Algorithm_IsSupported == nullptr && load)
795 {
796 throw std::runtime_error("Failed to load peak_afl_AutoController_Algorithm_IsSupported");
797 }
798
799 m_peak_afl_AutoController_Algorithm_Set = (dyn_peak_afl_AutoController_Algorithm_Set) (load ? import_function(m_handle, "peak_afl_AutoController_Algorithm_Set") : nullptr);
800 if(m_peak_afl_AutoController_Algorithm_Set == nullptr && load)
801 {
802 throw std::runtime_error("Failed to load peak_afl_AutoController_Algorithm_Set");
803 }
804
805 m_peak_afl_AutoController_Algorithm_Get = (dyn_peak_afl_AutoController_Algorithm_Get) (load ? import_function(m_handle, "peak_afl_AutoController_Algorithm_Get") : nullptr);
806 if(m_peak_afl_AutoController_Algorithm_Get == nullptr && load)
807 {
808 throw std::runtime_error("Failed to load peak_afl_AutoController_Algorithm_Get");
809 }
810
811 m_peak_afl_AutoController_Algorithm_GetList = (dyn_peak_afl_AutoController_Algorithm_GetList) (load ? import_function(m_handle, "peak_afl_AutoController_Algorithm_GetList") : nullptr);
812 if(m_peak_afl_AutoController_Algorithm_GetList == nullptr && load)
813 {
814 throw std::runtime_error("Failed to load peak_afl_AutoController_Algorithm_GetList");
815 }
816
817 m_peak_afl_AutoController_SharpnessAlgorithm_IsSupported = (dyn_peak_afl_AutoController_SharpnessAlgorithm_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_SharpnessAlgorithm_IsSupported") : nullptr);
818 if(m_peak_afl_AutoController_SharpnessAlgorithm_IsSupported == nullptr && load)
819 {
820 throw std::runtime_error("Failed to load peak_afl_AutoController_SharpnessAlgorithm_IsSupported");
821 }
822
823 m_peak_afl_AutoController_SharpnessAlgorithm_Set = (dyn_peak_afl_AutoController_SharpnessAlgorithm_Set) (load ? import_function(m_handle, "peak_afl_AutoController_SharpnessAlgorithm_Set") : nullptr);
824 if(m_peak_afl_AutoController_SharpnessAlgorithm_Set == nullptr && load)
825 {
826 throw std::runtime_error("Failed to load peak_afl_AutoController_SharpnessAlgorithm_Set");
827 }
828
829 m_peak_afl_AutoController_SharpnessAlgorithm_Get = (dyn_peak_afl_AutoController_SharpnessAlgorithm_Get) (load ? import_function(m_handle, "peak_afl_AutoController_SharpnessAlgorithm_Get") : nullptr);
830 if(m_peak_afl_AutoController_SharpnessAlgorithm_Get == nullptr && load)
831 {
832 throw std::runtime_error("Failed to load peak_afl_AutoController_SharpnessAlgorithm_Get");
833 }
834
835 m_peak_afl_AutoController_SharpnessAlgorithm_GetList = (dyn_peak_afl_AutoController_SharpnessAlgorithm_GetList) (load ? import_function(m_handle, "peak_afl_AutoController_SharpnessAlgorithm_GetList") : nullptr);
836 if(m_peak_afl_AutoController_SharpnessAlgorithm_GetList == nullptr && load)
837 {
838 throw std::runtime_error("Failed to load peak_afl_AutoController_SharpnessAlgorithm_GetList");
839 }
840
841 m_peak_afl_AutoController_Callback_Set = (dyn_peak_afl_AutoController_Callback_Set) (load ? import_function(m_handle, "peak_afl_AutoController_Callback_Set") : nullptr);
842 if(m_peak_afl_AutoController_Callback_Set == nullptr && load)
843 {
844 throw std::runtime_error("Failed to load peak_afl_AutoController_Callback_Set");
845 }
846
847 m_peak_afl_AutoController_Weighted_ROI_IsSupported = (dyn_peak_afl_AutoController_Weighted_ROI_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_Weighted_ROI_IsSupported") : nullptr);
848 if(m_peak_afl_AutoController_Weighted_ROI_IsSupported == nullptr && load)
849 {
850 throw std::runtime_error("Failed to load peak_afl_AutoController_Weighted_ROI_IsSupported");
851 }
852
853 m_peak_afl_AutoController_Weighted_ROI_Min_Size = (dyn_peak_afl_AutoController_Weighted_ROI_Min_Size) (load ? import_function(m_handle, "peak_afl_AutoController_Weighted_ROI_Min_Size") : nullptr);
854 if(m_peak_afl_AutoController_Weighted_ROI_Min_Size == nullptr && load)
855 {
856 throw std::runtime_error("Failed to load peak_afl_AutoController_Weighted_ROI_Min_Size");
857 }
858
859 m_peak_afl_AutoController_Weighted_ROI_Set = (dyn_peak_afl_AutoController_Weighted_ROI_Set) (load ? import_function(m_handle, "peak_afl_AutoController_Weighted_ROI_Set") : nullptr);
860 if(m_peak_afl_AutoController_Weighted_ROI_Set == nullptr && load)
861 {
862 throw std::runtime_error("Failed to load peak_afl_AutoController_Weighted_ROI_Set");
863 }
864
865 m_peak_afl_AutoController_Weighted_ROI_Get = (dyn_peak_afl_AutoController_Weighted_ROI_Get) (load ? import_function(m_handle, "peak_afl_AutoController_Weighted_ROI_Get") : nullptr);
866 if(m_peak_afl_AutoController_Weighted_ROI_Get == nullptr && load)
867 {
868 throw std::runtime_error("Failed to load peak_afl_AutoController_Weighted_ROI_Get");
869 }
870
871 m_peak_afl_AutoController_Limit_IsSupported = (dyn_peak_afl_AutoController_Limit_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_Limit_IsSupported") : nullptr);
872 if(m_peak_afl_AutoController_Limit_IsSupported == nullptr && load)
873 {
874 throw std::runtime_error("Failed to load peak_afl_AutoController_Limit_IsSupported");
875 }
876
877 m_peak_afl_AutoController_Limit_Default = (dyn_peak_afl_AutoController_Limit_Default) (load ? import_function(m_handle, "peak_afl_AutoController_Limit_Default") : nullptr);
878 if(m_peak_afl_AutoController_Limit_Default == nullptr && load)
879 {
880 throw std::runtime_error("Failed to load peak_afl_AutoController_Limit_Default");
881 }
882
883 m_peak_afl_AutoController_Limit_Set = (dyn_peak_afl_AutoController_Limit_Set) (load ? import_function(m_handle, "peak_afl_AutoController_Limit_Set") : nullptr);
884 if(m_peak_afl_AutoController_Limit_Set == nullptr && load)
885 {
886 throw std::runtime_error("Failed to load peak_afl_AutoController_Limit_Set");
887 }
888
889 m_peak_afl_AutoController_Limit_Get = (dyn_peak_afl_AutoController_Limit_Get) (load ? import_function(m_handle, "peak_afl_AutoController_Limit_Get") : nullptr);
890 if(m_peak_afl_AutoController_Limit_Get == nullptr && load)
891 {
892 throw std::runtime_error("Failed to load peak_afl_AutoController_Limit_Get");
893 }
894
895 m_peak_afl_AutoController_Hysteresis_IsSupported = (dyn_peak_afl_AutoController_Hysteresis_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_Hysteresis_IsSupported") : nullptr);
896 if(m_peak_afl_AutoController_Hysteresis_IsSupported == nullptr && load)
897 {
898 throw std::runtime_error("Failed to load peak_afl_AutoController_Hysteresis_IsSupported");
899 }
900
901 m_peak_afl_AutoController_Hysteresis_Default = (dyn_peak_afl_AutoController_Hysteresis_Default) (load ? import_function(m_handle, "peak_afl_AutoController_Hysteresis_Default") : nullptr);
902 if(m_peak_afl_AutoController_Hysteresis_Default == nullptr && load)
903 {
904 throw std::runtime_error("Failed to load peak_afl_AutoController_Hysteresis_Default");
905 }
906
907 m_peak_afl_AutoController_Hysteresis_Set = (dyn_peak_afl_AutoController_Hysteresis_Set) (load ? import_function(m_handle, "peak_afl_AutoController_Hysteresis_Set") : nullptr);
908 if(m_peak_afl_AutoController_Hysteresis_Set == nullptr && load)
909 {
910 throw std::runtime_error("Failed to load peak_afl_AutoController_Hysteresis_Set");
911 }
912
913 m_peak_afl_AutoController_Hysteresis_Get = (dyn_peak_afl_AutoController_Hysteresis_Get) (load ? import_function(m_handle, "peak_afl_AutoController_Hysteresis_Get") : nullptr);
914 if(m_peak_afl_AutoController_Hysteresis_Get == nullptr && load)
915 {
916 throw std::runtime_error("Failed to load peak_afl_AutoController_Hysteresis_Get");
917 }
918
919 m_peak_afl_AutoController_Hysteresis_GetRange = (dyn_peak_afl_AutoController_Hysteresis_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_Hysteresis_GetRange") : nullptr);
920 if(m_peak_afl_AutoController_Hysteresis_GetRange == nullptr && load)
921 {
922 throw std::runtime_error("Failed to load peak_afl_AutoController_Hysteresis_GetRange");
923 }
924
925 m_peak_afl_AutoController_GainLimit_IsSupported = (dyn_peak_afl_AutoController_GainLimit_IsSupported) (load ? import_function(m_handle, "peak_afl_AutoController_GainLimit_IsSupported") : nullptr);
926 if(m_peak_afl_AutoController_GainLimit_IsSupported == nullptr && load)
927 {
928 throw std::runtime_error("Failed to load peak_afl_AutoController_GainLimit_IsSupported");
929 }
930
931 m_peak_afl_AutoController_GainLimit_Set = (dyn_peak_afl_AutoController_GainLimit_Set) (load ? import_function(m_handle, "peak_afl_AutoController_GainLimit_Set") : nullptr);
932 if(m_peak_afl_AutoController_GainLimit_Set == nullptr && load)
933 {
934 throw std::runtime_error("Failed to load peak_afl_AutoController_GainLimit_Set");
935 }
936
937 m_peak_afl_AutoController_GainLimit_Get = (dyn_peak_afl_AutoController_GainLimit_Get) (load ? import_function(m_handle, "peak_afl_AutoController_GainLimit_Get") : nullptr);
938 if(m_peak_afl_AutoController_GainLimit_Get == nullptr && load)
939 {
940 throw std::runtime_error("Failed to load peak_afl_AutoController_GainLimit_Get");
941 }
942
943 m_peak_afl_AutoController_GainLimit_GetRange = (dyn_peak_afl_AutoController_GainLimit_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_GainLimit_GetRange") : nullptr);
944 if(m_peak_afl_AutoController_GainLimit_GetRange == nullptr && load)
945 {
946 throw std::runtime_error("Failed to load peak_afl_AutoController_GainLimit_GetRange");
947 }
948
949 m_peak_afl_AutoController_GainAnalogLimit_Set = (dyn_peak_afl_AutoController_GainAnalogLimit_Set) (load ? import_function(m_handle, "peak_afl_AutoController_GainAnalogLimit_Set") : nullptr);
950 if(m_peak_afl_AutoController_GainAnalogLimit_Set == nullptr && load)
951 {
952 throw std::runtime_error("Failed to load peak_afl_AutoController_GainAnalogLimit_Set");
953 }
954
955 m_peak_afl_AutoController_GainAnalogLimit_Get = (dyn_peak_afl_AutoController_GainAnalogLimit_Get) (load ? import_function(m_handle, "peak_afl_AutoController_GainAnalogLimit_Get") : nullptr);
956 if(m_peak_afl_AutoController_GainAnalogLimit_Get == nullptr && load)
957 {
958 throw std::runtime_error("Failed to load peak_afl_AutoController_GainAnalogLimit_Get");
959 }
960
961 m_peak_afl_AutoController_GainAnalogLimit_GetRange = (dyn_peak_afl_AutoController_GainAnalogLimit_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_GainAnalogLimit_GetRange") : nullptr);
962 if(m_peak_afl_AutoController_GainAnalogLimit_GetRange == nullptr && load)
963 {
964 throw std::runtime_error("Failed to load peak_afl_AutoController_GainAnalogLimit_GetRange");
965 }
966
967 m_peak_afl_AutoController_GainDigitalLimit_Set = (dyn_peak_afl_AutoController_GainDigitalLimit_Set) (load ? import_function(m_handle, "peak_afl_AutoController_GainDigitalLimit_Set") : nullptr);
968 if(m_peak_afl_AutoController_GainDigitalLimit_Set == nullptr && load)
969 {
970 throw std::runtime_error("Failed to load peak_afl_AutoController_GainDigitalLimit_Set");
971 }
972
973 m_peak_afl_AutoController_GainDigitalLimit_Get = (dyn_peak_afl_AutoController_GainDigitalLimit_Get) (load ? import_function(m_handle, "peak_afl_AutoController_GainDigitalLimit_Get") : nullptr);
974 if(m_peak_afl_AutoController_GainDigitalLimit_Get == nullptr && load)
975 {
976 throw std::runtime_error("Failed to load peak_afl_AutoController_GainDigitalLimit_Get");
977 }
978
979 m_peak_afl_AutoController_GainDigitalLimit_GetRange = (dyn_peak_afl_AutoController_GainDigitalLimit_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_GainDigitalLimit_GetRange") : nullptr);
980 if(m_peak_afl_AutoController_GainDigitalLimit_GetRange == nullptr && load)
981 {
982 throw std::runtime_error("Failed to load peak_afl_AutoController_GainDigitalLimit_GetRange");
983 }
984
985 m_peak_afl_AutoController_GainCombinedLimit_Set = (dyn_peak_afl_AutoController_GainCombinedLimit_Set) (load ? import_function(m_handle, "peak_afl_AutoController_GainCombinedLimit_Set") : nullptr);
986 if(m_peak_afl_AutoController_GainCombinedLimit_Set == nullptr && load)
987 {
988 throw std::runtime_error("Failed to load peak_afl_AutoController_GainCombinedLimit_Set");
989 }
990
991 m_peak_afl_AutoController_GainCombinedLimit_Get = (dyn_peak_afl_AutoController_GainCombinedLimit_Get) (load ? import_function(m_handle, "peak_afl_AutoController_GainCombinedLimit_Get") : nullptr);
992 if(m_peak_afl_AutoController_GainCombinedLimit_Get == nullptr && load)
993 {
994 throw std::runtime_error("Failed to load peak_afl_AutoController_GainCombinedLimit_Get");
995 }
996
997 m_peak_afl_AutoController_GainCombinedLimit_GetRange = (dyn_peak_afl_AutoController_GainCombinedLimit_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_GainCombinedLimit_GetRange") : nullptr);
998 if(m_peak_afl_AutoController_GainCombinedLimit_GetRange == nullptr && load)
999 {
1000 throw std::runtime_error("Failed to load peak_afl_AutoController_GainCombinedLimit_GetRange");
1001 }
1002
1003 m_peak_afl_AutoController_GainHostLimit_Set = (dyn_peak_afl_AutoController_GainHostLimit_Set) (load ? import_function(m_handle, "peak_afl_AutoController_GainHostLimit_Set") : nullptr);
1004 if(m_peak_afl_AutoController_GainHostLimit_Set == nullptr && load)
1005 {
1006 throw std::runtime_error("Failed to load peak_afl_AutoController_GainHostLimit_Set");
1007 }
1008
1009 m_peak_afl_AutoController_GainHostLimit_Get = (dyn_peak_afl_AutoController_GainHostLimit_Get) (load ? import_function(m_handle, "peak_afl_AutoController_GainHostLimit_Get") : nullptr);
1010 if(m_peak_afl_AutoController_GainHostLimit_Get == nullptr && load)
1011 {
1012 throw std::runtime_error("Failed to load peak_afl_AutoController_GainHostLimit_Get");
1013 }
1014
1015 m_peak_afl_AutoController_GainHostLimit_GetRange = (dyn_peak_afl_AutoController_GainHostLimit_GetRange) (load ? import_function(m_handle, "peak_afl_AutoController_GainHostLimit_GetRange") : nullptr);
1016 if(m_peak_afl_AutoController_GainHostLimit_GetRange == nullptr && load)
1017 {
1018 throw std::runtime_error("Failed to load peak_afl_AutoController_GainHostLimit_GetRange");
1019 }
1020
1021
1022 return true;
1023}
1024
1025inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_Init(void )
1026{
1027 auto& inst = instance();
1028 if(inst.m_peak_afl_Init)
1029 {
1030 return inst.m_peak_afl_Init();
1031 }
1032 else
1033 {
1034 throw std::runtime_error("Library not loaded!");
1035 }
1036}
1037
1038inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_Exit(void )
1039{
1040 auto& inst = instance();
1041 if(inst.m_peak_afl_Exit)
1042 {
1043 return inst.m_peak_afl_Exit();
1044 }
1045 else
1046 {
1047 throw std::runtime_error("Library not loaded!");
1048 }
1049}
1050
1051inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_GetLastError(peak_afl_status * lastErrorCode, char * lastErrorMessage, size_t * lastErrorMessageSize)
1052{
1053 auto& inst = instance();
1054 if(inst.m_peak_afl_GetLastError)
1055 {
1056 return inst.m_peak_afl_GetLastError(lastErrorCode, lastErrorMessage, lastErrorMessageSize);
1057 }
1058 else
1059 {
1060 throw std::runtime_error("Library not loaded!");
1061 }
1062}
1063
1064inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_GetVersion(uint32_t * majorVersion, uint32_t * minorVersion, uint32_t * subminorVersion, uint32_t * patchVersion)
1065{
1066 auto& inst = instance();
1067 if(inst.m_peak_afl_GetVersion)
1068 {
1069 return inst.m_peak_afl_GetVersion(majorVersion, minorVersion, subminorVersion, patchVersion);
1070 }
1071 else
1072 {
1073 throw std::runtime_error("Library not loaded!");
1074 }
1075}
1076
1077inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_Create(peak_afl_manager_handle * handle, PEAK_NODE_MAP_HANDLE nodeMapHandle)
1078{
1079 auto& inst = instance();
1080 if(inst.m_peak_afl_AutoFeatureManager_Create)
1081 {
1082 return inst.m_peak_afl_AutoFeatureManager_Create(handle, nodeMapHandle);
1083 }
1084 else
1085 {
1086 throw std::runtime_error("Library not loaded!");
1087 }
1088}
1089
1090inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_Destroy(peak_afl_manager_handle handle)
1091{
1092 auto& inst = instance();
1093 if(inst.m_peak_afl_AutoFeatureManager_Destroy)
1094 {
1095 return inst.m_peak_afl_AutoFeatureManager_Destroy(handle);
1096 }
1097 else
1098 {
1099 throw std::runtime_error("Library not loaded!");
1100 }
1101}
1102
1103inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_AddController(peak_afl_manager_handle handle, peak_afl_manager_handle controller)
1104{
1105 auto& inst = instance();
1106 if(inst.m_peak_afl_AutoFeatureManager_AddController)
1107 {
1108 return inst.m_peak_afl_AutoFeatureManager_AddController(handle, controller);
1109 }
1110 else
1111 {
1112 throw std::runtime_error("Library not loaded!");
1113 }
1114}
1115
1116inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_RemoveController(peak_afl_manager_handle handle, peak_afl_manager_handle controller)
1117{
1118 auto& inst = instance();
1119 if(inst.m_peak_afl_AutoFeatureManager_RemoveController)
1120 {
1121 return inst.m_peak_afl_AutoFeatureManager_RemoveController(handle, controller);
1122 }
1123 else
1124 {
1125 throw std::runtime_error("Library not loaded!");
1126 }
1127}
1128
1129inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_Process(peak_afl_manager_handle handle, PEAK_IPL_IMAGE_HANDLE imageHandle)
1130{
1131 auto& inst = instance();
1132 if(inst.m_peak_afl_AutoFeatureManager_Process)
1133 {
1134 return inst.m_peak_afl_AutoFeatureManager_Process(handle, imageHandle);
1135 }
1136 else
1137 {
1138 throw std::runtime_error("Library not loaded!");
1139 }
1140}
1141
1142inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_CreateController(peak_afl_manager_handle handle, peak_afl_controller_handle * controller, peak_afl_controllerType controllerType)
1143{
1144 auto& inst = instance();
1145 if(inst.m_peak_afl_AutoFeatureManager_CreateController)
1146 {
1147 return inst.m_peak_afl_AutoFeatureManager_CreateController(handle, controller, controllerType);
1148 }
1149 else
1150 {
1151 throw std::runtime_error("Library not loaded!");
1152 }
1153}
1154
1155inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_DestroyAllController(peak_afl_manager_handle handle)
1156{
1157 auto& inst = instance();
1158 if(inst.m_peak_afl_AutoFeatureManager_DestroyAllController)
1159 {
1160 return inst.m_peak_afl_AutoFeatureManager_DestroyAllController(handle);
1161 }
1162 else
1163 {
1164 throw std::runtime_error("Library not loaded!");
1165 }
1166}
1167
1168inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_DestroyController(peak_afl_manager_handle handle, peak_afl_controller_handle controller)
1169{
1170 auto& inst = instance();
1171 if(inst.m_peak_afl_AutoFeatureManager_DestroyController)
1172 {
1173 return inst.m_peak_afl_AutoFeatureManager_DestroyController(handle, controller);
1174 }
1175 else
1176 {
1177 throw std::runtime_error("Library not loaded!");
1178 }
1179}
1180
1181inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_SetGainIPL(peak_afl_manager_handle handle, PEAK_IPL_GAIN_HANDLE gainHandle)
1182{
1183 auto& inst = instance();
1184 if(inst.m_peak_afl_AutoFeatureManager_SetGainIPL)
1185 {
1186 return inst.m_peak_afl_AutoFeatureManager_SetGainIPL(handle, gainHandle);
1187 }
1188 else
1189 {
1190 throw std::runtime_error("Library not loaded!");
1191 }
1192}
1193
1194inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoFeatureManager_Status(peak_afl_manager_handle handle, peak_afl_BOOL8 * running)
1195{
1196 auto& inst = instance();
1197 if(inst.m_peak_afl_AutoFeatureManager_Status)
1198 {
1199 return inst.m_peak_afl_AutoFeatureManager_Status(handle, running);
1200 }
1201 else
1202 {
1203 throw std::runtime_error("Library not loaded!");
1204 }
1205}
1206
1207inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Create(peak_afl_controller_handle * controller, peak_afl_controllerType controllerType)
1208{
1209 auto& inst = instance();
1210 if(inst.m_peak_afl_AutoController_Create)
1211 {
1212 return inst.m_peak_afl_AutoController_Create(controller, controllerType);
1213 }
1214 else
1215 {
1216 throw std::runtime_error("Library not loaded!");
1217 }
1218}
1219
1220inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Destroy(peak_afl_controller_handle controller)
1221{
1222 auto& inst = instance();
1223 if(inst.m_peak_afl_AutoController_Destroy)
1224 {
1225 return inst.m_peak_afl_AutoController_Destroy(controller);
1226 }
1227 else
1228 {
1229 throw std::runtime_error("Library not loaded!");
1230 }
1231}
1232
1233inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_SkipFrames_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1234{
1235 auto& inst = instance();
1236 if(inst.m_peak_afl_AutoController_SkipFrames_IsSupported)
1237 {
1238 return inst.m_peak_afl_AutoController_SkipFrames_IsSupported(controller, supported);
1239 }
1240 else
1241 {
1242 throw std::runtime_error("Library not loaded!");
1243 }
1244}
1245
1246inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_SkipFrames_Set(peak_afl_controller_handle controller, uint32_t count)
1247{
1248 auto& inst = instance();
1249 if(inst.m_peak_afl_AutoController_SkipFrames_Set)
1250 {
1251 return inst.m_peak_afl_AutoController_SkipFrames_Set(controller, count);
1252 }
1253 else
1254 {
1255 throw std::runtime_error("Library not loaded!");
1256 }
1257}
1258
1259inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_SkipFrames_Get(peak_afl_controller_handle controller, uint32_t * count)
1260{
1261 auto& inst = instance();
1262 if(inst.m_peak_afl_AutoController_SkipFrames_Get)
1263 {
1264 return inst.m_peak_afl_AutoController_SkipFrames_Get(controller, count);
1265 }
1266 else
1267 {
1268 throw std::runtime_error("Library not loaded!");
1269 }
1270}
1271
1272inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_SkipFrames_GetRange(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc)
1273{
1274 auto& inst = instance();
1275 if(inst.m_peak_afl_AutoController_SkipFrames_GetRange)
1276 {
1277 return inst.m_peak_afl_AutoController_SkipFrames_GetRange(controller, min, max, inc);
1278 }
1279 else
1280 {
1281 throw std::runtime_error("Library not loaded!");
1282 }
1283}
1284
1285inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_ROI_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1286{
1287 auto& inst = instance();
1288 if(inst.m_peak_afl_AutoController_ROI_IsSupported)
1289 {
1290 return inst.m_peak_afl_AutoController_ROI_IsSupported(controller, supported);
1291 }
1292 else
1293 {
1294 throw std::runtime_error("Library not loaded!");
1295 }
1296}
1297
1298inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_ROI_Set(peak_afl_controller_handle controller, peak_afl_rectangle roi)
1299{
1300 auto& inst = instance();
1301 if(inst.m_peak_afl_AutoController_ROI_Set)
1302 {
1303 return inst.m_peak_afl_AutoController_ROI_Set(controller, roi);
1304 }
1305 else
1306 {
1307 throw std::runtime_error("Library not loaded!");
1308 }
1309}
1310
1311inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_ROI_Get(peak_afl_controller_handle controller, peak_afl_rectangle * roi)
1312{
1313 auto& inst = instance();
1314 if(inst.m_peak_afl_AutoController_ROI_Get)
1315 {
1316 return inst.m_peak_afl_AutoController_ROI_Get(controller, roi);
1317 }
1318 else
1319 {
1320 throw std::runtime_error("Library not loaded!");
1321 }
1322}
1323
1324inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_ROI_Preset_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1325{
1326 auto& inst = instance();
1327 if(inst.m_peak_afl_AutoController_ROI_Preset_IsSupported)
1328 {
1329 return inst.m_peak_afl_AutoController_ROI_Preset_IsSupported(controller, supported);
1330 }
1331 else
1332 {
1333 throw std::runtime_error("Library not loaded!");
1334 }
1335}
1336
1337inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_ROI_Preset_Set(peak_afl_controller_handle controller, peak_afl_roi_preset roiPreset)
1338{
1339 auto& inst = instance();
1340 if(inst.m_peak_afl_AutoController_ROI_Preset_Set)
1341 {
1342 return inst.m_peak_afl_AutoController_ROI_Preset_Set(controller, roiPreset);
1343 }
1344 else
1345 {
1346 throw std::runtime_error("Library not loaded!");
1347 }
1348}
1349
1350inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Mode_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1351{
1352 auto& inst = instance();
1353 if(inst.m_peak_afl_AutoController_Mode_IsSupported)
1354 {
1355 return inst.m_peak_afl_AutoController_Mode_IsSupported(controller, supported);
1356 }
1357 else
1358 {
1359 throw std::runtime_error("Library not loaded!");
1360 }
1361}
1362
1363inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Mode_Set(peak_afl_controller_handle controller, peak_afl_controller_automode mode)
1364{
1365 auto& inst = instance();
1366 if(inst.m_peak_afl_AutoController_Mode_Set)
1367 {
1368 return inst.m_peak_afl_AutoController_Mode_Set(controller, mode);
1369 }
1370 else
1371 {
1372 throw std::runtime_error("Library not loaded!");
1373 }
1374}
1375
1376inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Mode_Get(peak_afl_controller_handle controller, peak_afl_controller_automode * mode)
1377{
1378 auto& inst = instance();
1379 if(inst.m_peak_afl_AutoController_Mode_Get)
1380 {
1381 return inst.m_peak_afl_AutoController_Mode_Get(controller, mode);
1382 }
1383 else
1384 {
1385 throw std::runtime_error("Library not loaded!");
1386 }
1387}
1388
1389inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessAlgorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_algorithm algorithm)
1390{
1391 auto& inst = instance();
1392 if(inst.m_peak_afl_AutoController_BrightnessAlgorithm_Set)
1393 {
1394 return inst.m_peak_afl_AutoController_BrightnessAlgorithm_Set(controller, algorithm);
1395 }
1396 else
1397 {
1398 throw std::runtime_error("Library not loaded!");
1399 }
1400}
1401
1402inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessAlgorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_brightness_algorithm * algorithm)
1403{
1404 auto& inst = instance();
1405 if(inst.m_peak_afl_AutoController_BrightnessAlgorithm_Get)
1406 {
1407 return inst.m_peak_afl_AutoController_BrightnessAlgorithm_Get(controller, algorithm);
1408 }
1409 else
1410 {
1411 throw std::runtime_error("Library not loaded!");
1412 }
1413}
1414
1415inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessAlgorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1416{
1417 auto& inst = instance();
1418 if(inst.m_peak_afl_AutoController_BrightnessAlgorithm_IsSupported)
1419 {
1420 return inst.m_peak_afl_AutoController_BrightnessAlgorithm_IsSupported(controller, supported);
1421 }
1422 else
1423 {
1424 throw std::runtime_error("Library not loaded!");
1425 }
1426}
1427
1428inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessComponent_Mode_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1429{
1430 auto& inst = instance();
1431 if(inst.m_peak_afl_AutoController_BrightnessComponent_Mode_IsSupported)
1432 {
1433 return inst.m_peak_afl_AutoController_BrightnessComponent_Mode_IsSupported(controller, supported);
1434 }
1435 else
1436 {
1437 throw std::runtime_error("Library not loaded!");
1438 }
1439}
1440
1441inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessComponent_Unit_IsSupported(peak_afl_controller_handle controller, peak_afl_controller_brightness_component unit, peak_afl_BOOL8 * supported)
1442{
1443 auto& inst = instance();
1444 if(inst.m_peak_afl_AutoController_BrightnessComponent_Unit_IsSupported)
1445 {
1446 return inst.m_peak_afl_AutoController_BrightnessComponent_Unit_IsSupported(controller, unit, supported);
1447 }
1448 else
1449 {
1450 throw std::runtime_error("Library not loaded!");
1451 }
1452}
1453
1454inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessComponent_Mode_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_automode mode)
1455{
1456 auto& inst = instance();
1457 if(inst.m_peak_afl_AutoController_BrightnessComponent_Mode_Set)
1458 {
1459 return inst.m_peak_afl_AutoController_BrightnessComponent_Mode_Set(controller, component, mode);
1460 }
1461 else
1462 {
1463 throw std::runtime_error("Library not loaded!");
1464 }
1465}
1466
1467inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessComponent_Mode_Get(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_automode * mode)
1468{
1469 auto& inst = instance();
1470 if(inst.m_peak_afl_AutoController_BrightnessComponent_Mode_Get)
1471 {
1472 return inst.m_peak_afl_AutoController_BrightnessComponent_Mode_Get(controller, component, mode);
1473 }
1474 else
1475 {
1476 throw std::runtime_error("Library not loaded!");
1477 }
1478}
1479
1480inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessComponent_Status(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_status * status)
1481{
1482 auto& inst = instance();
1483 if(inst.m_peak_afl_AutoController_BrightnessComponent_Status)
1484 {
1485 return inst.m_peak_afl_AutoController_BrightnessComponent_Status(controller, component, status);
1486 }
1487 else
1488 {
1489 throw std::runtime_error("Library not loaded!");
1490 }
1491}
1492
1493inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_BrightnessComponent_Callback_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_callback_type type, void * funcPtr, void * context)
1494{
1495 auto& inst = instance();
1496 if(inst.m_peak_afl_AutoController_BrightnessComponent_Callback_Set)
1497 {
1498 return inst.m_peak_afl_AutoController_BrightnessComponent_Callback_Set(controller, component, type, funcPtr, context);
1499 }
1500 else
1501 {
1502 throw std::runtime_error("Library not loaded!");
1503 }
1504}
1505
1506inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_ExposureLimit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1507{
1508 auto& inst = instance();
1509 if(inst.m_peak_afl_AutoController_ExposureLimit_IsSupported)
1510 {
1511 return inst.m_peak_afl_AutoController_ExposureLimit_IsSupported(controller, supported);
1512 }
1513 else
1514 {
1515 throw std::runtime_error("Library not loaded!");
1516 }
1517}
1518
1519inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_ExposureLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
1520{
1521 auto& inst = instance();
1522 if(inst.m_peak_afl_AutoController_ExposureLimit_Set)
1523 {
1524 return inst.m_peak_afl_AutoController_ExposureLimit_Set(controller, limit);
1525 }
1526 else
1527 {
1528 throw std::runtime_error("Library not loaded!");
1529 }
1530}
1531
1532inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_ExposureLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
1533{
1534 auto& inst = instance();
1535 if(inst.m_peak_afl_AutoController_ExposureLimit_Get)
1536 {
1537 return inst.m_peak_afl_AutoController_ExposureLimit_Get(controller, limit);
1538 }
1539 else
1540 {
1541 throw std::runtime_error("Library not loaded!");
1542 }
1543}
1544
1545inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Status(peak_afl_controller_handle controller, peak_afl_controller_status * status)
1546{
1547 auto& inst = instance();
1548 if(inst.m_peak_afl_AutoController_Status)
1549 {
1550 return inst.m_peak_afl_AutoController_Status(controller, status);
1551 }
1552 else
1553 {
1554 throw std::runtime_error("Library not loaded!");
1555 }
1556}
1557
1558inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GetLastAutoAverage(peak_afl_controller_handle controller, uint8_t * average)
1559{
1560 auto& inst = instance();
1561 if(inst.m_peak_afl_AutoController_GetLastAutoAverage)
1562 {
1563 return inst.m_peak_afl_AutoController_GetLastAutoAverage(controller, average);
1564 }
1565 else
1566 {
1567 throw std::runtime_error("Library not loaded!");
1568 }
1569}
1570
1571inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GetLastAutoAverages(peak_afl_controller_handle controller, uint8_t * averageRed, uint8_t * averageGreen, uint8_t * averageBlue)
1572{
1573 auto& inst = instance();
1574 if(inst.m_peak_afl_AutoController_GetLastAutoAverages)
1575 {
1576 return inst.m_peak_afl_AutoController_GetLastAutoAverages(controller, averageRed, averageGreen, averageBlue);
1577 }
1578 else
1579 {
1580 throw std::runtime_error("Library not loaded!");
1581 }
1582}
1583
1584inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoTarget_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1585{
1586 auto& inst = instance();
1587 if(inst.m_peak_afl_AutoController_AutoTarget_IsSupported)
1588 {
1589 return inst.m_peak_afl_AutoController_AutoTarget_IsSupported(controller, supported);
1590 }
1591 else
1592 {
1593 throw std::runtime_error("Library not loaded!");
1594 }
1595}
1596
1597inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoTarget_Set(peak_afl_controller_handle controller, uint32_t target)
1598{
1599 auto& inst = instance();
1600 if(inst.m_peak_afl_AutoController_AutoTarget_Set)
1601 {
1602 return inst.m_peak_afl_AutoController_AutoTarget_Set(controller, target);
1603 }
1604 else
1605 {
1606 throw std::runtime_error("Library not loaded!");
1607 }
1608}
1609
1610inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoTarget_Get(peak_afl_controller_handle controller, uint32_t * target)
1611{
1612 auto& inst = instance();
1613 if(inst.m_peak_afl_AutoController_AutoTarget_Get)
1614 {
1615 return inst.m_peak_afl_AutoController_AutoTarget_Get(controller, target);
1616 }
1617 else
1618 {
1619 throw std::runtime_error("Library not loaded!");
1620 }
1621}
1622
1623inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoTarget_GetRange(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc)
1624{
1625 auto& inst = instance();
1626 if(inst.m_peak_afl_AutoController_AutoTarget_GetRange)
1627 {
1628 return inst.m_peak_afl_AutoController_AutoTarget_GetRange(controller, min, max, inc);
1629 }
1630 else
1631 {
1632 throw std::runtime_error("Library not loaded!");
1633 }
1634}
1635
1636inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoTolerance_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1637{
1638 auto& inst = instance();
1639 if(inst.m_peak_afl_AutoController_AutoTolerance_IsSupported)
1640 {
1641 return inst.m_peak_afl_AutoController_AutoTolerance_IsSupported(controller, supported);
1642 }
1643 else
1644 {
1645 throw std::runtime_error("Library not loaded!");
1646 }
1647}
1648
1649inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoTolerance_Set(peak_afl_controller_handle controller, uint32_t tolerance)
1650{
1651 auto& inst = instance();
1652 if(inst.m_peak_afl_AutoController_AutoTolerance_Set)
1653 {
1654 return inst.m_peak_afl_AutoController_AutoTolerance_Set(controller, tolerance);
1655 }
1656 else
1657 {
1658 throw std::runtime_error("Library not loaded!");
1659 }
1660}
1661
1662inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoTolerance_Get(peak_afl_controller_handle controller, uint32_t * tolerance)
1663{
1664 auto& inst = instance();
1665 if(inst.m_peak_afl_AutoController_AutoTolerance_Get)
1666 {
1667 return inst.m_peak_afl_AutoController_AutoTolerance_Get(controller, tolerance);
1668 }
1669 else
1670 {
1671 throw std::runtime_error("Library not loaded!");
1672 }
1673}
1674
1675inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoTolerance_GetRange(peak_afl_controller_handle controller, uint32_t * min, uint32_t * max, uint32_t * inc)
1676{
1677 auto& inst = instance();
1678 if(inst.m_peak_afl_AutoController_AutoTolerance_GetRange)
1679 {
1680 return inst.m_peak_afl_AutoController_AutoTolerance_GetRange(controller, min, max, inc);
1681 }
1682 else
1683 {
1684 throw std::runtime_error("Library not loaded!");
1685 }
1686}
1687
1688inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoPercentile_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1689{
1690 auto& inst = instance();
1691 if(inst.m_peak_afl_AutoController_AutoPercentile_IsSupported)
1692 {
1693 return inst.m_peak_afl_AutoController_AutoPercentile_IsSupported(controller, supported);
1694 }
1695 else
1696 {
1697 throw std::runtime_error("Library not loaded!");
1698 }
1699}
1700
1701inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoPercentile_Set(peak_afl_controller_handle controller, double percentile)
1702{
1703 auto& inst = instance();
1704 if(inst.m_peak_afl_AutoController_AutoPercentile_Set)
1705 {
1706 return inst.m_peak_afl_AutoController_AutoPercentile_Set(controller, percentile);
1707 }
1708 else
1709 {
1710 throw std::runtime_error("Library not loaded!");
1711 }
1712}
1713
1714inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoPercentile_Get(peak_afl_controller_handle controller, double * percentile)
1715{
1716 auto& inst = instance();
1717 if(inst.m_peak_afl_AutoController_AutoPercentile_Get)
1718 {
1719 return inst.m_peak_afl_AutoController_AutoPercentile_Get(controller, percentile);
1720 }
1721 else
1722 {
1723 throw std::runtime_error("Library not loaded!");
1724 }
1725}
1726
1727inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_AutoPercentile_GetRange(peak_afl_controller_handle controller, double * min, double * max, double * inc)
1728{
1729 auto& inst = instance();
1730 if(inst.m_peak_afl_AutoController_AutoPercentile_GetRange)
1731 {
1732 return inst.m_peak_afl_AutoController_AutoPercentile_GetRange(controller, min, max, inc);
1733 }
1734 else
1735 {
1736 throw std::runtime_error("Library not loaded!");
1737 }
1738}
1739
1740inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Type_Get(peak_afl_controller_handle controller, peak_afl_controllerType * type)
1741{
1742 auto& inst = instance();
1743 if(inst.m_peak_afl_AutoController_Type_Get)
1744 {
1745 return inst.m_peak_afl_AutoController_Type_Get(controller, type);
1746 }
1747 else
1748 {
1749 throw std::runtime_error("Library not loaded!");
1750 }
1751}
1752
1753inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Algorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1754{
1755 auto& inst = instance();
1756 if(inst.m_peak_afl_AutoController_Algorithm_IsSupported)
1757 {
1758 return inst.m_peak_afl_AutoController_Algorithm_IsSupported(controller, supported);
1759 }
1760 else
1761 {
1762 throw std::runtime_error("Library not loaded!");
1763 }
1764}
1765
1766inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Algorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_algorithm algorithm)
1767{
1768 auto& inst = instance();
1769 if(inst.m_peak_afl_AutoController_Algorithm_Set)
1770 {
1771 return inst.m_peak_afl_AutoController_Algorithm_Set(controller, algorithm);
1772 }
1773 else
1774 {
1775 throw std::runtime_error("Library not loaded!");
1776 }
1777}
1778
1779inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Algorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_algorithm * algorithm)
1780{
1781 auto& inst = instance();
1782 if(inst.m_peak_afl_AutoController_Algorithm_Get)
1783 {
1784 return inst.m_peak_afl_AutoController_Algorithm_Get(controller, algorithm);
1785 }
1786 else
1787 {
1788 throw std::runtime_error("Library not loaded!");
1789 }
1790}
1791
1792inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Algorithm_GetList(peak_afl_controller_handle controller, peak_afl_controller_algorithm * typeList, uint32_t * listSize)
1793{
1794 auto& inst = instance();
1795 if(inst.m_peak_afl_AutoController_Algorithm_GetList)
1796 {
1797 return inst.m_peak_afl_AutoController_Algorithm_GetList(controller, typeList, listSize);
1798 }
1799 else
1800 {
1801 throw std::runtime_error("Library not loaded!");
1802 }
1803}
1804
1805inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_SharpnessAlgorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1806{
1807 auto& inst = instance();
1808 if(inst.m_peak_afl_AutoController_SharpnessAlgorithm_IsSupported)
1809 {
1810 return inst.m_peak_afl_AutoController_SharpnessAlgorithm_IsSupported(controller, supported);
1811 }
1812 else
1813 {
1814 throw std::runtime_error("Library not loaded!");
1815 }
1816}
1817
1818inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_SharpnessAlgorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm algorithm)
1819{
1820 auto& inst = instance();
1821 if(inst.m_peak_afl_AutoController_SharpnessAlgorithm_Set)
1822 {
1823 return inst.m_peak_afl_AutoController_SharpnessAlgorithm_Set(controller, algorithm);
1824 }
1825 else
1826 {
1827 throw std::runtime_error("Library not loaded!");
1828 }
1829}
1830
1831inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_SharpnessAlgorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm * algorithm)
1832{
1833 auto& inst = instance();
1834 if(inst.m_peak_afl_AutoController_SharpnessAlgorithm_Get)
1835 {
1836 return inst.m_peak_afl_AutoController_SharpnessAlgorithm_Get(controller, algorithm);
1837 }
1838 else
1839 {
1840 throw std::runtime_error("Library not loaded!");
1841 }
1842}
1843
1844inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_SharpnessAlgorithm_GetList(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm * typeList, uint32_t * listSize)
1845{
1846 auto& inst = instance();
1847 if(inst.m_peak_afl_AutoController_SharpnessAlgorithm_GetList)
1848 {
1849 return inst.m_peak_afl_AutoController_SharpnessAlgorithm_GetList(controller, typeList, listSize);
1850 }
1851 else
1852 {
1853 throw std::runtime_error("Library not loaded!");
1854 }
1855}
1856
1857inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Callback_Set(peak_afl_controller_handle controller, peak_afl_callback_type type, void * funcPtr, void * context)
1858{
1859 auto& inst = instance();
1860 if(inst.m_peak_afl_AutoController_Callback_Set)
1861 {
1862 return inst.m_peak_afl_AutoController_Callback_Set(controller, type, funcPtr, context);
1863 }
1864 else
1865 {
1866 throw std::runtime_error("Library not loaded!");
1867 }
1868}
1869
1870inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Weighted_ROI_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1871{
1872 auto& inst = instance();
1873 if(inst.m_peak_afl_AutoController_Weighted_ROI_IsSupported)
1874 {
1875 return inst.m_peak_afl_AutoController_Weighted_ROI_IsSupported(controller, supported);
1876 }
1877 else
1878 {
1879 throw std::runtime_error("Library not loaded!");
1880 }
1881}
1882
1883inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Weighted_ROI_Min_Size(peak_afl_controller_handle controller, peak_afl_size * size)
1884{
1885 auto& inst = instance();
1886 if(inst.m_peak_afl_AutoController_Weighted_ROI_Min_Size)
1887 {
1888 return inst.m_peak_afl_AutoController_Weighted_ROI_Min_Size(controller, size);
1889 }
1890 else
1891 {
1892 throw std::runtime_error("Library not loaded!");
1893 }
1894}
1895
1896inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Weighted_ROI_Set(peak_afl_controller_handle controller, const peak_afl_weighted_rectangle * weightedRoiList, uint32_t listSize)
1897{
1898 auto& inst = instance();
1899 if(inst.m_peak_afl_AutoController_Weighted_ROI_Set)
1900 {
1901 return inst.m_peak_afl_AutoController_Weighted_ROI_Set(controller, weightedRoiList, listSize);
1902 }
1903 else
1904 {
1905 throw std::runtime_error("Library not loaded!");
1906 }
1907}
1908
1909inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Weighted_ROI_Get(peak_afl_controller_handle controller, peak_afl_weighted_rectangle * weightedRoiList, uint32_t * listSize)
1910{
1911 auto& inst = instance();
1912 if(inst.m_peak_afl_AutoController_Weighted_ROI_Get)
1913 {
1914 return inst.m_peak_afl_AutoController_Weighted_ROI_Get(controller, weightedRoiList, listSize);
1915 }
1916 else
1917 {
1918 throw std::runtime_error("Library not loaded!");
1919 }
1920}
1921
1922inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Limit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1923{
1924 auto& inst = instance();
1925 if(inst.m_peak_afl_AutoController_Limit_IsSupported)
1926 {
1927 return inst.m_peak_afl_AutoController_Limit_IsSupported(controller, supported);
1928 }
1929 else
1930 {
1931 throw std::runtime_error("Library not loaded!");
1932 }
1933}
1934
1935inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Limit_Default(peak_afl_controller_handle controller, peak_afl_controller_limit * limit)
1936{
1937 auto& inst = instance();
1938 if(inst.m_peak_afl_AutoController_Limit_Default)
1939 {
1940 return inst.m_peak_afl_AutoController_Limit_Default(controller, limit);
1941 }
1942 else
1943 {
1944 throw std::runtime_error("Library not loaded!");
1945 }
1946}
1947
1948inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Limit_Set(peak_afl_controller_handle controller, peak_afl_controller_limit limit)
1949{
1950 auto& inst = instance();
1951 if(inst.m_peak_afl_AutoController_Limit_Set)
1952 {
1953 return inst.m_peak_afl_AutoController_Limit_Set(controller, limit);
1954 }
1955 else
1956 {
1957 throw std::runtime_error("Library not loaded!");
1958 }
1959}
1960
1961inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Limit_Get(peak_afl_controller_handle controller, peak_afl_controller_limit * limit)
1962{
1963 auto& inst = instance();
1964 if(inst.m_peak_afl_AutoController_Limit_Get)
1965 {
1966 return inst.m_peak_afl_AutoController_Limit_Get(controller, limit);
1967 }
1968 else
1969 {
1970 throw std::runtime_error("Library not loaded!");
1971 }
1972}
1973
1974inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Hysteresis_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
1975{
1976 auto& inst = instance();
1977 if(inst.m_peak_afl_AutoController_Hysteresis_IsSupported)
1978 {
1979 return inst.m_peak_afl_AutoController_Hysteresis_IsSupported(controller, supported);
1980 }
1981 else
1982 {
1983 throw std::runtime_error("Library not loaded!");
1984 }
1985}
1986
1987inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Hysteresis_Default(peak_afl_controller_handle controller, uint8_t * hysteresis)
1988{
1989 auto& inst = instance();
1990 if(inst.m_peak_afl_AutoController_Hysteresis_Default)
1991 {
1992 return inst.m_peak_afl_AutoController_Hysteresis_Default(controller, hysteresis);
1993 }
1994 else
1995 {
1996 throw std::runtime_error("Library not loaded!");
1997 }
1998}
1999
2000inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Hysteresis_Set(peak_afl_controller_handle controller, uint8_t hysteresis)
2001{
2002 auto& inst = instance();
2003 if(inst.m_peak_afl_AutoController_Hysteresis_Set)
2004 {
2005 return inst.m_peak_afl_AutoController_Hysteresis_Set(controller, hysteresis);
2006 }
2007 else
2008 {
2009 throw std::runtime_error("Library not loaded!");
2010 }
2011}
2012
2013inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Hysteresis_Get(peak_afl_controller_handle controller, uint8_t * hysteresis)
2014{
2015 auto& inst = instance();
2016 if(inst.m_peak_afl_AutoController_Hysteresis_Get)
2017 {
2018 return inst.m_peak_afl_AutoController_Hysteresis_Get(controller, hysteresis);
2019 }
2020 else
2021 {
2022 throw std::runtime_error("Library not loaded!");
2023 }
2024}
2025
2026inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_Hysteresis_GetRange(peak_afl_controller_handle controller, uint8_t * min, uint8_t * max, uint8_t * inc)
2027{
2028 auto& inst = instance();
2029 if(inst.m_peak_afl_AutoController_Hysteresis_GetRange)
2030 {
2031 return inst.m_peak_afl_AutoController_Hysteresis_GetRange(controller, min, max, inc);
2032 }
2033 else
2034 {
2035 throw std::runtime_error("Library not loaded!");
2036 }
2037}
2038
2039inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainLimit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 * supported)
2040{
2041 auto& inst = instance();
2042 if(inst.m_peak_afl_AutoController_GainLimit_IsSupported)
2043 {
2044 return inst.m_peak_afl_AutoController_GainLimit_IsSupported(controller, supported);
2045 }
2046 else
2047 {
2048 throw std::runtime_error("Library not loaded!");
2049 }
2050}
2051
2052inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
2053{
2054 auto& inst = instance();
2055 if(inst.m_peak_afl_AutoController_GainLimit_Set)
2056 {
2057 return inst.m_peak_afl_AutoController_GainLimit_Set(controller, limit);
2058 }
2059 else
2060 {
2061 throw std::runtime_error("Library not loaded!");
2062 }
2063}
2064
2065inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2066{
2067 auto& inst = instance();
2068 if(inst.m_peak_afl_AutoController_GainLimit_Get)
2069 {
2070 return inst.m_peak_afl_AutoController_GainLimit_Get(controller, limit);
2071 }
2072 else
2073 {
2074 throw std::runtime_error("Library not loaded!");
2075 }
2076}
2077
2078inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2079{
2080 auto& inst = instance();
2081 if(inst.m_peak_afl_AutoController_GainLimit_GetRange)
2082 {
2083 return inst.m_peak_afl_AutoController_GainLimit_GetRange(controller, limit);
2084 }
2085 else
2086 {
2087 throw std::runtime_error("Library not loaded!");
2088 }
2089}
2090
2091inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainAnalogLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
2092{
2093 auto& inst = instance();
2094 if(inst.m_peak_afl_AutoController_GainAnalogLimit_Set)
2095 {
2096 return inst.m_peak_afl_AutoController_GainAnalogLimit_Set(controller, limit);
2097 }
2098 else
2099 {
2100 throw std::runtime_error("Library not loaded!");
2101 }
2102}
2103
2104inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainAnalogLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2105{
2106 auto& inst = instance();
2107 if(inst.m_peak_afl_AutoController_GainAnalogLimit_Get)
2108 {
2109 return inst.m_peak_afl_AutoController_GainAnalogLimit_Get(controller, limit);
2110 }
2111 else
2112 {
2113 throw std::runtime_error("Library not loaded!");
2114 }
2115}
2116
2117inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainAnalogLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2118{
2119 auto& inst = instance();
2120 if(inst.m_peak_afl_AutoController_GainAnalogLimit_GetRange)
2121 {
2122 return inst.m_peak_afl_AutoController_GainAnalogLimit_GetRange(controller, limit);
2123 }
2124 else
2125 {
2126 throw std::runtime_error("Library not loaded!");
2127 }
2128}
2129
2130inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainDigitalLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
2131{
2132 auto& inst = instance();
2133 if(inst.m_peak_afl_AutoController_GainDigitalLimit_Set)
2134 {
2135 return inst.m_peak_afl_AutoController_GainDigitalLimit_Set(controller, limit);
2136 }
2137 else
2138 {
2139 throw std::runtime_error("Library not loaded!");
2140 }
2141}
2142
2143inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainDigitalLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2144{
2145 auto& inst = instance();
2146 if(inst.m_peak_afl_AutoController_GainDigitalLimit_Get)
2147 {
2148 return inst.m_peak_afl_AutoController_GainDigitalLimit_Get(controller, limit);
2149 }
2150 else
2151 {
2152 throw std::runtime_error("Library not loaded!");
2153 }
2154}
2155
2156inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainDigitalLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2157{
2158 auto& inst = instance();
2159 if(inst.m_peak_afl_AutoController_GainDigitalLimit_GetRange)
2160 {
2161 return inst.m_peak_afl_AutoController_GainDigitalLimit_GetRange(controller, limit);
2162 }
2163 else
2164 {
2165 throw std::runtime_error("Library not loaded!");
2166 }
2167}
2168
2169inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainCombinedLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
2170{
2171 auto& inst = instance();
2172 if(inst.m_peak_afl_AutoController_GainCombinedLimit_Set)
2173 {
2174 return inst.m_peak_afl_AutoController_GainCombinedLimit_Set(controller, limit);
2175 }
2176 else
2177 {
2178 throw std::runtime_error("Library not loaded!");
2179 }
2180}
2181
2182inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainCombinedLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2183{
2184 auto& inst = instance();
2185 if(inst.m_peak_afl_AutoController_GainCombinedLimit_Get)
2186 {
2187 return inst.m_peak_afl_AutoController_GainCombinedLimit_Get(controller, limit);
2188 }
2189 else
2190 {
2191 throw std::runtime_error("Library not loaded!");
2192 }
2193}
2194
2195inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainCombinedLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2196{
2197 auto& inst = instance();
2198 if(inst.m_peak_afl_AutoController_GainCombinedLimit_GetRange)
2199 {
2200 return inst.m_peak_afl_AutoController_GainCombinedLimit_GetRange(controller, limit);
2201 }
2202 else
2203 {
2204 throw std::runtime_error("Library not loaded!");
2205 }
2206}
2207
2208inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainHostLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
2209{
2210 auto& inst = instance();
2211 if(inst.m_peak_afl_AutoController_GainHostLimit_Set)
2212 {
2213 return inst.m_peak_afl_AutoController_GainHostLimit_Set(controller, limit);
2214 }
2215 else
2216 {
2217 throw std::runtime_error("Library not loaded!");
2218 }
2219}
2220
2221inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainHostLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2222{
2223 auto& inst = instance();
2224 if(inst.m_peak_afl_AutoController_GainHostLimit_Get)
2225 {
2226 return inst.m_peak_afl_AutoController_GainHostLimit_Get(controller, limit);
2227 }
2228 else
2229 {
2230 throw std::runtime_error("Library not loaded!");
2231 }
2232}
2233
2234inline PEAK_AFL_API_STATUS DynamicLoader::peak_afl_AutoController_GainHostLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit * limit)
2235{
2236 auto& inst = instance();
2237 if(inst.m_peak_afl_AutoController_GainHostLimit_GetRange)
2238 {
2239 return inst.m_peak_afl_AutoController_GainHostLimit_GetRange(controller, limit);
2240 }
2241 else
2242 {
2243 throw std::runtime_error("Library not loaded!");
2244 }
2245}
2246
2247} /* namespace dynamic */
2248} /* namespace afl */
2249} /* namespace peak */
peak_afl_AutoController_ExposureLimit_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_ExposureLimit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if exposure limit is supported for a controller.
peak_afl_AutoController_GainAnalogLimit_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_GainAnalogLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature analog gain limit for a controller.
peak_afl_AutoController_AutoTarget_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTarget_GetRange(peak_afl_controller_handle controller, uint32_t *min, uint32_t *max, uint32_t *inc)
Get the auto target range for a controller.
peak_afl_AutoController_Limit_Default
PEAK_AFL_API_STATUS peak_afl_AutoController_Limit_Default(peak_afl_controller_handle controller, peak_afl_controller_limit *limit)
Get the autofeature default limit.
peak_afl_AutoController_AutoPercentile_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoPercentile_GetRange(peak_afl_controller_handle controller, double *min, double *max, double *inc)
Get the auto percentile range for a controller.
peak_afl_AutoController_GainAnalogLimit_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_GainAnalogLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature analog gain limit range for a controller.
peak_afl_AutoController_BrightnessComponent_Callback_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Callback_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_callback_type type, void *funcPtr, void *context)
Set a callback for a controller component.
peak_afl_AutoController_SkipFrames_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_SkipFrames_GetRange(peak_afl_controller_handle controller, uint32_t *min, uint32_t *max, uint32_t *inc)
Get range for frames skipped for a controller.
peak_afl_AutoController_Hysteresis_Default
PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_Default(peak_afl_controller_handle controller, uint8_t *hysteresis)
Get the autofeature hysteresis default.
peak_afl_AutoController_Mode_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_Mode_Get(peak_afl_controller_handle controller, peak_afl_controller_automode *mode)
Get the current autofeature mode for a controller.
peak_afl_callback_type
peak_afl_callback_type
controller callback type
Definition peak_afl.h:287
peak_afl_AutoController_AutoPercentile_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoPercentile_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
check if auto percentile is supported for a controller.
peak_afl_AutoController_GainCombinedLimit_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_GainCombinedLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
Set autofeature combined gain limit for a controller.
peak_afl_controllerType
peak_afl_controllerType
controller types
Definition peak_afl.h:125
peak_afl_AutoController_BrightnessComponent_Status
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Status(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_status *status)
Get the status for a controller component.
peak_afl_controller_brightness_component
peak_afl_controller_brightness_component
controller brightness component
Definition peak_afl.h:245
peak_afl_AutoController_BrightnessAlgorithm_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessAlgorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_algorithm algorithm)
Set the brightness algorithm for a controller.
peak_afl_AutoController_Algorithm_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_Algorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_algorithm *algorithm)
Get the used algorithm for a controller.
peak_afl_AutoController_BrightnessComponent_Mode_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Mode_Get(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_automode *mode)
Get the current brightness component mode for a controller.
peak_afl_controller_automode
peak_afl_controller_automode
controller automode
Definition peak_afl.h:144
peak_afl_AutoController_AutoTarget_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTarget_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
check if auto target is supported for a controller.
peak_afl_AutoController_Limit_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_Limit_Get(peak_afl_controller_handle controller, peak_afl_controller_limit *limit)
Get the autofeature limit for a controller.
peak_afl_AutoController_Status
PEAK_AFL_API_STATUS peak_afl_AutoController_Status(peak_afl_controller_handle controller, peak_afl_controller_status *status)
Get the status for a controller.
peak_afl_roi_preset
peak_afl_roi_preset
controller roi preset
Definition peak_afl.h:312
peak_afl_AutoController_AutoTarget_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTarget_Get(peak_afl_controller_handle controller, uint32_t *target)
Get the currently set auto target for a controller.
peak_afl_AutoController_GainLimit_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_GainLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
Set autofeature gain limit for a controller.
peak_afl_AutoController_SharpnessAlgorithm_GetList
PEAK_AFL_API_STATUS peak_afl_AutoController_SharpnessAlgorithm_GetList(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm *typeList, uint32_t *listSize)
Get the list of supported sharpness algorithms for a controller.
peak_afl_AutoController_GainLimit_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_GainLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature gain limit range for a controller.
peak_afl_AutoController_SkipFrames_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_SkipFrames_Set(peak_afl_controller_handle controller, uint32_t count)
Set number of frames skipped for a controller.
peak_afl_AutoController_GainHostLimit_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_GainHostLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature host gain limit for a controller.
peak_afl_AutoController_SkipFrames_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_SkipFrames_Get(peak_afl_controller_handle controller, uint32_t *count)
Get number of frames skipped for a controller.
peak_afl_AutoController_AutoTolerance_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTolerance_Set(peak_afl_controller_handle controller, uint32_t tolerance)
Set the auto tolerance for a controller.
peak_afl_AutoController_Weighted_ROI_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_Weighted_ROI_Set(peak_afl_controller_handle controller, const peak_afl_weighted_rectangle *weightedRoiList, uint32_t listSize)
Set the autofeature weighted region of interest for a controller.
peak_afl_AutoController_ROI_Preset_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_Preset_Set(peak_afl_controller_handle controller, peak_afl_roi_preset roiPreset)
Set the autofeature region of interest preset for a controller.
peak_afl_controller_brightness_algorithm
peak_afl_controller_brightness_algorithm
brightness calculation algorithm
Definition peak_afl.h:210
peak_afl_AutoController_Hysteresis_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_Set(peak_afl_controller_handle controller, uint8_t hysteresis)
Set the autofeature hysteresis for a controller.
peak_afl_AutoController_Weighted_ROI_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_Weighted_ROI_Get(peak_afl_controller_handle controller, peak_afl_weighted_rectangle *weightedRoiList, uint32_t *listSize)
Get the autofeature weighted region of interest for a controller.
peak_afl_AutoController_Mode_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_Mode_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if auto mode is supported for a controller.
peak_afl_AutoController_SkipFrames_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_SkipFrames_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if skip frames is supported for a controller.
peak_afl_AutoController_Mode_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_Mode_Set(peak_afl_controller_handle controller, peak_afl_controller_automode mode)
Set the autofeature mode for a controller.
peak_afl_AutoController_ROI_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_Get(peak_afl_controller_handle controller, peak_afl_rectangle *roi)
Get the autofeature region of interest for a controller.
peak_afl_AutoController_ExposureLimit_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_ExposureLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
Set autofeature exposure limit for a controller.
peak_afl_AutoController_Callback_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_Callback_Set(peak_afl_controller_handle controller, peak_afl_callback_type type, void *funcPtr, void *context)
Set a callback for a controller.
peak_afl_AutoController_Hysteresis_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_Get(peak_afl_controller_handle controller, uint8_t *hysteresis)
Get the autofeature hysteresis for a controller.
peak_afl_AutoController_Hysteresis_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if hysteresis is supported for a controller.
peak_afl_AutoController_ROI_Preset_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_Preset_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if ROI preset is supported for a controller.
peak_afl_controller_status
peak_afl_controller_status
controller status
Definition peak_afl.h:160
peak_afl_AutoController_AutoTolerance_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTolerance_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
check if auto tolerance is supported for a controller.
peak_afl_AutoController_ExposureLimit_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_ExposureLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature exposure limit for a controller.
peak_afl_AutoController_Create
PEAK_AFL_API_STATUS peak_afl_AutoController_Create(peak_afl_controller_handle *controller, peak_afl_controllerType controllerType)
Create a new controller.
peak_afl_AutoController_BrightnessComponent_Mode_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Mode_Set(peak_afl_controller_handle controller, peak_afl_controller_brightness_component component, peak_afl_controller_automode mode)
Set the autofeature mode for a brightness component.
peak_afl_AutoController_SharpnessAlgorithm_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_SharpnessAlgorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm algorithm)
Set the used sharpness algorithm for a controller.
peak_afl_AutoController_BrightnessAlgorithm_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessAlgorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_brightness_algorithm *algorithm)
Get the current brightness algorithm for a controller.
peak_afl_AutoController_Weighted_ROI_Min_Size
PEAK_AFL_API_STATUS peak_afl_AutoController_Weighted_ROI_Min_Size(peak_afl_controller_handle controller, peak_afl_size *size)
Get the autofeature minimum size for the weighted region of interest for a controller.
peak_afl_AutoController_Weighted_ROI_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_Weighted_ROI_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if weighted region of interest is supported for a controller.
peak_afl_controller_algorithm
peak_afl_controller_algorithm
controller algorithm
Definition peak_afl.h:188
peak_afl_AutoController_AutoPercentile_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoPercentile_Set(peak_afl_controller_handle controller, double percentile)
Set the auto percentile for a controller.
peak_afl_AutoController_Algorithm_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_Algorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
check if setting an algorithm is supported for a controller.
peak_afl_AutoController_Limit_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_Limit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if limit is supported for a controller.
peak_afl_controller_sharpness_algorithm
peak_afl_controller_sharpness_algorithm
controller sharpness algorithm (focus)
Definition peak_afl.h:223
peak_afl_AutoController_GetLastAutoAverage
PEAK_AFL_API_STATUS peak_afl_AutoController_GetLastAutoAverage(peak_afl_controller_handle controller, uint8_t *average)
Get the last auto average for a controller.
peak_afl_AutoController_BrightnessComponent_Unit_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Unit_IsSupported(peak_afl_controller_handle controller, peak_afl_controller_brightness_component unit, peak_afl_BOOL8 *supported)
Check if a specific unit is supported for a brightness controller.
peak_afl_AutoController_GainDigitalLimit_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_GainDigitalLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature digital gain limit range for a controller.
peak_afl_AutoController_GetLastAutoAverages
PEAK_AFL_API_STATUS peak_afl_AutoController_GetLastAutoAverages(peak_afl_controller_handle controller, uint8_t *averageRed, uint8_t *averageGreen, uint8_t *averageBlue)
Get the last auto average for a controller.
peak_afl_AutoController_AutoTarget_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTarget_Set(peak_afl_controller_handle controller, uint32_t target)
Set the auto target for a controller.
peak_afl_AutoController_ROI_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_Set(peak_afl_controller_handle controller, peak_afl_rectangle roi)
Set the autofeature region of interest for a controller.
peak_afl_AutoController_Type_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_Type_Get(peak_afl_controller_handle controller, peak_afl_controllerType *type)
Get the controller type.
peak_afl_AutoController_GainAnalogLimit_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_GainAnalogLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
Set autofeature analog gain limit for a controller.
peak_afl_AutoController_Hysteresis_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_Hysteresis_GetRange(peak_afl_controller_handle controller, uint8_t *min, uint8_t *max, uint8_t *inc)
Get autofeature hysteresis range for a controller.
peak_afl_AutoController_Destroy
PEAK_AFL_API_STATUS peak_afl_AutoController_Destroy(peak_afl_controller_handle controller)
Destroy a controller. Will fail if it is queued inside a manager.
peak_afl_AutoController_AutoTolerance_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTolerance_GetRange(peak_afl_controller_handle controller, uint32_t *min, uint32_t *max, uint32_t *inc)
Get the auto tolerance range for a controller.
peak_afl_AutoController_Algorithm_GetList
PEAK_AFL_API_STATUS peak_afl_AutoController_Algorithm_GetList(peak_afl_controller_handle controller, peak_afl_controller_algorithm *typeList, uint32_t *listSize)
Get the list of supported algorithms for a controller.
peak_afl_AutoController_AutoTolerance_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoTolerance_Get(peak_afl_controller_handle controller, uint32_t *tolerance)
Get the current auto tolerance for a controller.
peak_afl_AutoController_AutoPercentile_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_AutoPercentile_Get(peak_afl_controller_handle controller, double *percentile)
Get the auto percentile for a controller.
peak_afl_AutoController_SharpnessAlgorithm_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_SharpnessAlgorithm_Get(peak_afl_controller_handle controller, peak_afl_controller_sharpness_algorithm *algorithm)
Get the used sharpness algorithm for a controller.
peak_afl_AutoController_GainCombinedLimit_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_GainCombinedLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature combined gain limit range for a controller.
peak_afl_AutoController_GainDigitalLimit_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_GainDigitalLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature digital gain limit for a controller.
peak_afl_AutoController_ROI_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_ROI_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if setting a region of interest is supported for a controller.
peak_afl_AutoController_BrightnessAlgorithm_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessAlgorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if brightness algorithm is supported for a controller component.
peak_afl_AutoController_GainDigitalLimit_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_GainDigitalLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
Set autofeature digital gain limit for a controller.
peak_afl_AutoController_BrightnessComponent_Mode_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_BrightnessComponent_Mode_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if brightness component mode is supported for a controller component.
peak_afl_AutoController_Algorithm_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_Algorithm_Set(peak_afl_controller_handle controller, peak_afl_controller_algorithm algorithm)
Set the used algorithm for a controller.
peak_afl_AutoController_SharpnessAlgorithm_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_SharpnessAlgorithm_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
check setting a sharpness algorithm is supported by a controller.
peak_afl_AutoController_Limit_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_Limit_Set(peak_afl_controller_handle controller, peak_afl_controller_limit limit)
Set the autofeature limit for a controller.
peak_afl_AutoController_GainCombinedLimit_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_GainCombinedLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature combined gain limit for a controller.
peak_afl_AutoController_GainLimit_IsSupported
PEAK_AFL_API_STATUS peak_afl_AutoController_GainLimit_IsSupported(peak_afl_controller_handle controller, peak_afl_BOOL8 *supported)
Check if gain limit is supported for a controller.
peak_afl_AutoController_GainLimit_Get
PEAK_AFL_API_STATUS peak_afl_AutoController_GainLimit_Get(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature gain limit for a controller.
peak_afl_AutoController_GainHostLimit_Set
PEAK_AFL_API_STATUS peak_afl_AutoController_GainHostLimit_Set(peak_afl_controller_handle controller, peak_afl_double_limit limit)
Set autofeature host gain limit for a controller.
peak_afl_AutoController_GainHostLimit_GetRange
PEAK_AFL_API_STATUS peak_afl_AutoController_GainHostLimit_GetRange(peak_afl_controller_handle controller, peak_afl_double_limit *limit)
Get autofeature host gain limit range for a controller.
peak_afl_AutoFeatureManager_Create
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_Create(peak_afl_manager_handle *handle, PEAK_NODE_MAP_HANDLE nodeMapHandle)
Create an automanager instance.
peak_afl_AutoFeatureManager_CreateController
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_CreateController(peak_afl_manager_handle handle, peak_afl_controller_handle *controller, peak_afl_controllerType controllerType)
Create a controller and append it to Manager.
peak_afl_AutoFeatureManager_Process
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_Process(peak_afl_manager_handle handle, PEAK_IPL_IMAGE_HANDLE imageHandle)
Process an image.
peak_afl_AutoFeatureManager_DestroyController
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_DestroyController(peak_afl_manager_handle handle, peak_afl_controller_handle controller)
Destroy a controller.
peak_afl_AutoFeatureManager_Status
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_Status(peak_afl_manager_handle handle, peak_afl_BOOL8 *running)
Get the status of a manager.
peak_afl_AutoFeatureManager_Destroy
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_Destroy(peak_afl_manager_handle handle)
Destroy an automanager instance.
peak_afl_AutoFeatureManager_DestroyAllController
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_DestroyAllController(peak_afl_manager_handle handle)
Destroy all controllers for a manager.
peak_afl_AutoFeatureManager_AddController
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_AddController(peak_afl_manager_handle handle, peak_afl_manager_handle controller)
Add a controller to an auto manager instance.
peak_afl_AutoFeatureManager_RemoveController
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_RemoveController(peak_afl_manager_handle handle, peak_afl_manager_handle controller)
Remove a controller to an automanager instance.
peak_afl_AutoFeatureManager_SetGainIPL
PEAK_AFL_API_STATUS peak_afl_AutoFeatureManager_SetGainIPL(peak_afl_manager_handle handle, PEAK_IPL_GAIN_HANDLE gainHandle)
Set the IPL Gain.
peak_afl_Init
PEAK_AFL_API_STATUS peak_afl_Init(void)
Init the peak_afl auto feature library.
peak_afl_Exit
PEAK_AFL_API_STATUS peak_afl_Exit(void)
Exit the peak_afl auto feature library.
peak_afl_GetVersion
PEAK_AFL_API_STATUS peak_afl_GetVersion(uint32_t *majorVersion, uint32_t *minorVersion, uint32_t *subminorVersion, uint32_t *patchVersion)
Query the library version.
peak_afl_GetLastError
PEAK_AFL_API_STATUS peak_afl_GetLastError(peak_afl_status *lastErrorCode, char *lastErrorMessage, size_t *lastErrorMessageSize)
Get the last error message.
peak_afl_status
peak_afl_status
peak_afl Status codes
Definition peak_afl.h:88
peak_afl.h
peak_afl_controller_handle
void * peak_afl_controller_handle
opaque controller handle type
Definition peak_afl.h:49
peak_afl_manager_handle
void * peak_afl_manager_handle
opaque manager handle type
Definition peak_afl.h:51
peak_afl_BOOL8
uint8_t peak_afl_BOOL8
custom boolean type
Definition peak_afl.h:422
peak_afl_controller_limit
peak_afl Focus Limit
Definition peak_afl.h:398
peak_afl_double_limit
peak_afl Double Limit
Definition peak_afl.h:414
peak_afl_rectangle
peak_afl Rectangle (2D)
Definition peak_afl.h:360
peak_afl_size
peak_afl Size (2D)
Definition peak_afl.h:326
peak_afl_weighted_rectangle
peak_afl Focus Rectangle
Definition peak_afl.h:382