asmirasdk.h

Go to the documentation of this file.

/****************************************************************
* Name:       asmirasdk.h
* Purpose:    ASMIRA SDK
* Author:     Fredrick Vamstad
* Created:    2022 - April
* Updated:    2025 - October
* Copyright:  AnsuR Technologies
* Dependency: videomodule/libvideomodule
****************************************************************/
 
#ifndef ASMIRA_SDK_H
#define ASMIRA_SDK_H


#if defined (__WIN32__) || defined(__WIN64__) || defined(_WINDOWS)
#define ASDK_WINDOWS
#include <windows.h>
#ifndef ASDK_LoadLib
#define ASDK_LoadLib(a) (asdk::hsdk)LoadLibraryA(a)
#endif
#ifndef ASDK_GetProc
#define ASDK_GetProc(a1, a2) GetProcAddress((HINSTANCE__*)a1, a2)
#endif
#ifndef ASDK_FreeLib
#define ASDK_FreeLib(a) FreeLibrary((HINSTANCE__*)a)
#endif
#define ASDK_CALL __cdecl
#elif defined(__GNUC__) 
#define ASDK_UNIX
#include <sys/types.h>
#include <dlfcn.h>
#include <string.h>
#ifndef ASDK_LoadLib
#define ASDK_LoadLib(a) (asdk::hsdk)dlopen(a, RTLD_NOW)
#endif
#ifndef ASDK_GetProc
#define ASDK_GetProc(a1, a2) dlsym(a1, a2)
#endif
#ifndef ASDK_FreeLib
#define ASDK_FreeLib(a) dlclose(a)
#endif
#define ASDK_CALL
#else
#error Compiler unsupported
#endif
 
#include <stdio.h>
#include <cstdint>
#include <chrono>
#include <vector>
 
#ifndef ASDK_SAFE_ALIAS
    #define ASDK_SAFE_ALIAS
#endif
 
namespace asdk {
    typedef void* hsdk; 
 
    static const uint8_t VERSION_MAJOR = 2;
    static const uint8_t VERSION_MINOR = 0;
    static const uint8_t VERSION_PATCH = 1;

    enum Status {
        StatusUndef,            
        StatusOK,               
        StatusDisconnected,     
        StatusError,            
        StatusErrorHandle,      
        StatusErrorVideoModule, 
        StatusErrorImageModule, 
        StatusErrorInitialized, 
        StatusErrorConnect,     
        StatusErrorTransmit     
    };

    enum ServerState {
        ServerStateUndef,                     
        ServerStateDisconnected,                
        ServerStateConnected,                 
        ServerStateConnectedAndAuthenticated,   
        ServerStateAuthenticateError          
    };

    enum AuthenticationResponse {
        AuthenticationResponseUndef             = 0,
        AuthenticationResponseSuccess           = 1 << 0,
        AuthenticationResponseError             = 1 << 1,
        AuthenticationResponseVersionError      = 1 << 2,
        // Minor version differ, operations may be affected
        AuthenticationResponseVersionRecUpgrade = 1 << 3,
        // Patch version differ, operations not be affected
        AuthenticationResponseVersionMayUpgrade = 1 << 4,
        // Someone logged into the server with your credentials
        AuthenticationResponseLoggedInOther     = 1 << 5,
        // Logged in, but caused the server to kick out another client
        AuthenticationResponseKickedOther       = 1 << 6,
        // Logged in, but wrong type (Sender with Controller account etc)
        AuthenticationResponseWrongLoginType    = 1 << 7,
        // To many/often login attempts
        AuthenticationResponseTryAgainLater     = 1 << 8,
        // Server unable to read login data
        AuthenticationResponseFormatError       = 1 << 9,
        // Requeste capability for user not available
        AuthenticationResponseRequestedCapError = 1 << 10,
    };

    enum Request {
        RequestUndef,               
        RequestRoomListSubscribe,   
        RequestRoomListUnsubscribe, 
        RequestRoomJoin,            
        RequestRoomLeave            
    };
 
    enum RoomResponse {
        RoomResponseUndef,
        RoomResponseSuccess,
        RoomResponseError,
        RoomResponseErrorAlreadyJoined,
        RoomResponseErrorUnhandled
    };
 
