Video SDK Linux

struct ZoomVideoSDKInitParams {
    const zchar_t* domain;              // Required: "https://zoom.us"
    bool enableLog;                      // Enable logging
    const zchar_t* logFilePrefix;        // Log file prefix
    ZoomVideoSDKRawDataMemoryMode videoRawDataMemoryMode;
    ZoomVideoSDKRawDataMemoryMode shareRawDataMemoryMode;
    ZoomVideoSDKRawDataMemoryMode audioRawDataMemoryMode;
    bool enableIndirectRawdata;          // Indirect raw data access
    ZoomVideoSDKExtendParams* extendParams; // Extended parameters
};

struct ZoomVideoSDKExtendParams {
    const zchar_t* speakerTestFilePath;
    // Additional extended parameters
};

struct ZoomVideoSDKSessionContext {
    const zchar_t* sessionName;          // Required
    const zchar_t* sessionPassword;      // Optional
    const zchar_t* userName;             // Required
    const zchar_t* token;                // Required: JWT token
    unsigned int sessionIdleTimeoutMins; // 0 = never timeout, default 40
    bool autoLoadMutliStream;            // Auto-load multiple streams
    
    ZoomVideoSDKVideoOption videoOption;
    ZoomVideoSDKAudioOption audioOption;
    
    IZoomVideoSDKVideoSource* externalVideoSource;
    IZoomVideoSDKVirtualAudioMic* virtualAudioMic;
    IZoomVideoSDKVirtualAudioSpeaker* virtualAudioSpeaker;
    IZoomVideoSDKVideoSourcePreProcessor* preProcessor;
};

struct ZoomVideoSDKVideoOption {
    bool localVideoOn;                   // Start with video on
};

struct ZoomVideoSDKAudioOption {
    bool connect;                        // Connect to audio
    bool mute;                           // Start muted
};

struct ZoomVideoSDKSessionAudioStatisticInfo {
    int frequency;
    int latency;
    int Jitter;
    float packetLossAvg;
    float packetLossMax;
};

struct ZoomVideoSDKSessionASVStatisticInfo {
    int frame_width;
    int frame_height;
    int fps;
    int latency;
    int Jitter;
    float packetLossAvg;
    float packetLossMax;
};

// Alias
typedef ZoomVideoSDKSessionASVStatisticInfo _SessionASVStatisticInfo;
typedef ZoomVideoSDKSessionAudioStatisticInfo _SessionAudioStatisticInfo;

struct ZoomVideoSDKVideoStatisticInfo {
    int width;
    int height;
    int fps;
    int bps;
};

struct ZoomVideoSDKShareStatisticInfo {
    int width;
    int height;
    int fps;
    int bps;
};

struct ZoomVideoSDKVideoStatus {
    bool isOn;
    bool hasSource;
};

struct ZoomVideoSDKAudioStatus {
    bool isMuted;
    bool isAudioConnected;
    ZoomVideoSDKAudioType audioType;
};

struct VideoSourceCapability {
    unsigned int width;
    unsigned int height;
    unsigned int frame;  // FPS
};

struct ZoomVideoSDKLiveStreamParams {
    const zchar_t* streamUrl;           // RTMP URL
    const zchar_t* streamKey;           // Stream key
    const zchar_t* broadcastUrl;        // Broadcast URL
};

struct ZoomVideoSDKLiveStreamSetting {
    // Live stream settings
};

struct IncomingLiveStreamStatus {
    // Incoming stream status
};

struct ZoomVideoSDKShareOption {
    bool isWithDeviceAudio;
    bool isOptimizeForSharedVideo;
};

struct ZoomVideoSDKShareCursorData {
    int x;
    int y;
    // Cursor information
};

struct ZoomVideoSDKSharePreprocessParam {
    // Preprocessing parameters
};

struct FileTransferProgress {
    unsigned long long transferredSize;
    unsigned long long totalSize;
    float percentage;
};

struct ZoomVideoSDKFileStatus {
    // File transfer status
};

struct ZoomVideoSDKViewSize {
    int width;
    int height;
};

struct tagVideoPreferenceSetting {
    // Video preference settings
};

struct tagProxySettings {
    // Proxy configuration
};

