asmirasdk.h

Go to the documentation of this file.

/****************************************************************
* Name:       asmirasdk.h
* Purpose:    ASMIRA SDK
* Author:     Fredrick Vamstad
* Created:    2022 - April
* Updated:    2026 - September
* Copyright:  AnsuR Technologies
* Dependency: videocore, audiolib 
****************************************************************/
 
#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;

    static const uint32_t CHAT_MESSAGE_LEN = 256;

    static const uint32_t AUDIO_SAMPLE_RATE = 16000;
    static const uint32_t AUDIO_CHANNELS = 1;
    static const uint32_t AUDIO_FRAME_SAMPLES = 320;

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

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

    enum AuthenticationResponse {
        AuthenticationResponseUndef             = 0,       
        AuthenticationResponseSuccess           = 1 << 0,  
        AuthenticationResponseError             = 1 << 1,  
        AuthenticationResponseVersionError      = 1 << 2,  
        AuthenticationResponseVersionRecUpgrade = 1 << 3,  
        AuthenticationResponseVersionMayUpgrade = 1 << 4,  
        AuthenticationResponseLoggedInOther     = 1 << 5,  
        AuthenticationResponseKickedOther       = 1 << 6,  
        AuthenticationResponseWrongLoginType    = 1 << 7,  
        AuthenticationResponseTryAgainLater     = 1 << 8,  
        AuthenticationResponseFormatError       = 1 << 9,  
        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, 
        RoomStatePreview  = 1 << 1, 
    };

    typedef uint32_t RoomStateValue;

    enum RoomFileDirection {
        RoomFileDirectionUndef,  
        RoomFileDirectionSend,   
        RoomFileDirectionReceive 
    };

    enum RoomFileError {
        RoomFileErrorUndef,        
        RoomFileErrorCanceled,     
        RoomFileErrorHashMismatch, 
        RoomFileErrorFile          
    };

    enum PositionSource {
        PositionSourceUndefined, 
        PositionSourceNMEA,      
        PositionSourceKLV        
    };
    
    enum StreamType {
        StreamTypeUnknown,      
        StreamType264Frame,     
        StreamType265Frame,     
        StreamTypeAV1Frame,     
        StreamTypeMPEGTS,       
        StreamTypeWEBP          
    };

    enum ImageFormat {
        ImageFormatUndef, 
        ImageFormatJPEG,  
        ImageFormatWEBP,  
        ImageFormatHEIF,  
        ImageFormatAVIF,  
        ImageFormatAV1,   
        ImageFormatH265   
    };

    enum UserCapability : uint8_t {
        UserCapabilityUndef       = 0,      
        UserCapabilitySender      = 1 << 0, 
        UserCapabilityController  = 1 << 1, 
        UserCapabilityViewer      = 1 << 2, 
        UserCapabilityGuest       = 1 << 3, 
        UserCapabilitySuper       = 1 << 6, 
        UserCapabilityUnsure      = 1 << 7  
    };

    typedef uint8_t UserCapabilityValue;

    enum DeviceCapability : int {
        DeviceCapabilityUndef         = 0,       
        DeviceCapabilityVideoAV1      = 1 << 1,  
        DeviceCapabilityVideoH264     = 1 << 2,  
        DeviceCapabilityVideoH265     = 1 << 3,  
        DeviceCapabilityAudioOpus     = 1 << 4,  
        DeviceCapabilityAudioSpeex    = 1 << 5,  
        DeviceCapabilityAudioMIC      = 1 << 6,  
        DeviceCapabilityPhotoModeWEBP = 1 << 7,  
        DeviceCapabilityPhotoModeHEIF = 1 << 8,  
        DeviceCapabilityPhotoModeAVIF = 1 << 9,  
        DeviceCapabilityPhotoROI      = 1 << 10, 
        DeviceCapabilityVideoROI      = 1 << 11, 
        DeviceCapabilityChat          = 1 << 12, 
        DeviceCapabilityDisplay       = 1 << 13, 
        DeviceCapabilityFileTransfer  = 1 << 16, 
        /*
            More device capabilities as needed
        */
        DeviceCapabilityASIGN         = 1 << 31, 

        DeviceCapabilityBasic = DeviceCapabilityVideoH265 | DeviceCapabilityAudioSpeex |
                                DeviceCapabilityAudioMIC | DeviceCapabilityPhotoModeWEBP |
                                DeviceCapabilityPhotoROI | DeviceCapabilityDisplay |
                                DeviceCapabilityVideoROI | DeviceCapabilityChat,

        DeviceCapabilityCore = DeviceCapabilityBasic | DeviceCapabilityVideoAV1 |
                               DeviceCapabilityVideoH264 | DeviceCapabilityDisplay,
        DeviceCapabilityFull = DeviceCapabilityCore | DeviceCapabilityAudioOpus |
                               DeviceCapabilityASIGN,
        DeviceCapabilityHeadless = DeviceCapabilityVideoH265 | DeviceCapabilityVideoAV1 |
                                   DeviceCapabilityVideoH264 | DeviceCapabilityPhotoModeWEBP |
                                   DeviceCapabilityPhotoROI | DeviceCapabilityVideoROI
    };

    typedef int DeviceCapabilityValue;

    enum AudioFrameState {
        AudioFrameStateUndef = 0,      
        AudioFrameSpeex      = 1 << 0, 
        AudioFrameOpus       = 1 << 1, 
        AudioFrameServer     = 1 << 2, 
    };

    typedef uint8_t AudioFrameStateValue;

    enum AudioCodec {
        AudioCodecUndef, 
        AudioCodecOpus,  
        AudioCodecSpeex  
    };
 
