OpenScanDeviceLib.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
#define OScDevInternal_MAKE_VERSION(major, minor)                             \
    (((uint32_t)(major) << 16) | (uint16_t)(minor))
 
 
#define OScDevInternal_ABI_VERSION OScDevInternal_MAKE_VERSION(13, 0)
 
// Forward declarations for types defined later in this header
typedef struct OScDev_ModuleImpl OScDev_ModuleImpl;
typedef struct OScDev_DeviceImpl OScDev_DeviceImpl;
typedef struct OScDev_SettingImpl OScDev_SettingImpl;
 
#define OScDev_MAX_STR_SIZE 512
 
#define OScDev_MAX_STR_LEN (OScDev_MAX_STR_SIZE - 1)
 
// Declarations for opaque data types accessed through device interface
// functions.
typedef struct OScInternal_Device OScDev_Device;
typedef struct OScInternal_Setting OScDev_Setting;
typedef struct OScInternal_AcquisitionForDevice OScDev_Acquisition;
typedef struct RERR_Error OScDev_RichError;
#define OScDev_RichError_OK ((OScDev_RichError *)NULL)
 
typedef int32_t OScDev_LogLevel;
 
enum {
    OScDev_LogLevel_Debug,
    OScDev_LogLevel_Info,
    OScDev_LogLevel_Warning,
    OScDev_LogLevel_Error,
};
 
typedef int32_t OScDev_ErrorCodeFormat;
enum {
    OScDev_ErrorCodeFormat_I32 = 1,   
    OScDev_ErrorCodeFormat_U32 = 2,   
    OScDev_ErrorCodeFormat_Hex32 = 4, 
    OScDev_ErrorCodeFormat_I16 = 8,   
    OScDev_ErrorCodeFormat_U16 = 16,  
    OScDev_ErrorCodeFormat_Hex16 =
        32, 
 
    OScDev_ErrorCodeFormat_HexNoPad = 1 << 31,
};
 
 
typedef int32_t OScDev_Error;
enum {
    OScDev_OK = 0,
 
    // WARNING: Do not edit these without correctly incrementing the device
    // interface version.
    OScDev_Error_Unknown = 10000,
    OScDev_Error_Unsupported_Operation,
    OScDev_Error_Illegal_Argument,
    OScDev_Error_Device_Module_Already_Exists,
    OScDev_Error_No_Such_Device_Module,
    OScDev_Error_Driver_Not_Available,
    OScDev_Error_Device_Already_Open,
    OScDev_Error_Device_Not_Opened_For_LSM,
    OScDev_Error_Device_Does_Not_Support_Clock,
    OScDev_Error_Device_Does_Not_Support_Scanner,
    OScDev_Error_Device_Does_Not_Support_Detector,
    OScDev_Error_Wrong_Value_Type,
    OScDev_Error_Setting_Not_Writable,
    OScDev_Error_Wrong_Constraint_Type,
    OScDev_Error_Unknown_Enum_Value_Name,
    OScDev_Error_Acquisition_Running,
    OScDev_Error_Not_Armed,
    OScDev_Error_Waveform_Out_Of_Range,
    OScDev_Error_Waveform_Memory_Size_Mismatch,
    OScDev_Error_Data_Left_In_Fifo_After_Reading_Image,
};
 
 
#define OScDev_CHECK(err, call) ((err = (call)) != OScDev_OK)
 
// Note: There is no OScDev_RETURN_IF_ERROR macro because it tends to
// encourage poor coding practices. Often, locally allocated resources need to
// be freed before returning with an error.
 
typedef int32_t OScDev_TriggerSource;
enum {
    OScDev_TriggerSource_Software,
    OScDev_TriggerSource_External,
};
 
typedef int32_t OScDev_ClockSource;
enum {
    OScDev_ClockSource_Internal,
    OScDev_ClockSource_External,
};
 
typedef int32_t OScDev_ValueType;
enum {
    OScDev_ValueType_String,
    OScDev_ValueType_Bool,
    OScDev_ValueType_Int32,
    OScDev_ValueType_Float64,
    OScDev_ValueType_Enum,
};
 