struct InvitePhoneUserInfo {
    const zchar_t* countryCode;
    const zchar_t* phoneNumber;
    const zchar_t* displayName;
};

struct ZoomVideoSDKSteamingJoinContext {
    // Streaming join context
};

class IZoomVideoSDK {
public:
    // Lifecycle
    virtual ZoomVideoSDKErrors initialize(ZoomVideoSDKInitParams& params) = 0;
    virtual ZoomVideoSDKErrors cleanup() = 0;
    
    // Session management
    virtual IZoomVideoSDKSession* joinSession(ZoomVideoSDKSessionContext& params) = 0;
    virtual ZoomVideoSDKErrors leaveSession(bool end) = 0;
    virtual IZoomVideoSDKSession* getSessionInfo() = 0;
    virtual bool isInSession() = 0;
    
    // Listeners
    virtual void addListener(IZoomVideoSDKDelegate* listener) = 0;
    virtual void removeListener(IZoomVideoSDKDelegate* listener) = 0;
    
    // Helpers
    virtual IZoomVideoSDKAudioHelper* getAudioHelper() = 0;
    virtual IZoomVideoSDKVideoHelper* getVideoHelper() = 0;
    virtual IZoomVideoSDKUserHelper* getUserHelper() = 0;
    virtual IZoomVideoSDKShareHelper* getShareHelper() = 0;
    virtual IZoomVideoSDKRecordingHelper* getRecordingHelper() = 0;
    virtual IZoomVideoSDKLiveStreamHelper* getLiveStreamHelper() = 0;
    virtual IZoomVideoSDKChatHelper* getChatHelper() = 0;
    virtual IZoomVideoSDKCmdChannel* getCmdChannel() = 0;
    virtual IZoomVideoSDKPhoneHelper* getPhoneHelper() = 0;
    virtual IZoomVideoSDKLiveTranscriptionHelper* getLiveTranscriptionHelper() = 0;
    virtual IZoomVideoSDKCRCHelper* getCRCHelper() = 0;
    virtual IZoomVideoSDKWhiteboardHelper* getWhiteboardHelper() = 0;
    virtual IZoomVideoSDKSubSessionHelper* getSubSessionHelper() = 0;
    virtual IZoomVideoSDKIncomingLiveStreamHelper* getIncomingLiveStreamHelper() = 0;
    
    // Settings
    virtual IZoomVideoSDKAudioSettingHelper* getAudioSettingHelper() = 0;
    virtual IZoomVideoSDKVideoSettingHelper* getVideoSettingHelper() = 0;
    virtual IZoomVideoSDKShareSettingHelper* getShareSettingHelper() = 0;
    virtual IZoomVideoSDKTestAudioDeviceHelper* GetAudioDeviceTestHelper() = 0;
    virtual IZoomVideoSDKNetworkConnectionHelper* getNetworkConnectionHelper() = 0;
    
    // Utilities
    virtual const zchar_t* getSDKVersion() = 0;
    virtual const zchar_t* exportLog() = 0;
    virtual ZoomVideoSDKErrors cleanAllExportedLogs() = 0;
};

class IZoomVideoSDKDelegate {
public:
    // Session
    virtual void onSessionJoin() = 0;
    virtual void onSessionLeave() = 0;
    virtual void onError(ZoomVideoSDKErrors errorCode, int detailErrorCode) = 0;
    virtual void onSessionNeedPassword(IZoomVideoSDKPasswordHandler* handler) = 0;
    virtual void onSessionPasswordWrong(IZoomVideoSDKPasswordHandler* handler) = 0;
    
    // Users
    virtual void onUserJoin(IZoomVideoSDKUserHelper* pUserHelper,
                           IVideoSDKVector<IZoomVideoSDKUser*>* userList) = 0;
    virtual void onUserLeave(IZoomVideoSDKUserHelper* pUserHelper,
                            IVideoSDKVector<IZoomVideoSDKUser*>* userList) = 0;
    virtual void onUserHostChanged(IZoomVideoSDKUserHelper* pUserHelper,
                                  IZoomVideoSDKUser* pUser) = 0;
    virtual void onUserManagerChanged(IZoomVideoSDKUser* pUser) = 0;
    virtual void onUserNameChanged(IZoomVideoSDKUser* pUser) = 0;
    