#ifdef ASDK_SAFE_ALIAS
    #pragma pack(4)
#endif

 
    typedef struct {
        int32_t width;
        int32_t height;
        int32_t size;
        int64_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 {
        AudioCodec codec;
        int32_t bitrate;
        int32_t complexity;
        int32_t txQueueFrames;
        bool prioritizeSpeech;
    }audio_options_t;

 
    typedef struct {
        uint32_t sampleCount;
        uint32_t sampleRate;
        uint32_t channels;
        uint32_t timeStamp;
        const int16_t* data;
    }audio_frame_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;
        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();
    }

    enum CertificateState {
        CertificateStateUndef,       
        CertificateStateConnected,   
        CertificateStateReceived,    
        CertificateStateConnectError 
    };

 
    typedef struct certificate_t {
        int len;
        const char* data{ nullptr };
    }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);
    typedef void (ASDK_CALL *RoomFileAvailableFunc)(const uint32_t roomID, const uint64_t hash,
                                                    const char* fileName, const uint32_t fileSize,
                                                    const uint32_t originClientID, const uint64_t utc,
                                                    void* opaque);
    typedef void (ASDK_CALL *RoomFileDeletedFunc)(const uint32_t roomID, const uint64_t hash,
                                                  void* opaque);
    typedef void (ASDK_CALL *RoomFileDownloadedFunc)(const uint32_t roomID, const uint64_t hash,
                                                     const char* fileName, const uint8_t* data,
                                                     const uint32_t size, void* opaque);
    typedef void (ASDK_CALL *RoomFileProgressFunc)(const uint32_t roomID, const uint64_t hash,
                                                   const char* fileName,
                                                   const RoomFileDirection direction,
                                                   const uint32_t transferred, const uint32_t total,
                                                   void* opaque);
    typedef void (ASDK_CALL *RoomFileSentFunc)(const uint32_t roomID, const uint64_t hash,
                                               const char* fileName, void* opaque);
    typedef void (ASDK_CALL *RoomFileErrorFunc)(const uint32_t roomID, const uint64_t hash,
                                                const char* fileName, const RoomFileError error,
                                                void* opaque);
    typedef void (ASDK_CALL *ChatMessageFunc)(const uint32_t clientID, const char* message,
                                              const uint32_t size, void* opaque);
    typedef void (ASDK_CALL *DecodedAudioFrameFunc)(const audio_frame_t* audioFrame, 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;
        }

 
        Status SendChatMessage(const char* message) {
            if (_send_chat_message_)
                return _send_chat_message_(this, message);
            return StatusErrorHandle;
        }

 
        Status SendAudioFrame(const int16_t* samples, const uint32_t sampleCount,
                              const uint32_t timeStamp = 0) {
            if (_send_audio_frame_)
                return _send_audio_frame_(this, samples, sampleCount, timeStamp);
            return StatusErrorHandle;
        }

 
        Status SendEncodedAudioFrame(const void* data, const uint32_t size,
                                     const uint32_t timeStamp,
                                     const AudioFrameStateValue state) {
            if (_send_encoded_audio_frame_)
                return _send_encoded_audio_frame_(this, data, size, timeStamp, state);
            return StatusErrorHandle;
        }

 
        Status FlushAudioFrames() {
            if (_flush_audio_frames_)
                return _flush_audio_frames_(this);
            return StatusErrorHandle;
        }

 
        Status SetAudioOptions(const audio_options_t* audioOptions) {
            if (_set_audio_options_)
                return _set_audio_options_(this, audioOptions);
            return StatusErrorHandle;
        }

 
        Status AudioOptions(audio_options_t* audioOptions) {
            if (_audio_options_)
                return _audio_options_(this, audioOptions);
            return StatusErrorHandle;
        }

 
        Status RoomFileSend(const uint32_t roomID, const char* fileName,
                            const void* data, const uint32_t size) {
            if (_room_file_send_)
                return _room_file_send_(this, roomID, fileName, data, size);
            return StatusErrorHandle;
        }

 
        Status RoomFileSendFromPath(const uint32_t roomID, const char* filePath) {
            if (_room_file_send_from_path_)
                return _room_file_send_from_path_(this, roomID, filePath);
            return StatusErrorHandle;
        }

 
        Status RoomFileSendResumeFromPath(const uint32_t roomID, const char* filePath) {
            if (_room_file_send_resume_from_path_)
                return _room_file_send_resume_from_path_(this, roomID, filePath);
            return StatusErrorHandle;
        }

 
        Status RoomFileDownload(const uint32_t roomID, const uint64_t hash) {
            if (_room_file_download_)
                return _room_file_download_(this, roomID, hash);
            return StatusErrorHandle;
        }

 
        Status RoomFileDownloadResume(const uint32_t roomID, const uint64_t hash,
                                      const char* fileName, const uint32_t totalSize,
                                      const void* haveBytes, const uint32_t haveCount) {
            if (_room_file_download_resume_)
                return _room_file_download_resume_(this, roomID, hash, fileName, totalSize,
                                                   haveBytes, haveCount);
            return StatusErrorHandle;
        }

 
        Status RoomFileCancel(const uint32_t roomID, const uint64_t hash) {
            if (_room_file_cancel_)
                return _room_file_cancel_(this, roomID, hash);
            return StatusErrorHandle;
        }

 
        Status RoomFileDelete(const uint32_t roomID, const uint64_t hash) {
            if (_room_file_delete_)
                return _room_file_delete_(this, roomID, hash);
            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);
        }

 
        inline void SetChatMessageCallback(ChatMessageFunc func, void* opaque = nullptr) {
            if (_cb_chat_message_)
                _cb_chat_message_(this, func, opaque);
        }

 
        inline void SetDecodedAudioFrameCallback(DecodedAudioFrameFunc func, void* opaque = nullptr) {
            if (_cb_decoded_audio_frame_)
                _cb_decoded_audio_frame_(this, func, opaque);
        }

 
        inline void SetRoomFileAvailableCallback(RoomFileAvailableFunc func, void* opaque = nullptr) {
            if (_cb_room_file_available_)
                _cb_room_file_available_(this, func, opaque);
        }

 
        inline void SetRoomFileDeletedCallback(RoomFileDeletedFunc func, void* opaque = nullptr) {
            if (_cb_room_file_deleted_)
                _cb_room_file_deleted_(this, func, opaque);
        }

 
        inline void SetRoomFileDownloadedCallback(RoomFileDownloadedFunc func, void* opaque = nullptr) {
            if (_cb_room_file_downloaded_)
                _cb_room_file_downloaded_(this, func, opaque);
        }

 
        inline void SetRoomFileProgressCallback(RoomFileProgressFunc func, void* opaque = nullptr) {
            if (_cb_room_file_progress_)
                _cb_room_file_progress_(this, func, opaque);
        }

 
        inline void SetRoomFileSentCallback(RoomFileSentFunc func, void* opaque = nullptr) {
            if (_cb_room_file_sent_)
                _cb_room_file_sent_(this, func, opaque);
        }

 
        inline void SetRoomFileErrorCallback(RoomFileErrorFunc func, void* opaque = nullptr) {
            if (_cb_room_file_error_)
                _cb_room_file_error_(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);
        // Delete a shared room file for the whole room, identified by (roomID, hash) from a
        // RoomFileAvailable callback. Privileged (Sender/Controller/Super); the server checks.
        Status (ASDK_CALL *_room_file_delete_)(sdk_t* sdk, const uint32_t roomID, const uint64_t hash);
        // Upload a file to a room: data/size is the content; the server hashes it and announces
        // it to the other members. Requires DeviceCapabilityFileTransfer. StatusOK if queued.
        Status (ASDK_CALL *_room_file_send_)(sdk_t* sdk, const uint32_t roomID, const char* fileName,
                                             const void* data, const uint32_t size);
        // Hash and stream a file straight off disk, the content is never fully resident.
        Status (ASDK_CALL *_room_file_send_from_path_)(sdk_t* sdk, const uint32_t roomID,
                                                       const char* filePath);
        // Resume an interrupted disk upload: stream only the bytes the server does not yet hold.
        Status (ASDK_CALL *_room_file_send_resume_from_path_)(sdk_t* sdk, const uint32_t roomID,
                                                              const char* filePath);
        // Request download of an available room file (roomID, hash from RoomFileAvailable). The
        // verified bytes arrive via the RoomFileDownloaded callback on completion.
        Status (ASDK_CALL *_room_file_download_)(sdk_t* sdk, const uint32_t roomID, const uint64_t hash);
        Status (ASDK_CALL *_room_file_download_resume_)(sdk_t* sdk, const uint32_t roomID,
                                                        const uint64_t hash, const char* fileName,
                                                        const uint32_t totalSize,
                                                        const void* haveBytes, const uint32_t haveCount);
        // Cancel an in-flight download started with _room_file_download_ (roomID, hash): the
        // server stops streaming and any partially received bytes are discarded.
        Status (ASDK_CALL *_room_file_cancel_)(sdk_t* sdk, const uint32_t roomID, const uint64_t hash);
        // Send a chat message to the joined room. Rejected locally if no room is joined or the
        // message is empty/longer than CHAT_MESSAGE_LEN, by the server if chat is not permitted.
        Status (ASDK_CALL *_send_chat_message_)(sdk_t* sdk, const char* message);
        // Accumulate PCM into codec sized frames, encode and queue for transmit. Rejected
        // locally when the audio module is missing, dropped downstream if no room is joined.
        Status (ASDK_CALL *_send_audio_frame_)(sdk_t* sdk, const int16_t* samples,
                                               const uint32_t sampleCount, const uint32_t timeStamp);
        // Queue an already encoded Opus/Speex frame for transmit, no encoding done.
        Status (ASDK_CALL *_send_encoded_audio_frame_)(sdk_t* sdk, const void* data,
                                                       const uint32_t size, const uint32_t timeStamp,
                                                       const AudioFrameStateValue state);
        // Send whatever the audio transmit queue is still holding.
        Status (ASDK_CALL *_flush_audio_frames_)(sdk_t* sdk);
        // Apply encoder options, falling back to the codec the audio module offers.
        Status (ASDK_CALL *_set_audio_options_)(sdk_t* sdk, const audio_options_t* audioOptions);
        // Read back the options in effect, including the codec actually selected.
        Status (ASDK_CALL *_audio_options_)(sdk_t* sdk, audio_options_t* audioOptions);
 
        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);
        void (ASDK_CALL *_cb_room_file_available_)(sdk_t* sdk, RoomFileAvailableFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_file_deleted_)(sdk_t* sdk, RoomFileDeletedFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_file_downloaded_)(sdk_t* sdk, RoomFileDownloadedFunc func, void* opaque);
        void (ASDK_CALL *_cb_chat_message_)(sdk_t* sdk, ChatMessageFunc func, void* opaque);
        void (ASDK_CALL *_cb_decoded_audio_frame_)(sdk_t* sdk, DecodedAudioFrameFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_file_progress_)(sdk_t* sdk, RoomFileProgressFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_file_sent_)(sdk_t* sdk, RoomFileSentFunc func, void* opaque);
        void (ASDK_CALL *_cb_room_file_error_)(sdk_t* sdk, RoomFileErrorFunc 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