    enum RoomFlag {
        RoomFlagUndef,
        RoomFlagIsPublic     = 1 << 0,
        RoomFlagChatGuests   = 1 << 1,
        RoomFlagChatViewers  = 1 << 2,
        RoomFlagChatSenders  = 1 << 3,
        RoomFlagAudioGuests  = 1 << 4,
        RoomFlagAudioViewers = 1 << 5,
        RoomFlagAudioSenders = 1 << 6,
    };
    typedef uint32_t RoomFlagValue;
 
    enum RoomState {
        RoomStateUndef,
        RoomStatePassword = 1 << 0, // Password protection is enabled
        RoomStatePreview  = 1 << 1, // Preview is enabled
    };
    typedef uint32_t RoomStateValue;

    enum PositionSource {
        PositionSourceUndefined, 
        PositionSourceNMEA,      
        PositionSourceKLV        
    };
    
    enum StreamType {
        StreamTypeUnknown,      
        StreamType264Frame,     
        StreamType265Frame,     
        StreamTypeAV1Frame,     
        StreamTypeMPEGTS,       
        StreamTypeWEBP          
    };
 
    enum ImageFormat  {
        ImageFormatUndef,
        ImageFormatJPEG,
        ImageFormatWEBP,
        ImageFormatHEIF,
        ImageFormatAVIF,
        ImageFormatAV1
    };
 
    // General user mode (Sender App or Receiver App)
    enum UserCapability : uint8_t {
        UserCapabilityUndef       = 0,
        // Use only one of these bits
        UserCapabilitySender      = 1 << 0,
        UserCapabilityController  = 1 << 1,
        UserCapabilityViewer      = 1 << 2,
        UserCapabilityGuest       = 1 << 3,
        UserCapabilitySuper       = 1 << 6, // Reserved bit for super user
        UserCapabilityUnsure      = 1 << 7  // Connect without knowing the user capability
    };
    typedef uint8_t UserCapabilityValue;
 
    enum DeviceCapability : int {
        DeviceCapabilityUndef         = 0,
        DeviceCapabilityVideoAV1      = 1 << 1,
        DeviceCapabilityVideoH264     = 1 << 2,
        DeviceCapabilityVideoH265     = 1 << 3,
        DeviceCapabilityAudioOpus     = 1 << 4,   // No yet implemented     
        DeviceCapabilityAudioSpeex    = 1 << 5,
        DeviceCapabilityAudioMIC      = 1 << 6,   // Has microphone or capable of audio input
        DeviceCapabilityPhotoModeWEBP = 1 << 7,
        DeviceCapabilityPhotoModeHEIF = 1 << 8,   // No yet implemented
        DeviceCapabilityPhotoModeAVIF = 1 << 9,   // No yet implemented
        DeviceCapabilityPhotoROI      = 1 << 10,
        DeviceCapabilityVideoROI      = 1 << 11,
        DeviceCapabilityChat          = 1 << 12,
        DeviceCapabilityDisplay       = 1 << 13,  // Is not headless or autonomous
        /*
            More device capabilities as needed
        */
        DeviceCapabilityASIGN         = 1 << 31,
 
        DeviceCapabilityBasic = DeviceCapabilityVideoH265 | DeviceCapabilityAudioSpeex | 
                                DeviceCapabilityAudioMIC | DeviceCapabilityPhotoModeWEBP | 
                                DeviceCapabilityPhotoROI | DeviceCapabilityDisplay |
                                DeviceCapabilityVideoROI | DeviceCapabilityChat,
 
        // Core Desktop ASMIRA
        DeviceCapabilityCore = DeviceCapabilityBasic | DeviceCapabilityVideoAV1 | 
                               DeviceCapabilityVideoH264 | DeviceCapabilityDisplay,
        // No yet implemented
        DeviceCapabilityFull = DeviceCapabilityCore | DeviceCapabilityAudioOpus | 
                               DeviceCapabilityASIGN,
        // Core Headless ASMIRA
        DeviceCapabilityHeadless = DeviceCapabilityVideoH265 | DeviceCapabilityVideoAV1 | 
                                   DeviceCapabilityVideoH264 | DeviceCapabilityPhotoModeWEBP |
                                   DeviceCapabilityPhotoROI | DeviceCapabilityVideoROI 
    };
    typedef int DeviceCapabilityValue;
 
