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