    // Video
    virtual void onUserVideoStatusChanged(IZoomVideoSDKVideoHelper* pVideoHelper,
                                         IVideoSDKVector<IZoomVideoSDKUser*>* userList) = 0;
    
    // Audio
    virtual void onUserAudioStatusChanged(IZoomVideoSDKAudioHelper* pAudioHelper,
                                         IVideoSDKVector<IZoomVideoSDKUser*>* userList) = 0;
    virtual void onUserActiveAudioChanged(IZoomVideoSDKAudioHelper* pAudioHelper,
                                         IVideoSDKVector<IZoomVideoSDKUser*>* list) = 0;
    
    // Raw Audio
    virtual void onMixedAudioRawDataReceived(AudioRawData* data_) = 0;
    virtual void onOneWayAudioRawDataReceived(AudioRawData* data_,
                                             IZoomVideoSDKUser* pUser) = 0;
    virtual void onSharedAudioRawDataReceived(AudioRawData* data_) = 0;
    
    // Virtual Speaker
    virtual void onVirtualSpeakerMixedAudioReceived(AudioRawData* data_) = 0;
    virtual void onVirtualSpeakerOneWayAudioReceived(AudioRawData* data_,
                                                    IZoomVideoSDKUser* pUser) = 0;
    virtual void onVirtualSpeakerSharedAudioReceived(AudioRawData* data_) = 0;
    
    // Share
    virtual void onUserShareStatusChanged(IZoomVideoSDKShareHelper* pShareHelper,
                                         IZoomVideoSDKUser* pUser,
                                         IZoomVideoSDKShareAction* pShareAction) = 0;
    
    // Chat
    virtual void onChatNewMessageNotify(IZoomVideoSDKChatHelper* pChatHelper,
                                       IZoomVideoSDKChatMessage* messageItem) = 0;
    virtual void onChatMsgDeleteNotification(IZoomVideoSDKChatHelper* pChatHelper,
                                            const zchar_t* msgID,
                                            ZoomVideoSDKChatMessageDeleteType deleteBy) = 0;
    virtual void onChatPrivilegeChanged(IZoomVideoSDKChatHelper* pChatHelper,
                                       ZoomVideoSDKChatPrivilegeType privilege) = 0;
    
    // Commands
    virtual void onCommandReceived(IZoomVideoSDKUser* sender, const zchar_t* strCmd) = 0;
    virtual void onCommandChannelConnectResult(bool isSuccess) = 0;
    
    // Recording
    virtual void onCloudRecordingStatus(RecordingStatus status,
                                       IZoomVideoSDKRecordingConsentHandler* pHandler) = 0;
    virtual void onUserRecordingConsent(IZoomVideoSDKUser* pUser) = 0;
    virtual void onHostAskUnmute() = 0;
    
    // Live Stream
    virtual void onLiveStreamStatusChanged(IZoomVideoSDKLiveStreamHelper* pLiveStreamHelper,
                                          ZoomVideoSDKLiveStreamStatus status) = 0;
    
    // Live Transcription
    virtual void onLiveTranscriptionStatus(ZoomVideoSDKLiveTranscriptionStatus status) = 0;
    virtual void onLiveTranscriptionMsgReceived(const zchar_t* ltMsg,
                                               IZoomVideoSDKUser* pUser,
                                               ZoomVideoSDKLiveTranscriptionOperationType type) = 0;
    virtual void onLiveTranscriptionMsgInfoReceived(ILiveTranscriptionMessageInfo* messageInfo) = 0;
    virtual void onLiveTranscriptionMsgError(ILiveTranscriptionLanguage* spokenLanguage,
                                            ILiveTranscriptionLanguage* transcriptLanguage) = 0;
    virtual void onOriginalLanguageMsgReceived(ILiveTranscriptionMessageInfo* messageInfo) = 0;
    
    // Phone
    virtual void onInviteByPhoneStatus(PhoneStatus status, PhoneFailedReason reason) = 0;
    virtual void onCalloutJoinSuccess(IZoomVideoSDKUser* pUser, const zchar_t* phoneNumber) = 0;
    