    enum AudioFrameState {
        AudioFrameStateUndef = 0,
        // Start, decoder may need to be updated
        AudioFrameStateStart = 1 << 0,
        // Audio quality mode, Low to HIGH
        AudioFrameStateQM1   = 1 << 1,
        AudioFrameStateQM2   = 1 << 2,
        AudioFrameStateQM3   = 1 << 3,
        AudioFrameStateQM4   = 1 << 4,
        AudioFrameStateQM5   = 1 << 5,
        // Reserved for protocol expansion
        AudioFrameStateRES1  = 1 << 6,
        AudioFrameStateRES2  = 1 << 7,
        AudioFrameStateRES3  = 1 << 7
    };
    typedef uint8_t AudioFrameStateValue;
 
#ifdef ASDK_SAFE_ALIAS
    #pragma pack(4)
#endif

 
    typedef struct {
        int32_t width;
        int32_t height;
        int32_t size;
        uint32_t timeStamp;
        uint64_t utc;
        uint8_t* data;
    }frame_t;

 
    typedef struct {
        int32_t width;
        int32_t height;
        int32_t sourceWidth;
        int32_t sourceHeight;
        int32_t sourceFPS;
        int32_t targetFPS;
        int32_t targetBitrate;
        int32_t photoBitrate;
        int32_t photoTargetSize;
        int32_t threads;
        int32_t threadsAvailable;
        int32_t priority;
    }video_options_t;

 
    typedef struct {
        bool photoMode;
        bool roiMode;
        bool streamingEnabled;
    }video_mode_t;

    typedef struct position_klv_values_t {
        uint64_t unixTime{ 0ULL };
        float indicatedAirSpeed{ 0.0f };
        float trueAirSpeed{ 0.0f };
        float groundSpeed{ 0.0f };
        double latitude{ 0.0 };
        double longitude{ 0.0 };
        double altitude{ 0.0 };
        float heading{ 0.0f };
        float pitch{ 0.0f };
        float roll{ 0.0f };
        float sensorHorizontalFOV{ 0.0f };
        float sensorVerticalFOV{ 0.0f };
        float sensorAzimuth{ 0.0f };
        float sensorElevationAngle{ 0.0f };
        float sensorRelativeRollAngle{ 0.0f };
    }position_klv_values_t;

    typedef struct position_nmea_values_t {
        uint64_t unixTime{ 0ULL };
        int64_t satVisibleCount{ 0ULL };
        double dilution{ 0.0 };
        double groundSpeed{ 0.0 };
        double latitude{ 0.0 };
        double longitude{ 0.0 };
        float heading{ 0.0f };
    } position_nmea_values_t;

 
    typedef struct position_values_t {
        PositionSource positionSource{ PositionSourceUndefined };
        position_klv_values_t* klvValues{ nullptr };
        position_nmea_values_t* nmeaValues{ nullptr };
    }position_values_t;
 
    typedef struct bandwidth_statistics_t {
        bandwidth_statistics_t() : packetsSentReceived(0), sizeTotal(0), 
                                   reportTime(0), rtcpPacketLostCount(0),
                                   rtcpPacketLostSize(0) {}
        unsigned int packetsSentReceived;
        unsigned int sizeTotal;
        // Duration of current report (in milliseconds)
        unsigned int reportTime;     
 
        unsigned int rtcpPacketLostCount;
        unsigned int rtcpPacketLostSize;
    }bandwidth_statistics_t;

    typedef struct {
        float bitrate;
        float bitrateAverage;
        unsigned int packetsSentReceived;
    }bandwidth_statistics_simple_t;
 
    using TimePoint = std::chrono::high_resolution_clock::time_point;
    using TimeMS = std::chrono::milliseconds;
 
    inline TimePoint TimeNow() {
        return std::chrono::high_resolution_clock::now();
    }
    inline long long TimeSpent(const TimePoint& timeStart) {
        return std::chrono::duration_cast<TimeMS>(TimeNow() - timeStart).count();
    }
 
    using TimePointSteady = std::chrono::steady_clock::time_point;
    inline TimePointSteady TimeNowSteady() {
        return std::chrono::steady_clock::now();
    }
 
    inline long long TimeSpentSteady(const TimePointSteady& time) {
        return std::chrono::duration_cast<TimeMS>(TimeNowSteady() - time).count();
    }
 
    std::vector<std::pair<TimePoint, unsigned int>> m_streamStats;
 
    enum CertificateState {
        CertificateStateUndef,
        CertificateStateConnected,
        CertificateStateReceived,
        CertificateStateConnectError
    };
 
    typedef struct certificate_t {
        int len;                
        const char* data{ nullptr }; // Pointer to certificate data, temporary storage only
    }certificate_t;
 
#ifdef ASDK_SAFE_ALIAS
    #pragma pack()
#endif
 