typedef int32_t OScDev_ValueConstraint;
enum {
    OScDev_ValueConstraint_None,
    OScDev_ValueConstraint_DiscreteValues,
    OScDev_ValueConstraint_Range,
};
 
 
typedef struct OScInternal_PtrArray OScDev_PtrArray;
 
 
typedef struct OScInternal_NumArray OScDev_NumArray;
 
 
typedef struct OScInternal_NumRange OScDev_NumRange;
 
 
#ifndef OScDevInternal_BUILDING_OPENSCANLIB
 
 
extern struct OScDevInternal_Interface *OScDevInternal_FunctionTable;
 
 
extern OScDev_ModuleImpl OScDevInternal_TheModuleImpl;
 
#endif
 
 
#define OScDev_MODULE_IMPL OScDev_ModuleImpl OScDevInternal_TheModuleImpl
 
 
struct OScDevInternal_Interface {
    // All functions take a pointer to the module implementation, even if not
    // needed in the implementation, because it may help with debugging.
 
    void (*Log)(OScDev_ModuleImpl *modImpl, OScDev_Device *device,
                OScDev_LogLevel level, const char *message);
 
    OScDev_RichError *(*Error_RegisterCodeDomain)(
        OScDev_ModuleImpl *modImpl, const char *domainName,
        OScDev_ErrorCodeFormat codeFormat);
    OScDev_Error (*Error_ReturnAsCode)(OScDev_ModuleImpl *modImpl,
                                       OScDev_RichError *error);
    OScDev_RichError *(*Error_Create)(OScDev_ModuleImpl *modImpl,
                                      const char *message);
    OScDev_RichError *(*Error_CreateWithCode)(OScDev_ModuleImpl *modImpl,
                                              const char *domainName,
                                              OScDev_Error code,
                                              const char *message);
    OScDev_RichError *(*Error_Wrap)(OScDev_ModuleImpl *modImpl,
                                    OScDev_RichError *cause,
                                    const char *message);
    OScDev_RichError *(*Error_WrapWithCode)(OScDev_ModuleImpl *modImpl,
                                            OScDev_RichError *cause,
                                            const char *domainName,
                                            int32_t code, const char *message);
 
    const char *(*Error_GetMessage)(OScDev_ModuleImpl *modImpl,
                                    OScDev_RichError *error);
    const char *(*Error_GetDomain)(OScDev_ModuleImpl *modImpl,
                                   OScDev_RichError *error);
    int32_t (*Error_GetCode)(OScDev_ModuleImpl *modImpl,
                             OScDev_RichError *error);
    OScDev_RichError *(*Error_GetCause)(OScDev_ModuleImpl *modImpl,
                                        OScDev_RichError *error);
    void (*Error_Format)(OScDev_ModuleImpl *modImpl, OScDev_RichError *error,
                         char *buffer, size_t bufsize);
    void (*Error_FormatRecursive)(OScDev_ModuleImpl *modImpl,
                                  OScDev_RichError *error, char *buffer,
                                  size_t bufsize);
    OScDev_RichError *(*Error_AsRichError)(OScDev_ModuleImpl *modImpl,
                                           OScDev_Error code);
    void (*Error_Destroy)(OScDev_ModuleImpl *modImpl, OScDev_RichError *error);
 
    OScDev_PtrArray *(*PtrArray_Create)(OScDev_ModuleImpl *modImpl);
    OScDev_PtrArray *(*PtrArray_CreateFromNullTerminated)(
        OScDev_ModuleImpl *modImpl, void *const *nullTerminatedArray);
    void (*PtrArray_Destroy)(OScDev_ModuleImpl *modImpl,
                             const OScDev_PtrArray *arr);
    void (*PtrArray_Append)(OScDev_ModuleImpl *modImpl, OScDev_PtrArray *arr,
                            void *obj);
    size_t (*PtrArray_Size)(OScDev_ModuleImpl *modImpl,
                            const OScDev_PtrArray *arr);
    bool (*PtrArray_Empty)(OScDev_ModuleImpl *modImpl,
                           const OScDev_PtrArray *arr);
    void *(*PtrArray_At)(OScDev_ModuleImpl *modImpl,
                         const OScDev_PtrArray *arr, size_t index);
 