    // Camera Control
    virtual void onCameraControlRequestResult(IZoomVideoSDKUser* pUser, bool isApproved) = 0;
    virtual void onCameraControlRequestReceived(IZoomVideoSDKUser* pUser,
                                               ZoomVideoSDKCameraControlRequestType requestType,
                                               IZoomVideoSDKCameraControlRequestHandler* handler) = 0;
    
    // Multi-Camera
    virtual void onMultiCameraStreamStatusChanged(ZoomVideoSDKMultiCameraStreamStatus status,
                                                 IZoomVideoSDKUser* pUser,
                                                 IZoomVideoSDKRawDataPipe* pVideoPipe) = 0;
    
    // Devices
    virtual void onMicSpeakerVolumeChanged(unsigned int micVolume,
                                          unsigned int speakerVolume) = 0;
    virtual void onAudioDeviceStatusChanged(ZoomVideoSDKAudioDeviceType type,
                                           ZoomVideoSDKAudioDeviceStatus status) = 0;
    virtual void onTestMicStatusChanged(ZoomVideoSDK_TESTMIC_STATUS status) = 0;
    virtual void onSelectedAudioDeviceChanged() = 0;
    virtual void onCameraListChanged() = 0;
    
    // Network
    virtual void onUserVideoNetworkStatusChanged(ZoomVideoSDKNetworkStatus status,
                                                IZoomVideoSDKUser* pUser) = 0;
    virtual void onProxyDetectComplete() = 0;
    virtual void onProxySettingNotification(IZoomVideoSDKProxySettingHandler* handler) = 0;
    virtual void onSSLCertVerifiedFailNotification(IZoomVideoSDKSSLCertificateInfo* info) = 0;
    
    // CRC
    virtual void onCallCRCDeviceStatusChanged(ZoomVideoSDKCRCCallStatus status) = 0;
    
    // Canvas
    virtual void onVideoCanvasSubscribeFail(ZoomVideoSDKSubscribeFailReason fail_reason,
                                           IZoomVideoSDKUser* pUser, void* handle) = 0;
    virtual void onShareCanvasSubscribeFail(ZoomVideoSDKSubscribeFailReason fail_reason,
                                           IZoomVideoSDKUser* pUser, void* handle) = 0;
    
    // Annotations
    virtual void onAnnotationHelperCleanUp(IZoomVideoSDKAnnotationHelper* helper) = 0;
    virtual void onAnnotationPrivilegeChange(IZoomVideoSDKUser* pUser, bool enable) = 0;
    virtual void onAnnotationHelperActived(void* handle) = 0;
    
    // Video Alpha Channel
    virtual void onVideoAlphaChannelStatusChanged(bool isAlphaModeOn) = 0;
    
    // File Transfer
    virtual void onSendFileStatus(IZoomVideoSDKSendFile* file,
                                 const FileTransferStatus& status) = 0;
    virtual void onReceiveFileStatus(IZoomVideoSDKReceiveFile* file,
                                    const FileTransferStatus& status) = 0;
};

class AudioRawData {
public:
    virtual char* GetBuffer() = 0;           // PCM 16-bit buffer
    virtual unsigned int GetBufferLen() = 0; // Buffer length in bytes
    virtual unsigned int GetSampleRate() = 0;// Sample rate (Hz)
    virtual unsigned int GetChannelNum() = 0;// Channels (1=mono, 2=stereo)
    virtual unsigned long long GetTimeStamp() = 0;
};

class YUVRawDataI420 {
public:
    virtual char* GetYBuffer() = 0;
    virtual char* GetUBuffer() = 0;
    virtual char* GetVBuffer() = 0;
    virtual char* GetAlphaBuffer() = 0;      // Optional alpha channel
    virtual char* GetBuffer() = 0;           // Full YUV buffer
    virtual unsigned int GetBufferLen() = 0;
    virtual unsigned int GetStreamWidth() = 0;
    virtual unsigned int GetStreamHeight() = 0;
    virtual unsigned int GetRotation() = 0;  // 0, 90, 180, 270
    virtual unsigned long long GetSourceID() = 0;
    virtual unsigned long long GetTimeStamp() = 0;
    virtual bool IsLimitedI420() = 0;
    