    // Callback functions
    typedef void (ASDK_CALL *ServerStateFunc)(const ServerState serverState, void* opaque);
    typedef void (ASDK_CALL *RoomAnnounceFunc)(const char* roomName, const uint32_t roomID,
                                               const asdk::RoomStateValue state,
                                               const asdk::RoomFlagValue flags, void *opaque);
    typedef void (ASDK_CALL *RoomResponseFunc)(const Request request, const RoomResponse response,
                                               const void* optionalData, const uint32_t optionalDataSize, void* opaque);
    typedef void (ASDK_CALL *RoomClientAddedFunc)(const uint32_t clientID, const char* userName, const UserCapabilityValue userCapability, 
                                                  const DeviceCapabilityValue deviceCapability, void* opaque);
    typedef void (ASDK_CALL *RoomClientRemovedFunc)(const uint32_t clientID, void* opaque);
    typedef void (ASDK_CALL *AuthenticateResponseFunc)(const AuthenticationResponse authenticateResponse, void* opaque);
    typedef void (ASDK_CALL *FrameFunc)(const frame_t* frame, void* opaque);
    typedef void (ASDK_CALL *EncodedStreamFunc)(const StreamType type, const void *data, const uint32_t dataSize, void* opaque);
    typedef void (ASDK_CALL *EncodedAudioFrameFunc)(const uint16_t srcID, const unsigned int timeStamp,
                                                    const asdk::AudioFrameStateValue state,
                                                    const unsigned char* audioEncoded, 
                                                    const size_t audioEncodedSize, void* opaque);
    typedef void (ASDK_CALL *VideoOptionsFunc)(const video_options_t* videoOptions, void* opaque);
    typedef void (ASDK_CALL *VideoModeFunc)(const video_mode_t* videoMode, void* opaque);
    typedef void (ASDK_CALL *PositionValuesFunc)(const position_values_t* positionValues, void* opaque);
    typedef void (ASDK_CALL *BandwidthStatisticsFunc)(const bandwidth_statistics_simple_t *bandwidthStatistics, void* opaque);
    typedef void (ASDK_CALL *RoomPreviewImageFunc)(const uint32_t roomID, const uint64_t utc, 
                                                   const ImageFormat imageFormat, 
                                                   const uint8_t *data, const uint32_t size, 
                                                   void* opaque);
 
#ifdef ASDK_SAFE_ALIAS
    #pragma pack(4)
#endif

 
    typedef struct sdk_t {
        typedef void (ASDK_CALL *VersionProc)(uint8_t *versionMajor,
                                              uint8_t *versionMinor,
                                              uint8_t *versionPath);
        hsdk library;
        hsdk handle;
        char* errorStr;
        Status status;

 
        Status Unload() {
            if (_unload_) {
                hsdk libraryHandle = library;
                _unload_(this);
 
                if (libraryHandle)
                    ASDK_FreeLib(libraryHandle);
 
                return StatusOK;
            }
            return StatusErrorHandle;
        }

        // Unsecured connection is not supported for 4.0, TBD for 4.1+
        Status Connect(const char* ip, const uint16_t port, 
                       const uint32_t timeout, const bool highLatency,
                       const char *username, const char *password,
                       const UserCapabilityValue userCapability,
                       const DeviceCapabilityValue deviceCapability,
                       const char *displayName = nullptr) {
            if (_connect_)
                return _connect_(this, ip, port, timeout, highLatency, username, 
                                 password, userCapability, deviceCapability, 
                                 displayName);
            return StatusErrorHandle;
        }

 
        Status ConnectSecured(const char* ip, const uint16_t port, 
                              const uint32_t timeout, const bool highLatency,
                              const char *username, const char* password,
                              const UserCapabilityValue userCapability,
                              const DeviceCapabilityValue deviceCapability,
                              const char *certificate,
                              const char *displayName = nullptr) {
            if (_connect_secured_)
                return _connect_secured_(this, ip, port, timeout, highLatency, username, 
                                         password, userCapability, deviceCapability,
                                         certificate, displayName);
            return StatusErrorHandle;
        }

 
        Status RequestCertificate(const char* address, const uint16_t port,
                                  const char* userName, const char *password,
                                  CertificateState* certificateStateOut,
                                  certificate_t* certificateOut,
                                  const int timeout = 3000) {
            if (_request_certificate_)
                return _request_certificate_(this, address, port, userName, password, 
                                             certificateStateOut, 
                                             certificateOut, timeout);
            return StatusErrorHandle;
        }

 
        Status CachedCertificate(certificate_t* certificateOut) {
            if (_cached_certificate_)
                return _cached_certificate_(this, certificateOut);
            
            return StatusErrorHandle;
        }

 
        Status Disconnect() {
            if (_disconnect_)
                return _disconnect_(this);
            return StatusErrorHandle;
        }

 
        Status SendRequest(const Request request) {
            if (_send_request_)
                return _send_request_(this, request);
            return StatusErrorHandle;
        }

 
        Status SendRequestStr(const Request request, const char* str, 
                              const char *option = nullptr) {
            if (_send_request_string_)
                return _send_request_string_(this, request, str, option);
            return StatusErrorHandle;
        }

 
        inline void SetServerStateCallback(ServerStateFunc func, void *opaque = nullptr) {
            if (_cb_server_state_)
                _cb_server_state_(this, func, opaque);
        }

 
        inline void SetRoomAnnounceCallback(RoomAnnounceFunc func, void* opaque = nullptr) {
            if (_cb_room_announce_)
                _cb_room_announce_(this, func, opaque);
        }

 
        inline void SetRoomResponseCallback(RoomResponseFunc func, void* opaque = nullptr) {
            if (_cb_room_response_)
                _cb_room_response_(this, func, opaque);
        }

 
        inline void SetRoomClientAddedCallback(RoomClientAddedFunc func, void* opaque = nullptr) {
            if (_cb_room_client_added_)
                _cb_room_client_added_(this, func, opaque);
        }

 
        inline void SetRoomClientRemovedCallback(RoomClientRemovedFunc func, void* opaque = nullptr) {
            if (_cb_room_client_removed_)
                _cb_room_client_removed_(this, func, opaque);
        }

 
        inline void SetAuthenticateResponseCallback(AuthenticateResponseFunc func, void* opaque = nullptr) {
            if (_cb_authenticate_response_)
                _cb_authenticate_response_(this, func, opaque);
        }

 
        inline void SetFrameCallback(FrameFunc func, void* opaque = nullptr) {
            if (_cb_frame_)
                _cb_frame_(this, func, opaque);
        }
        
        
        inline void SetEncodedStreamCallback(EncodedStreamFunc func, void* opaque = nullptr) {
            if (_cb_encoded_stream_)
                _cb_encoded_stream_(this, func, opaque);
        }

 
        inline void SetEncodedAudioFrameCallback(EncodedAudioFrameFunc func, void* opaque = nullptr) {
            if (_cb_encoded_audio_frame_)
                _cb_encoded_audio_frame_(this, func, opaque);
        }

 
        inline void SetVideoOptionsCallback(VideoOptionsFunc func, void* opaque = nullptr) {
            if (_cb_video_options_)
                _cb_video_options_(this, func, opaque);
        }

 
        inline void SetVideoModeCallback(VideoModeFunc func, void* opaque = nullptr) {
            if (_cb_video_mode_)
                _cb_video_mode_(this, func, opaque);
        }

 
        inline void SetPositionValuesCallback(PositionValuesFunc func, void* opaque = nullptr) {
            if (_cb_position_values_)
                _cb_position_values_(this, func, opaque);
        }

 
        inline void SetBandwidthStatisticsCallback(BandwidthStatisticsFunc func, void* opaque = nullptr) {
            if (_cb_bandwidth_statistics_)
                _cb_bandwidth_statistics_(this, func, opaque);
        }

 
        inline void SetRoomPreviewImageCallback(RoomPreviewImageFunc func, void* opaque = nullptr) {
            if (_cb_room_preview_image_)
                _cb_room_preview_image_(this, func, opaque);
        }
 
        // SDK Internal
        VersionProc version;
        void (ASDK_CALL *_unload_)(sdk_t* sdk);
        Status (ASDK_CALL *_connect_)(sdk_t* sdk, const char* ip, const uint16_t port, 
                                      const uint32_t timeout, const bool highLatency,
                                      const char* username, const char* password, 
                                      const UserCapabilityValue userCapability,
                                      const DeviceCapabilityValue deviceCapability,
                                      const char *displayName);
        Status (ASDK_CALL *_connect_secured_)(sdk_t* sdk, const char* ip, const uint16_t port, 
                                              const uint32_t timeout, const bool highLatency,
                                              const char* username, const char* password, 
                                              const UserCapabilityValue userCapability,
                                              const DeviceCapabilityValue deviceCapability,
                                              const char *certificate,
                                              const char* displayName);
        Status (ASDK_CALL *_request_certificate_)(sdk_t* sdk, const char* address, const uint16_t port,
                                                  const char* userName, const char* password,
                                                  CertificateState* certificateStateOut,
                                                  certificate_t* certificateOut, const int timeout);
        Status (ASDK_CALL *_cached_certificate_)(sdk_t* sdk, certificate_t* certificateOut);
        Status (ASDK_CALL *_disconnect_)(sdk_t* sdk);
        Status (ASDK_CALL *_send_request_)(sdk_t* sdk, const Request request);
        Status (ASDK_CALL *_send_request_string_)(sdk_t* sdk, const Request request, 
                                                  const char* str, const char *option);
        
        void (ASDK_CALL *_cb_server_state_)(sdk_t* sdk, ServerStateFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_announce_)(sdk_t* sdk, RoomAnnounceFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_response_)(sdk_t* sdk, RoomResponseFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_client_added_)(sdk_t* sdk, RoomClientAddedFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_client_removed_)(sdk_t* sdk, RoomClientRemovedFunc func, void* opaque);
        void (ASDK_CALL *_cb_authenticate_response_)(sdk_t* sdk, AuthenticateResponseFunc func, void* opaque);
        void (ASDK_CALL *_cb_frame_)(sdk_t* sdk, FrameFunc func, void* opaque);
        void (ASDK_CALL *_cb_encoded_stream_)(sdk_t* sdk, EncodedStreamFunc func, void* opaque);
        void (ASDK_CALL *_cb_encoded_audio_frame_)(sdk_t* sdk, EncodedAudioFrameFunc func, void* opaque);
        void (ASDK_CALL *_cb_video_options_)(sdk_t* sdk, VideoOptionsFunc func, void* opaque);
        void (ASDK_CALL *_cb_video_mode_)(sdk_t* sdk, VideoModeFunc func, void* opaque);
        void (ASDK_CALL *_cb_position_values_)(sdk_t* sdk, PositionValuesFunc func, void* opaque);
        void (ASDK_CALL *_cb_bandwidth_statistics_)(sdk_t* sdk, BandwidthStatisticsFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_preview_image_)(sdk_t* sdk, RoomPreviewImageFunc func, void* opaque);
    }sdk_t;
 
#ifdef ASDK_SAFE_ALIAS
    #pragma pack()
#endif
 