    OScDev_NumArray *(*NumArray_Create)(OScDev_ModuleImpl *modImpl);
    OScDev_NumArray *(*NumArray_CreateFromNaNTerminated)(
        OScDev_ModuleImpl *modImpl, const double *nanTerminatedArray);
    void (*NumArray_Destroy)(OScDev_ModuleImpl *modImpl,
                             const OScDev_NumArray *arr);
    void (*NumArray_Append)(OScDev_ModuleImpl *modImpl, OScDev_NumArray *arr,
                            double val);
    size_t (*NumArray_Size)(OScDev_ModuleImpl *modImpl,
                            const OScDev_NumArray *arr);
    bool (*NumArray_Empty)(OScDev_ModuleImpl *modImpl,
                           const OScDev_NumArray *arr);
    double (*NumArray_At)(OScDev_ModuleImpl *modImpl,
                          const OScDev_NumArray *arr, size_t index);
 
    OScDev_NumRange *(*NumRange_CreateContinuous)(OScDev_ModuleImpl *modImpl,
                                                  double rMin, double rMax);
    OScDev_NumRange *(*NumRange_CreateDiscrete)(OScDev_ModuleImpl *modImpl);
    OScDev_NumRange *(*NumRange_CreateDiscreteFromNaNTerminated)(
        OScDev_ModuleImpl *modImpl, const double *nanTerminatedArray);
    void (*NumRange_Destroy)(OScDev_ModuleImpl *modImpl,
                             const OScDev_NumRange *range);
    void (*NumRange_AppendDiscrete)(OScDev_ModuleImpl *modImpl,
                                    OScDev_NumRange *range, double val);
 
    OScDev_Error (*Device_Create)(OScDev_ModuleImpl *modImpl,
                                  OScDev_Device **device,
                                  OScDev_DeviceImpl *impl, void *data);
    void *(*Device_GetImplData)(OScDev_ModuleImpl *modImpl,
                                OScDev_Device *device);
 
    OScDev_Error (*Setting_Create)(OScDev_ModuleImpl *modImpl,
                                   OScDev_Setting **setting, const char *name,
                                   OScDev_ValueType valueType,
                                   OScDev_SettingImpl *impl, void *data);
    void (*Setting_Destroy)(OScDev_ModuleImpl *modImpl,
                            OScDev_Setting *setting);
    void *(*Setting_GetImplData)(OScDev_ModuleImpl *modImpl,
                                 OScDev_Setting *setting);
 
    // TODO These can return void
    OScDev_Error (*Acquisition_IsClockRequested)(OScDev_ModuleImpl *modImpl,
                                                 OScDev_Acquisition *acq,
                                                 bool *isRequested);
    OScDev_Error (*Acquisition_IsScannerRequested)(OScDev_ModuleImpl *modImpl,
                                                   OScDev_Acquisition *acq,
                                                   bool *isRequested);
    OScDev_Error (*Acquisition_IsDetectorRequested)(OScDev_ModuleImpl *modImpl,
                                                    OScDev_Acquisition *acq,
                                                    bool *isRequested);
    OScDev_Error (*Acquisition_GetClockStartTriggerSource)(
        OScDev_ModuleImpl *modImpl, OScDev_Acquisition *acq,
        OScDev_TriggerSource *startTrigger);
    OScDev_Error (*Acquisition_GetClockSource)(OScDev_ModuleImpl *modImpl,
                                               OScDev_Acquisition *acq,
                                               OScDev_ClockSource *clock);
 
    uint32_t (*Acquisition_GetNumberOfFrames)(OScDev_ModuleImpl *modImpl,
                                              OScDev_Acquisition *acq);
    double (*Acquisition_GetPixelRate)(OScDev_ModuleImpl *modImpl,
                                       OScDev_Acquisition *acq);
    uint32_t (*Acquisition_GetResolution)(OScDev_ModuleImpl *modImpl,
                                          OScDev_Acquisition *acq);
    double (*Acquisition_GetZoomFactor)(OScDev_ModuleImpl *modImpl,
                                        OScDev_Acquisition *acq);
    void (*Acquisition_GetROI)(OScDev_ModuleImpl *modImpl,
                               OScDev_Acquisition *acq, uint32_t *xOffset,
                               uint32_t *yOffset, uint32_t *width,
                               uint32_t *height);
 