    // Reference counting
    virtual bool CanAddRef() = 0;
    virtual bool AddRef() = 0;
    virtual int Release() = 0;
};

class IZoomVideoSDKRawDataPipeDelegate {
public:
    virtual void onRawDataFrameReceived(YUVRawDataI420* data) = 0;
    virtual void onRawDataStatusChanged(RawDataStatus status) = 0;
};

enum RawDataStatus {
    RawData_On,
    RawData_Off
};

class IZoomVideoSDKVirtualAudioMic {
public:
    virtual void onMicInitialize(IZoomVideoSDKAudioSender* sender) = 0;
    virtual void onMicStartSend() = 0;
    virtual void onMicStopSend() = 0;
    virtual void onMicUninitialized() = 0;
};

class IZoomVideoSDKAudioSender {
public:
    virtual ZoomVideoSDKErrors Send(char* data,
                                   unsigned int dataLength,
                                   int sampleRate) = 0;
};

class IZoomVideoSDKVirtualAudioSpeaker {
public:
    virtual void onVirtualSpeakerMixedAudioReceived(AudioRawData* data_) = 0;
    virtual void onVirtualSpeakerOneWayAudioReceived(AudioRawData* data_,
                                                    IZoomVideoSDKUser* pUser) = 0;
    virtual void onVirtualSpeakerSharedAudioReceived(AudioRawData* data_) = 0;
};

class IZoomVideoSDKVideoSource {
public:
    virtual void onInitialize(IZoomVideoSDKVideoSender* sender,
                             IVideoSDKVector<VideoSourceCapability>* supportCapList,
                             VideoSourceCapability& suggestCap) = 0;
    virtual void onPropertyChange(IVideoSDKVector<VideoSourceCapability>* supportCapList,
                                 VideoSourceCapability suggestCap) = 0;
    virtual void onStartSend() = 0;
    virtual void onStopSend() = 0;
    virtual void onUninitialized() = 0;
};

class IZoomVideoSDKVideoSender {
public:
    virtual ZoomVideoSDKErrors sendVideoFrame(char* frameBuffer,
                                             int width, int height,
                                             int frameLength,
                                             int rotation) = 0;
    // Alternative with Y, U, V planes
    virtual ZoomVideoSDKErrors sendVideoFrame(char* yBuffer, char* uBuffer, char* vBuffer,
                                             int width, int height,
                                             int frameLength,
                                             int rotation) = 0;
};

class IZoomVideoSDKShareSource {
public:
    virtual void onShareSendStarted(IZoomVideoSDKShareSender* pSender) = 0;
    virtual void onShareSendStopped() = 0;
};

class IZoomVideoSDKShareSender {
public:
    virtual ZoomVideoSDKErrors sendShareFrame(char* frameBuffer,
                                             int width, int height,
                                             int frameLength) = 0;
    virtual ZoomVideoSDKErrors sendShareFrame(char* yBuffer, char* uBuffer, char* vBuffer,
                                             int width, int height,
                                             int frameLength,
                                             int rotation) = 0;
};

enum ZoomVideoSDKErrors {
    ZoomVideoSDKErrors_Success = 0,
    ZoomVideoSDKErrors_Wrong_Usage = 1,
    ZoomVideoSDKErrors_Internal_Error = 2,
    ZoomVideoSDKErrors_Uninitialize = 3,
    ZoomVideoSDKErrors_Memory_Error = 4,
    ZoomVideoSDKErrors_Load_Module_Error = 5,
    ZoomVideoSDKErrors_UnLoad_Module_Error = 6,
    ZoomVideoSDKErrors_Invalid_Parameter = 7,
    ZoomVideoSDKErrors_Call_Too_Frequently = 8,
    ZoomVideoSDKErrors_No_Impl = 9,
    ZoomVideoSDKErrors_Dont_Support_Feature = 10,
    ZoomVideoSDKErrors_Unknown = 100,
    