    inline sdk_t* Initialize() {
        typedef sdk_t* (ASDK_CALL *InitProc)(void);
        sdk_t* self = nullptr;
#ifdef ASDK_WINDOWS
        const char *library = "asmirasdk.dll";
#else
        const char *library = "asmirasdk.so";
#endif
        hsdk asdk = ASDK_LoadLib(library);
        if (asdk) {
            sdk_t::VersionProc funcVersion = (sdk_t::VersionProc)ASDK_GetProc(asdk, "ASDKVersion");
            InitProc funcInit = (InitProc)ASDK_GetProc(asdk, "ASDKInitializeLibrary");
            if (funcInit && funcVersion) {
                uint8_t versionMajor = 0;
                uint8_t versionMinor = 0;
                uint8_t versionPatch = 0;
                funcVersion(&versionMajor, &versionMinor, &versionPatch);
                if (VERSION_MAJOR == versionMajor) {
                    if (VERSION_MINOR != versionMinor)
                        printf("Version mismatch warning\n");
 
                    self = funcInit();
                    if (self) {
                        self->library = asdk;
                        self->version = funcVersion;
                    }
                    else {
                        puts("Error occurred while initializing ASMIRA SDK");
                        ASDK_FreeLib(asdk);
                        asdk = nullptr;
                    }
                }
                else {
                    puts("Version error");
                    ASDK_FreeLib(asdk);
                    asdk = nullptr;
                }
            }
            else {
                puts("Failed to locate initialize proc");
                ASDK_FreeLib(asdk);
                asdk = nullptr;
            }
        }
        else {
#ifdef ASDK_WINDOWS
#else
            char* err = dlerror();
            if (err) {
                printf("Failed to open: \"%s\" Reason: \"%s\"\n", library, err);
            }
#endif
        }
        return self;
    }
}


 
#endif