    bool (*Acquisition_CallFrameCallback)(OScDev_ModuleImpl *modImpl,
                                          OScDev_Acquisition *acq,
                                          uint32_t channel, void *pixels);
};
 
 
struct OScDev_ModuleImpl {
 
    const char *displayName;
 
    /*
     * This flag determines how the device module reports errors.
     * If false, the device module uses conventional integer error codes.
     * If true, all errors generated by the device module should be rich
     * errors, and they should be returned by converting to temporary integer
     * codes via OScDev_Error_ReturnAsCode(). All new device modules should set
     * this to true.
     */
    const bool supportsRichErrors;
 
 
    OScDev_Error (*Open)(void);
 
 
    OScDev_Error (*Close)(void);
 
 
    OScDev_Error (*GetDeviceImpls)(OScDev_PtrArray **deviceImpls);
};
 
struct OScDev_DeviceImpl {
    OScDev_Error (*GetModelName)(const char **name);
 
 
    OScDev_Error (*EnumerateInstances)(OScDev_PtrArray **devices);
 
 
    OScDev_Error (*ReleaseInstance)(OScDev_Device *device);
 
    OScDev_Error (*GetName)(OScDev_Device *device, char *name);
 
 
    OScDev_Error (*Open)(OScDev_Device *device);
 
    OScDev_Error (*Close)(OScDev_Device *device);
 
 
    OScDev_Error (*HasClock)(OScDev_Device *device, bool *hasClock);
 
    OScDev_Error (*HasScanner)(OScDev_Device *device, bool *hasScanner);
 
    OScDev_Error (*HasDetector)(OScDev_Device *device, bool *hasDetector);
 
    OScDev_Error (*MakeSettings)(OScDev_Device *device,
                                 OScDev_PtrArray **settings);
 
 
    OScDev_Error (*GetPixelRates)(OScDev_Device *device,
                                  OScDev_NumRange **pixelRatesHz);
 
 
    OScDev_Error (*GetActualPixelRate)(OScDev_Device *device,
                                       double nominalRateHz,
                                       double *actualRateHz);
 
 
    OScDev_Error (*GetResolutions)(OScDev_Device *device,
                                   OScDev_NumRange **resolutions);
 
 
    OScDev_Error (*GetZoomFactors)(OScDev_Device *device,
                                   OScDev_NumRange **zooms);
 
 
    OScDev_Error (*IsROIScanSupported)(OScDev_Device *device, bool *supported);
 
 
    OScDev_Error (*GetRasterWidths)(OScDev_Device *device,
                                    OScDev_NumRange **widths);
 
 
    OScDev_Error (*GetRasterHeights)(OScDev_Device *device,
                                     OScDev_NumRange **heights);
 
 
    OScDev_Error (*GetNumberOfChannels)(OScDev_Device *device,
                                        uint32_t *nChannels);
 
 
    OScDev_Error (*GetBytesPerSample)(OScDev_Device *device,
                                      uint32_t *bytesPerSample);
 
 
    OScDev_Error (*Arm)(OScDev_Device *device, OScDev_Acquisition *acq);
 
 
    OScDev_Error (*Start)(OScDev_Device *device);
 
 
    OScDev_Error (*Stop)(OScDev_Device *device);
 
 
    OScDev_Error (*IsRunning)(OScDev_Device *device, bool *isRunning);
 
 
    OScDev_Error (*Wait)(OScDev_Device *device);
};
 
struct OScDev_SettingImpl {
    // TODO The value type should be moved inside the SettingImpl as a static
    // data field. The type-dependent fields could be placed in a union:
    //     .valueType = OScDev_ValueType_Int32,
    //     .typeImpl.int32 = {
    //         .constraintType = OScDev_ValueConstraint_Range,
    //         .Get = myGetFunc,
    //         .Set = mySetFunc,
    //         .GetRange = myRangeFunc,
    //     }
    // We can also provide static data fields for range and discrete values.
 