    // Auth errors (1000+)
    ZoomVideoSDKErrors_Auth_Error = 1001,
    ZoomVideoSDKErrors_Auth_Empty_Key_or_Secret = 1002,
    ZoomVideoSDKErrors_Auth_Wrong_Key_or_Secret = 1003,
    ZoomVideoSDKErrors_Auth_DoesNot_Support_SDK = 1004,
    ZoomVideoSDKErrors_Auth_Disable_SDK = 1005,
    
    // Session errors (3000+)
    ZoomVideoSDKErrors_Session_Join_Failed = 3001,
    ZoomVideoSDKErrors_Session_No_Rights = 3002,
    ZoomVideoSDKErrors_Session_Already_In_Progress = 3003,
    ZoomVideoSDKErrors_Session_Dont_Support_SessionType = 3004,
    ZoomVideoSDKErrors_Session_Reconnecting = 3005,
    ZoomVideoSDKErrors_Session_Disconnecting = 3006,
    ZoomVideoSDKErrors_Session_Not_Started = 3007,
    ZoomVideoSDKErrors_Session_Need_Password = 3008,
    ZoomVideoSDKErrors_Session_Password_Wrong = 3009,
    ZoomVideoSDKErrors_Session_Remote_DB_Error = 3010,
    ZoomVideoSDKErrors_Session_Invalid_Param = 3011,
    
    // Audio/Video errors
    ZoomVideoSDKErrors_Session_Audio_Error = 4001,
    ZoomVideoSDKErrors_Session_Audio_No_Microphone = 4002,
    ZoomVideoSDKErrors_Session_Video_Error = 5001,
    ZoomVideoSDKErrors_Session_Video_Device_Error = 5002,
    
    // Share errors
    ZoomVideoSDKErrors_Session_Share_Error = 6001,
    ZoomVideoSDKErrors_Session_Share_Module_Not_Ready = 6002,
    ZoomVideoSDKErrors_Session_Share_You_Are_Not_Sharing = 6003,
    ZoomVideoSDKErrors_Session_Share_Type_Is_Not_Support = 6004,
    ZoomVideoSDKErrors_Session_Share_Internal_Error = 6005,
    
    ZoomVideoSDKErrors_Dont_Support_Multi_Stream_Video_User = 7001,
};

enum ZoomVideoSDKResolution {
    ZoomVideoSDKResolution_90P,
    ZoomVideoSDKResolution_180P,
    ZoomVideoSDKResolution_360P,
    ZoomVideoSDKResolution_720P,
    ZoomVideoSDKResolution_1080P
};

enum RecordingStatus {
    Recording_Start,
    Recording_Stop,
    Recording_Pause,
    Recording_Connecting,
    Recording_DiskFull
};

enum ZoomVideoSDKRawDataMemoryMode {
    ZoomVideoSDKRawDataMemoryModeStack,
    ZoomVideoSDKRawDataMemoryModeHeap
};

#include "zoom_video_sdk_api.h"              // CreateZoomVideoSDKObj, DestroyZoomVideoSDKObj
#include "zoom_video_sdk_interface.h"        // IZoomVideoSDK
#include "zoom_video_sdk_delegate_interface.h" // IZoomVideoSDKDelegate
#include "zoom_video_sdk_def.h"              // Structures, enums
#include "zoom_video_sdk_platform.h"         // Platform definitions
#include "zoom_sdk_raw_data_def.h"           // Raw data types

// Helpers
#include "helpers/zoom_video_sdk_user_helper_interface.h"
#include "helpers/zoom_video_sdk_audio_helper_interface.h"
#include "helpers/zoom_video_sdk_video_helper_interface.h"
#include "helpers/zoom_video_sdk_share_helper_interface.h"
#include "helpers/zoom_video_sdk_chat_helper_interface.h"
#include "helpers/zoom_video_sdk_recording_helper_interface.h"
#include "helpers/zoom_video_sdk_livestream_helper_interface.h"
#include "helpers/zoom_video_sdk_livetranscription_helper_interface.h"
#include "helpers/zoom_video_sdk_cmd_channel_interface.h"
#include "helpers/zoom_video_sdk_phone_helper_interface.h"
#include "helpers/zoom_video_sdk_audio_send_rawdata_interface.h"
#include "helpers/zoom_video_sdk_video_source_helper_interface.h"