    OScDev_Error (*IsEnabled)(OScDev_Setting *setting, bool *enabled);
    OScDev_Error (*IsWritable)(OScDev_Setting *setting, bool *writable);
 
    OScDev_Error (*GetNumericConstraintType)(
        OScDev_Setting *setting, OScDev_ValueConstraint *constraintType);
    OScDev_Error (*GetString)(OScDev_Setting *setting, char *value);
    OScDev_Error (*SetString)(OScDev_Setting *setting, const char *value);
    OScDev_Error (*GetBool)(OScDev_Setting *setting, bool *value);
    OScDev_Error (*SetBool)(OScDev_Setting *setting, bool value);
    OScDev_Error (*GetInt32)(OScDev_Setting *setting, int32_t *value);
    OScDev_Error (*SetInt32)(OScDev_Setting *setting, int32_t value);
 
    OScDev_Error (*GetInt32Range)(OScDev_Setting *setting, int32_t *min,
                                  int32_t *max);
 
    OScDev_Error (*GetInt32DiscreteValues)(OScDev_Setting *setting,
                                           OScDev_NumArray **values);
 
    OScDev_Error (*GetFloat64)(OScDev_Setting *setting, double *value);
    OScDev_Error (*SetFloat64)(OScDev_Setting *setting, double value);
 
    OScDev_Error (*GetFloat64Range)(OScDev_Setting *setting, double *min,
                                    double *max);
 
    OScDev_Error (*GetFloat64DiscreteValues)(OScDev_Setting *setting,
                                             OScDev_NumArray **values);
    OScDev_Error (*GetEnum)(OScDev_Setting *setting, uint32_t *value);
    OScDev_Error (*SetEnum)(OScDev_Setting *setting, uint32_t value);
    OScDev_Error (*GetEnumNumValues)(OScDev_Setting *setting, uint32_t *count);
    OScDev_Error (*GetEnumNameForValue)(OScDev_Setting *setting,
                                        uint32_t value, char *name);
    OScDev_Error (*GetEnumValueForName)(OScDev_Setting *setting,
                                        uint32_t *value, const char *name);
 
    void (*Release)(OScDev_Setting *setting);
};
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#ifndef OScDevInternal_BUILDING_OPENSCANLIB
 
// Inline functions wrapping all entries in the OpenScanLib function table
//
// Use of this macro tricks Doxygen into documenting the functions even though
// they are static.
#define OScDev_API static inline
 
OScDev_API void OScDev_Log(OScDev_Device *device, OScDev_LogLevel level,
                           const char *message) {
    OScDevInternal_FunctionTable->Log(&OScDevInternal_TheModuleImpl, device,
                                      level, message);
}
 
OScDev_API void OScDev_Log_Debug(OScDev_Device *device, const char *message) {
    OScDev_Log(device, OScDev_LogLevel_Debug, message);
}
 
OScDev_API void OScDev_Log_Info(OScDev_Device *device, const char *message) {
    OScDev_Log(device, OScDev_LogLevel_Info, message);
}
 
OScDev_API void OScDev_Log_Warning(OScDev_Device *device,
                                   const char *message) {
    OScDev_Log(device, OScDev_LogLevel_Warning, message);
}
 
OScDev_API void OScDev_Log_Error(OScDev_Device *device, const char *message) {
    OScDev_Log(device, OScDev_LogLevel_Error, message);
}
 
OScDev_API OScDev_RichError *
OScDev_Error_RegisterCodeDomain(const char *domainName,
                                OScDev_ErrorCodeFormat codeFormat) {
    return OScDevInternal_FunctionTable->Error_RegisterCodeDomain(
        &OScDevInternal_TheModuleImpl, domainName, codeFormat);
}
 
OScDev_API OScDev_Error OScDev_Error_ReturnAsCode(OScDev_RichError *error) {
    return OScDevInternal_FunctionTable->Error_ReturnAsCode(
        &OScDevInternal_TheModuleImpl, error);
}
 
OScDev_API OScDev_RichError *OScDev_Error_Create(const char *message) {
    return OScDevInternal_FunctionTable->Error_Create(
        &OScDevInternal_TheModuleImpl, message);
}
 
OScDev_API OScDev_RichError *
OScDev_Error_CreateWithCode(const char *domainName, int32_t code,
                            const char *message) {
    return OScDevInternal_FunctionTable->Error_CreateWithCode(
        &OScDevInternal_TheModuleImpl, domainName, code, message);
}
 
OScDev_API OScDev_RichError *OScDev_Error_Wrap(OScDev_RichError *cause,
                                               const char *message) {
    return OScDevInternal_FunctionTable->Error_Wrap(
        &OScDevInternal_TheModuleImpl, cause, message);
}
 
OScDev_API OScDev_RichError *OScDev_Error_WrapWithCode(OScDev_RichError *cause,
                                                       const char *domainName,
                                                       int32_t code,
                                                       const char *message) {
    return OScDevInternal_FunctionTable->Error_WrapWithCode(
        &OScDevInternal_TheModuleImpl, cause, domainName, code, message);
}
 
OScDev_API const char *OScDev_Error_GetMessage(OScDev_RichError *error) {
    return OScDevInternal_FunctionTable->Error_GetMessage(
        &OScDevInternal_TheModuleImpl, error);
}
 
OScDev_API const char *OScDev_Error_GetDomain(OScDev_RichError *error) {
    return OScDevInternal_FunctionTable->Error_GetDomain(
        &OScDevInternal_TheModuleImpl, error);
}
 
OScDev_API int32_t OScDev_Error_GetCode(OScDev_RichError *error) {
    return OScDevInternal_FunctionTable->Error_GetCode(
        &OScDevInternal_TheModuleImpl, error);
}
 
OScDev_API OScDev_RichError *OScDev_Error_GetCause(OScDev_RichError *error) {
    return OScDevInternal_FunctionTable->Error_GetCause(
        &OScDevInternal_TheModuleImpl, error);
}
 
OScDev_API void OScDev_Error_Format(OScDev_RichError *error, char *buffer,
                                    size_t bufsize) {
    OScDevInternal_FunctionTable->Error_Format(&OScDevInternal_TheModuleImpl,
                                               error, buffer, bufsize);
}
 
OScDev_API void OScDev_Error_FormatRecursive(OScDev_RichError *error,
                                             char *buffer, size_t bufsize) {
    OScDevInternal_FunctionTable->Error_FormatRecursive(
        &OScDevInternal_TheModuleImpl, error, buffer, bufsize);
}
 
OScDev_API OScDev_RichError *OScDev_Error_AsRichError(OScDev_Error code) {
    return OScDevInternal_FunctionTable->Error_AsRichError(
        &OScDevInternal_TheModuleImpl, code);
}
 
OScDev_API void OScDev_Error_Destroy(OScDev_RichError *error) {
    OScDevInternal_FunctionTable->Error_Destroy(&OScDevInternal_TheModuleImpl,
                                                error);
}
 
OScDev_API OScDev_PtrArray *OScDev_PtrArray_Create(void) {
    return OScDevInternal_FunctionTable->PtrArray_Create(
        &OScDevInternal_TheModuleImpl);
}
 
OScDev_API OScDev_PtrArray *
OScDev_PtrArray_CreateFromNullTerminated(void *const *nullTerminatedArray) {
    return OScDevInternal_FunctionTable->PtrArray_CreateFromNullTerminated(
        &OScDevInternal_TheModuleImpl, nullTerminatedArray);
}
 
OScDev_API void OScDev_PtrArray_Destroy(const OScDev_PtrArray *arr) {
    OScDevInternal_FunctionTable->PtrArray_Destroy(
        &OScDevInternal_TheModuleImpl, arr);
}
 
OScDev_API void OScDev_PtrArray_Append(OScDev_PtrArray *arr, void *obj) {
    OScDevInternal_FunctionTable->PtrArray_Append(
        &OScDevInternal_TheModuleImpl, arr, obj);
}
 
OScDev_API size_t OScDev_PtrArray_Size(const OScDev_PtrArray *arr) {
    return OScDevInternal_FunctionTable->PtrArray_Size(
        &OScDevInternal_TheModuleImpl, arr);
}
 
OScDev_API bool OScDev_PtrArray_Empty(const OScDev_PtrArray *arr) {
    return OScDevInternal_FunctionTable->PtrArray_Empty(
        &OScDevInternal_TheModuleImpl, arr);
}
 
OScDev_API void *OScDev_PtrArray_At(const OScDev_PtrArray *arr, size_t index) {
    return OScDevInternal_FunctionTable->PtrArray_At(
        &OScDevInternal_TheModuleImpl, arr, index);
}
 
OScDev_API OScDev_NumArray *OScDev_NumArray_Create(void) {
    return OScDevInternal_FunctionTable->NumArray_Create(
        &OScDevInternal_TheModuleImpl);
}
 
OScDev_API OScDev_NumArray *
OScDev_NumArray_CreateFromNaNTerminated(const double *nanTerminatedArray) {
    return OScDevInternal_FunctionTable->NumArray_CreateFromNaNTerminated(
        &OScDevInternal_TheModuleImpl, nanTerminatedArray);
}
 
OScDev_API void OScDev_NumArray_Destroy(const OScDev_NumArray *arr) {
    OScDevInternal_FunctionTable->NumArray_Destroy(
        &OScDevInternal_TheModuleImpl, arr);
}
 
OScDev_API void OScDev_NumArray_Append(OScDev_NumArray *arr, double val) {
    OScDevInternal_FunctionTable->NumArray_Append(
        &OScDevInternal_TheModuleImpl, arr, val);
}
 
OScDev_API size_t OScDev_NumArray_Size(const OScDev_NumArray *arr) {
    return OScDevInternal_FunctionTable->NumArray_Size(
        &OScDevInternal_TheModuleImpl, arr);
}
 
OScDev_API bool OScDev_NumArray_Empty(const OScDev_NumArray *arr) {
    return OScDevInternal_FunctionTable->NumArray_Empty(
        &OScDevInternal_TheModuleImpl, arr);
}
 
OScDev_API double OScDev_NumArray_At(const OScDev_NumArray *arr,
                                     size_t index) {
    return OScDevInternal_FunctionTable->NumArray_At(
        &OScDevInternal_TheModuleImpl, arr, index);
}
 
OScDev_API OScDev_NumRange *OScDev_NumRange_CreateContinuous(double rMin,
                                                             double rMax) {
    return OScDevInternal_FunctionTable->NumRange_CreateContinuous(
        &OScDevInternal_TheModuleImpl, rMin, rMax);
}
 
OScDev_API OScDev_NumRange *OScDev_NumRange_CreateDiscrete(void) {
    return OScDevInternal_FunctionTable->NumRange_CreateDiscrete(
        &OScDevInternal_TheModuleImpl);
}
 
OScDev_API OScDev_NumRange *OScDev_NumRange_CreateDiscreteFromNaNTerminated(
    const double *nanTerminatedArray) {
    return OScDevInternal_FunctionTable
        ->NumRange_CreateDiscreteFromNaNTerminated(
            &OScDevInternal_TheModuleImpl, nanTerminatedArray);
}
 
OScDev_API void OScDev_NumRange_Destroy(const OScDev_NumRange *range) {
    OScDevInternal_FunctionTable->NumRange_Destroy(
        &OScDevInternal_TheModuleImpl, range);
}
 
OScDev_API void OScDev_NumRange_AppendDiscrete(OScDev_NumRange *range,
                                               double value) {
    OScDevInternal_FunctionTable->NumRange_AppendDiscrete(
        &OScDevInternal_TheModuleImpl, range, value);
}
 
OScDev_API OScDev_Error OScDev_Device_Create(OScDev_Device **device,
                                             OScDev_DeviceImpl *impl,
                                             void *data) {
    return OScDevInternal_FunctionTable->Device_Create(
        &OScDevInternal_TheModuleImpl, device, impl, data);
}
 
OScDev_API void *OScDev_Device_GetImplData(OScDev_Device *device) {
    return OScDevInternal_FunctionTable->Device_GetImplData(
        &OScDevInternal_TheModuleImpl, device);
}
 
OScDev_API OScDev_Error OScDev_Setting_Create(OScDev_Setting **setting,
                                              const char *name,
                                              OScDev_ValueType valueType,
                                              OScDev_SettingImpl *impl,
                                              void *data) {
    return OScDevInternal_FunctionTable->Setting_Create(
        &OScDevInternal_TheModuleImpl, setting, name, valueType, impl, data);
}
 
OScDev_API void OScDev_Setting_Destroy(OScDev_Setting *setting) {
    OScDevInternal_FunctionTable->Setting_Destroy(
        &OScDevInternal_TheModuleImpl, setting);
}
 
OScDev_API void *OScDev_Setting_GetImplData(OScDev_Setting *setting) {
    return OScDevInternal_FunctionTable->Setting_GetImplData(
        &OScDevInternal_TheModuleImpl, setting);
}
 
OScDev_API OScDev_Error OScDev_Acquisition_IsClockRequested(
    OScDev_Acquisition *acq, bool *isRequested) {
    return OScDevInternal_FunctionTable->Acquisition_IsClockRequested(
        &OScDevInternal_TheModuleImpl, acq, isRequested);
}
 
OScDev_API OScDev_Error OScDev_Acquisition_IsScannerRequested(
    OScDev_Acquisition *acq, bool *isRequested) {
    return OScDevInternal_FunctionTable->Acquisition_IsScannerRequested(
        &OScDevInternal_TheModuleImpl, acq, isRequested);
}
 
OScDev_API OScDev_Error OScDev_Acquisition_IsDetectorRequested(
    OScDev_Acquisition *acq, bool *isRequested) {
    return OScDevInternal_FunctionTable->Acquisition_IsDetectorRequested(
        &OScDevInternal_TheModuleImpl, acq, isRequested);
}
 
 
OScDev_API OScDev_Error OScDev_Acquisition_GetClockStartTriggerSource(
    OScDev_Acquisition *acq, OScDev_TriggerSource *startTrigger) {
    return OScDevInternal_FunctionTable
        ->Acquisition_GetClockStartTriggerSource(&OScDevInternal_TheModuleImpl,
                                                 acq, startTrigger);
}
 
 
OScDev_API OScDev_Error OScDev_Acquisition_GetClockSource(
    OScDev_Acquisition *acq, OScDev_ClockSource *clock) {
    return OScDevInternal_FunctionTable->Acquisition_GetClockSource(
        &OScDevInternal_TheModuleImpl, acq, clock);
}
 
OScDev_API uint32_t
OScDev_Acquisition_GetNumberOfFrames(OScDev_Acquisition *acq) {
    return OScDevInternal_FunctionTable->Acquisition_GetNumberOfFrames(
        &OScDevInternal_TheModuleImpl, acq);
}
 
OScDev_API double OScDev_Acquisition_GetPixelRate(OScDev_Acquisition *acq) {
    return OScDevInternal_FunctionTable->Acquisition_GetPixelRate(
        &OScDevInternal_TheModuleImpl, acq);
}
 
OScDev_API uint32_t OScDev_Acquisition_GetResolution(OScDev_Acquisition *acq) {
    return OScDevInternal_FunctionTable->Acquisition_GetResolution(
        &OScDevInternal_TheModuleImpl, acq);
}
 
OScDev_API double OScDev_Acquisition_GetZoomFactor(OScDev_Acquisition *acq) {
    return OScDevInternal_FunctionTable->Acquisition_GetZoomFactor(
        &OScDevInternal_TheModuleImpl, acq);
}
 
OScDev_API void OScDev_Acquisition_GetROI(OScDev_Acquisition *acq,
                                          uint32_t *xOffset, uint32_t *yOffset,
                                          uint32_t *width, uint32_t *height) {
    OScDevInternal_FunctionTable->Acquisition_GetROI(
        &OScDevInternal_TheModuleImpl, acq, xOffset, yOffset, width, height);
}
 
 
OScDev_API bool OScDev_Acquisition_CallFrameCallback(OScDev_Acquisition *acq,
                                                     uint32_t channel,
                                                     void *pixels) {
    return OScDevInternal_FunctionTable->Acquisition_CallFrameCallback(
        &OScDevInternal_TheModuleImpl, acq, channel, pixels);
}
 
#undef OScDev_API
 
#endif // OScDevInternal_BUILDING_OPENSCANLIB