zego-api-defines.h

Go to the documentation of this file.

//
//  zego-api-defines.h
//  zegoavkit
//
//  Copyright © 2017年 Zego. All rights reserved.
//
 
#ifndef zego_api_defines_h
#define zego_api_defines_h
 
#define ZEGO_MAX_COMMON_LEN (512)
#define ZEGO_MAX_URL_COUNT (10)
#define ZEGO_MAX_EVENT_INFO_COUNT (10)
#define ZEGO_MAX_MIX_INPUT_COUNT (12)
#define ZEGO_MAX_MIX_OUTPUT_COUNT (6)
#define ZEGO_MAX_IDENTITY_LEN (64)
#define ZEGO_MAX_ROOMMESSAGE_LEN (10240)
#define ZEGO_MAX_URL_LEN (1024)
#define ZEGO_MAX_ROOMID_LEN (128)
#define ZEGO_MAX_PATH_LEN (2048)
 
#define ZEGO_MAX_USERID_LEN (64)
#define ZEGO_MAX_USERNAME_LEN (256)
#define ZEGO_MAX_EXTRA_INFO_LEN (1024)
#define ZEGO_DEFAULT_LOG_SIZE (5242880) // 5 * 1024 * 1024 bytes, default size for single log file
#define ZEGO_MIN_LOG_SIZE (1048576)     // 1 * 1024 * 1024 bytes, min size for single log file
#define ZEGO_MAX_LOG_SIZE (104857600)   // 100 * 1024 * 1024 bytes, max size for single log file
#define ZEGO_MIN_LOG_FILE_COUNT (3)
#define ZEGO_MAX_LOG_FILE_COUNT (20)
 
#define ZEGO_MAX_ROOM_EXTRA_INFO_KEY_LEN (128)
#define ZEGO_MAX_ROOM_EXTRA_INFO_VALUE_LEN (4096)
 
#undef _I64_
#undef _64u_
#undef _I64uw_
#undef _i64uw_
#if defined(_MSC_VER) || defined(__BORLANDC__)
#define _I64_ "I64"
#define _64u_ "%I64u"
#define _I64uw_ L"%llu" L
#define _i64uw_ L"%llu" L
#else
#define _I64_ "ll"
#define _64u_ "%llu"
#define _I64uw_ L"%llu" L
#define _i64uw_ L"%llu" L
#undef __int64
#define __int64 long long
#endif
 
#ifdef WIN32
 
#ifdef ZEGOAVKIT_EXPORTS
#define ZEGOAVKIT_API __declspec(dllexport)
#elif defined(ZEGOAVKIT_STATIC)
#define ZEGOAVKIT_API // * nothing
#else
#define ZEGOAVKIT_API __declspec(dllimport)
#endif
 
#else
 
#define ZEGOAVKIT_API __attribute__((visibility("default")))
 
#endif
 
#define ZEGO_DEPRECATED 
 
#include <stddef.h>
 
namespace ZEGO {
namespace AV {
enum RemoteViewIndex {
    RemoteViewIndex_First = 0,
    RemoteViewIndex_Second = 1,
    RemoteViewIndex_Third = 2,
};
 
enum ZegoVideoViewMode {
    ZegoVideoViewModeScaleAspectFit = 0,  
    ZegoVideoViewModeScaleAspectFill = 1, 
    ZegoVideoViewModeScaleToFill = 2,     
};
 
enum ZegoVideoMirrorMode {
    ZegoVideoMirrorModePreviewMirrorPublishNoMirror = 0, 
    ZegoVideoMirrorModePreviewCaptureBothMirror = 1, 
    ZegoVideoMirrorModePreviewCaptureBothNoMirror = 2, 
    ZegoVideoMirrorModePreviewNoMirrorPublishMirror = 3 
};
 
enum ZegoVideoCodecAvc {
    VIDEO_CODEC_DEFAULT = 0, 
    VIDEO_CODEC_MULTILAYER =
        1, 
    VIDEO_CODEC_VP8 = 2,              
    VIDEO_CODEC_H265 = 3,             
    VIDEO_CODEC_H264_DUAL_STREAM = 4, 
    VIDEO_CODEC_UNKNOWN = 100,        
};
 
enum ZegoVideoCodecBackend {
    VIDEO_CODEC_BACKEND_ANY = 0,      
    VIDEO_CODEC_BACKEND_SOFTWARE = 1, 
    VIDEO_CODEC_BACKEND_HARDWARE = 2, 
};
 
enum AudioDeviceType {
    AudioDevice_Input = 0, 
    AudioDevice_Output,    
};
 
enum MixSysPlayoutPropertyMask {
    MIX_PROP_NONE = 0,
    MIX_PROP_ENABLE_AGC_FOR_SYS_PLAYOUT =
        1, //当开启采集系统声卡声音时，传递此参数启用自动增益(仅支持win)
};
 
struct DeviceInfo {
    char szDeviceId[ZEGO_MAX_COMMON_LEN];
    char szDeviceName[ZEGO_MAX_COMMON_LEN];
 
    DeviceInfo() {
        szDeviceId[0] = '\0';
        szDeviceName[0] = '\0';
    }
};
 
struct DeviceVideoCapabilityInfo {
    int height;
    int width;
    int fps;
 
    DeviceVideoCapabilityInfo() {
        height = 0;
        width = 0;
        fps = 0;
    }
};
 
enum DeviceState {
    Device_Added = 0, 
    Device_Deleted,   
};
 
enum DeviceStatus {
    Device_Unknown = -1, 
    Device_Opened = 0,   
    Device_Closed,       
};
 
enum VolumeType {
    Volume_EndPoint = 0, 
    Volume_Simple,       
};
 
struct ZegoUser {
    char szId[ZEGO_MAX_COMMON_LEN];
    char szName[ZEGO_MAX_COMMON_LEN];
 
    ZegoUser() {
        szId[0] = '\0';
        szName[0] = '\0';
    }
};
 
struct ZegoStreamInfo {
    ZegoStreamInfo() {
        uiRtmpURLCount = 0;
        uiHlsURLCount = 0;
        uiFlvURLCount = 0;
        szStreamID[0] = '\0';
        szMixStreamID[0] = '\0';
        for (int i = 0; i < ZEGO_MAX_URL_COUNT; i++) {
            arrRtmpURLs[i] = NULL;
            arrFlvRULs[i] = NULL;
            arrHlsURLs[i] = NULL;
        }
    }
 
    char szStreamID[ZEGO_MAX_COMMON_LEN];
    char szMixStreamID[ZEGO_MAX_COMMON_LEN];
    char *arrRtmpURLs[ZEGO_MAX_URL_COUNT];
    unsigned int uiRtmpURLCount;
    char *arrFlvRULs[ZEGO_MAX_URL_COUNT];
    unsigned int uiFlvURLCount;
    char *arrHlsURLs[ZEGO_MAX_URL_COUNT];
    unsigned int uiHlsURLCount;
};
 
enum ZegoStreamRelayCDNState {
    RELAY_STOP = 0,  
    RELAY_START = 1, 
    RELAY_RETRY = 2, 
};
 
enum ZegoStreamRelayCDNDetail {
    Relay_None = 0,                   
    Relay_ServerError = 8,            
    Relay_HandShakeFailed = 9,        
    Relay_AccessPointError = 10,      
    Relay_CreateStreamFailed = 11,    
    Relay_BadName = 12,               
    Relay_CDNServerDisconnected = 13, 
    Relay_Disconnected = 14,          
 
    MixStream_AllInputStreamClosed = 1214, 
    MixStream_AllInputStreamNoData = 1215, 
    MixStream_ServerInternalError = 1230, 
};
 
struct ZegoStreamRelayCDNInfo {
    ZegoStreamRelayCDNInfo() {
        rtmpURL[0] = '\0';
        state = RELAY_STOP;
        stateTime = 0;
        detail = Relay_None;
    }
 
    char rtmpURL[ZEGO_MAX_COMMON_LEN];
    ZegoStreamRelayCDNState state;
    ZegoStreamRelayCDNDetail detail; //转推停止或重试时有效
    unsigned int stateTime;
};
 
enum ZEGONetType {
    ZEGO_NT_NONE = 0,
    ZEGO_NT_LINE = 1,
    ZEGO_NT_WIFI = 2,
    ZEGO_NT_2G = 3,
    ZEGO_NT_3G = 4,
    ZEGO_NT_4G = 5,
    ZEGO_NT_5G = 6,
    ZEGO_NT_UNKNOWN = 32
};
 
enum ZegoPublishFlag {
    ZEGO_JOIN_PUBLISH = 0, 
    ZEGO_MIX_STREAM = 1 << 1, 
    ZEGO_SINGLE_ANCHOR = 1 << 2, 
};
 
enum ZegoTaskType {
    TASK_NORMAL = 1, //正常任务
    TASK_DELAY = 2,  //延时类任务(如定时器任务)
};
 
enum ZegoFontType {
    FONT_SOURCE_HAN_SANS = 0,
    FONT_ALIBABA_SANS = 1,
    FONT_PANG_MEN_ZHENG_DAO_TITLE = 2,
    FONT_HAPPY_ZCOOL = 3
};
struct ZegoFontStyle {
    ZegoFontType type;
    int size;
    int color;
    int transparency;
    bool border;
    int borderColor;
 
    ZegoFontStyle()
        : type(FONT_SOURCE_HAN_SANS), size(24), color(16777215), transparency(0), border(false),
          borderColor(0) {}
};
struct ZegoLabelInfo {
    char text[ZEGO_MAX_COMMON_LEN];
    int left;
    int top;
    ZegoFontStyle font;
 
    ZegoLabelInfo() : left(0), top(0), font() { text[0] = '\0'; }
};
 
struct ZegoMixImageInfo {
    char url[ZEGO_MAX_URL_LEN];
 
    int displayMode;
 
    ZegoMixImageInfo() {
        url[0] = '\0';
        displayMode = 0;
    }
};
 
struct ZegoMixErrorTargetRoomInfo {
    char szStreamID[ZEGO_MAX_URL_LEN];  
    char szRoomID[ZEGO_MAX_ROOMID_LEN]; 
};
 
struct ZegoMixStreamConfig {
    char szStreamID[ZEGO_MAX_URL_LEN]; 
    struct {
        int top;
        int left;
        int bottom;
        int right;
    } layout;
    unsigned int uSoundLevelID; 
    int nContentControl; 
    int nVolume;         
 
    ZegoMixStreamConfig() : uSoundLevelID(0), nContentControl(0), nVolume(100) {
        szStreamID[0] = '\0';
        layout.top = 0;
        layout.left = 0;
        layout.bottom = 0;
        layout.right = 0;
    }
};
 
struct ZegoCompleteMixStreamConfig {
    char szOutputStream[ZEGO_MAX_URL_LEN]; 
    bool bOutputIsUrl; 
    int nOutputFps;          
    int nOutputBitrate;      
    int nOutputAudioBitrate; 
    int nOutputWidth;  
    int nOutputHeight; 
    int nOutputAudioConfig; 
    ZegoMixStreamConfig *pInputStreamList; 
    int nInputStreamCount;                 
    const unsigned char *pUserData; 
    int nLenOfUserData;             
    int nChannels; 
    int nOutputBackgroundColor; 
    const char *pOutputBackgroundImage; 
    bool bWithSoundLevel; 
    int nExtra; 
    ZegoCompleteMixStreamConfig()
        : bOutputIsUrl(false), nOutputFps(0), nOutputBitrate(0), nOutputAudioBitrate(0),
          nOutputWidth(0), nOutputHeight(0), nOutputAudioConfig(0), pInputStreamList(0),
          nInputStreamCount(0), pUserData(0), nLenOfUserData(0), nChannels(1),
          nOutputBackgroundColor(0x00000000), pOutputBackgroundImage(0), bWithSoundLevel(false),
          nExtra(0) {
        szOutputStream[0] = '\0';
    }
};
 
struct ZegoMixStreamResult {
    unsigned int uiErrorCode;
    int nNonExistsStreamCount;
    const char *ppNonExistsStreamIDList[ZEGO_MAX_MIX_INPUT_COUNT];
    ZegoStreamInfo oStreamInfo;
 
    ZegoMixStreamResult() : uiErrorCode(0), nNonExistsStreamCount(0) {
        for (int i = 0; i < ZEGO_MAX_MIX_INPUT_COUNT; i++) {
            ppNonExistsStreamIDList[i] = NULL;
        }
    }
};
 
struct ZegoMixStreamResultEx {
    unsigned int uiErrorCode;
    int nNonExistsStreamCount;
    const char *ppNonExistsStreamIDList[ZEGO_MAX_MIX_INPUT_COUNT];
    int nImageErrorStreamCount;
    const char *ppImageErrorStreamIDList[ZEGO_MAX_MIX_INPUT_COUNT];
    int nErrorTargetRoomCount;
    const ZegoMixErrorTargetRoomInfo *ppErrorTargetRoomList[ZEGO_MAX_MIX_OUTPUT_COUNT];
    int nStreamInfoCount;
    ZegoStreamInfo *pStreamInfoList;
 
    ZegoMixStreamResultEx()
        : uiErrorCode(0), nNonExistsStreamCount(0), nImageErrorStreamCount(0),
          nErrorTargetRoomCount(0), nStreamInfoCount(0), pStreamInfoList(0) {
        for (int i = 0; i < ZEGO_MAX_MIX_INPUT_COUNT; i++) {
            ppNonExistsStreamIDList[i] = NULL;
            ppImageErrorStreamIDList[i] = NULL;
        }
        for (int i = 0; i < ZEGO_MAX_MIX_OUTPUT_COUNT; i++) {
            ppErrorTargetRoomList[i] = NULL;
        }
    }
};
 
enum ZegoLogLevel {
    Grievous = 0,
    Error = 1,
    Warning = 2,
    Generic = 3, 
    Debug = 4    
};
 
struct ZegoProxyInfo {
    const char *ip;       
    unsigned int port;    
    const char *hostName; 
    const char *userName; 
    const char *password; 
 
    ZegoProxyInfo() {
        ip = NULL;
        port = 0;
        hostName = NULL;
        userName = NULL;
        password = NULL;
    }
};
 
enum EventType {
    Play_BeginRetry = 1,   
    Play_RetrySuccess = 2, 
    Publish_BeginRetry = 3,   
    Publish_RetrySuccess = 4, 
    Play_TempDisconnected = 5,    
    Publish_TempDisconnected = 6, 
    Play_VideoBreak = 7,        
    Play_VideoBreakEnd = 8,     
    Play_VideoBreakCancel = 13, 
    Play_AudioBreak = 9,        
    Play_AudioBreakEnd = 10,    
    Play_AudioBreakCancel = 14, 
    PublishInfo_RegisterFailed = 11,  
    PublishInfo_RegisterSuccess = 12, 
    Play_FrameBreak = 15,    
    Play_FrameBreakEnd = 16, 
};
 
struct EventInfo {
    unsigned int uiInfoCount;
    const char *arrKeys[ZEGO_MAX_EVENT_INFO_COUNT];
    const char *arrValues[ZEGO_MAX_EVENT_INFO_COUNT];
 
    EventInfo() : uiInfoCount(0) {
        for (int i = 0; i < ZEGO_MAX_EVENT_INFO_COUNT; i++) {
            arrKeys[i] = NULL;
            arrValues[i] = NULL;
        }
    }
};
 
enum ZegoVideoConfigPreference {
    ZEGO_VIDEO_CONFIG_PREFERENCE_SMOOTH = 0,
    ZEGO_VIDEO_CONFIG_PREFERENCE_CLEAR = 1,
    ZEGO_VIDEO_CONFIG_PREFERENCE_BALANCED = 2
 
};
 
struct ZegoAdaptiveVideoConfig {
    int preference;
 
    int minEncodeWidth;
 
    int minEncodeHeight;
 
    int minFPS;
 
    ZegoAdaptiveVideoConfig()
        : preference(ZEGO_VIDEO_CONFIG_PREFERENCE_BALANCED), minEncodeWidth(240),
          minEncodeHeight(240), minFPS(10) {}
};
 
enum ZegoStreamEventType {
    STREAM_EVENT_PUBLISH_START = 100,
    STREAM_EVENT_PUBLISH_SUCCESS = 101,
    STREAM_EVENT_PUBLISH_FAIL = 102,
    STREAM_EVENT_RETRY_PUBLISH_START = 103,
    STREAM_EVENT_RETRY_PUBLISH_SUCCESS = 104,
    STREAM_EVENT_RETRY_PUBLISH_FAIL = 105,
    STREAM_EVENT_PUBLISH_END = 106,
    STREAM_EVENT_PLAY_START = 200,
    STREAM_EVENT_PLAY_SUCCESS = 201,
    STREAM_EVENT_PLAY_FAIL = 202,
    STREAM_EVENT_RETRY_PLAY_START = 203,
    STREAM_EVENT_RETRY_PLAY_SUCCESS = 204,
    STREAM_EVENT_RETRY_PLAY_FAIL = 205,
    STREAM_EVENT_PLAY_END = 206,
};
 
struct ZegoItem {
    const char *key;
    const char *value;
};
 
struct ZegoStreamEventExtraInfo {
    unsigned int info_count;
    ZegoItem info[ZEGO_MAX_EVENT_INFO_COUNT];
};
 
#if defined(WIN32) || defined(ANDROID) || defined(_OS_OHOS_)
ZEGOAVKIT_API extern const char *kZegoDeviceCamera;
ZEGOAVKIT_API extern const char *kZegoDeviceMicrophone;
ZEGOAVKIT_API extern const char *kZegoDeviceAudio;
ZEGOAVKIT_API extern const char *kZegoDeviceSpeaker;
ZEGOAVKIT_API extern const char *kZegoDeviceAudioSession;
ZEGOAVKIT_API extern const char *kZegoStreamID;
ZEGOAVKIT_API extern const char *kZegoUrl;
ZEGOAVKIT_API extern const char *kZegoStreamProtocol;
ZEGOAVKIT_API extern const char *kZegoNetProtocl;
ZEGOAVKIT_API extern const char *kZegoResourceType;
ZEGOAVKIT_API extern const char *kZegoError;
#else
extern const char *kZegoDeviceCamera;
extern const char *kZegoDeviceMicrophone;
extern const char *kZegoDeviceAudio;
extern const char *kZegoDeviceSpeaker;
extern const char *kZegoDeviceAudioSession;
extern const char *kZegoStreamID;
extern const char *kZegoUrl;
extern const char *kZegoStreamProtocol;
extern const char *kZegoNetProtocl;
extern const char *kZegoResourceType;
extern const char *kZegoError;
#endif
 
enum ZegoVideoEncoderRateControlStrategy {
    ZEGO_RC_ABR = 0, 
    ZEGO_RC_CBR = 1, 
    ZEGO_RC_VBR = 2, 
    ZEGO_RC_CRF = 3, 
};
 
enum ZegoCapturePipelineScaleMode {
    ZegoCapturePipelinePreScale = 0,  
    ZegoCapturePipelinePostScale = 1, 
};
 
enum ZegoAVAPIAudioDeviceMode {
    ZEGO_AUDIO_DEVICE_MODE_COMMUNICATION = 1, 
    ZEGO_AUDIO_DEVICE_MODE_GENERAL = 2,       
    ZEGO_AUDIO_DEVICE_MODE_AUTO = 3, 
    ZEGO_AUDIO_DEVICE_MODE_COMMUNICATION2 =
        4, 
    ZEGO_AUDIO_DEVICE_MODE_COMMUNICATION3 =
        5, 
    ZEGO_AUDIO_DEVICE_MODE_GENERAL2 =
        6, 
    ZEGO_AUDIO_DEVICE_MODE_GENERAL3 =
        7, 
    ZEGO_AUDIO_DEVICE_MODE_COMMUNICATION4 =
        8, 
};
 
enum ZegoAVAPILatencyMode {
    ZEGO_LATENCY_MODE_NORMAL = 0, 
    ZEGO_LATENCY_MODE_LOW,        
    ZEGO_LATENCY_MODE_NORMAL2,    
    ZEGO_LATENCY_MODE_LOW2, 
    ZEGO_LATENCY_MODE_LOW3, 
    ZEGO_LATENCY_MODE_NORMAL3, 
};
 
enum ZegoTrafficControlProperty {
    ZEGO_TRAFFIC_CONTROL_BASIC = 0,
    ZEGO_TRAFFIC_CONTROL_ADAPTIVE_FPS = 1,
    ZEGO_TRAFFIC_CONTROL_ADAPTIVE_RESOLUTION = 1 << 1,
 
    ZEGO_TRAFFIC_CONTROL_ADAPTIVE_AUDIO_BITRATE = 1 << 2,
 
    ZEGO_TRAFFIC_NONE = ZEGO_TRAFFIC_CONTROL_BASIC,
    ZEGO_TRAFFIC_FPS = ZEGO_TRAFFIC_CONTROL_ADAPTIVE_FPS,
    ZEGO_TRAFFIC_RESOLUTION = ZEGO_TRAFFIC_CONTROL_ADAPTIVE_RESOLUTION,
};
 
enum ZegoTrafficControlMinVideoBitrateMode {
    ZEGO_TRAFFIC_CONTROL_MIN_VIDEO_BITRATE_NO_VIDEO = 0,
    ZEGO_TRAFFIC_CONTROL_MIN_VIDEO_BITRATE_ULTRA_LOW_FPS
};
 
enum ZegoAVAPIAudioRecordMask {
    ZEGO_AUDIO_RECORD_NONE = 0x0,    
    ZEGO_AUDIO_RECORD_CAP = 0x01,    
    ZEGO_AUDIO_RECORD_RENDER = 0x02, 
    ZEGO_AUDIO_RECORD_MIX = 0x04     
};
 
enum LiveStreamQuality {
    Unknown = -1,
    Excellent = 0,
    Good = 1,
    Middle = 2,
    Poor = 3,
    Die = 4,
    MaxGrade,
};
 
struct PublishQuality {
    double cfps;    
    double vencFps; 
    double fps;     
    double kbps;    
 
    double acapFps; 
    double afps;    
    double akbps;   
 
    int rtt;         
    int pktLostRate; 
    int quality;     
 
    bool isHardwareVenc; 
    int videoCodecId;    
    int width;           
    int height;          
 
    double totalBytes; 
    double audioBytes; 
    double videoBytes; 
 
    double cpuAppUsage;   
    double cpuTotalUsage; 
 
    double memoryAppUsage;   
    double memoryTotalUsage; 
    double memoryAppUsed;    
 
    PublishQuality() {
        cfps = 0;
        vencFps = 0;
        fps = 0;
        kbps = 0;
 
        acapFps = 0;
        afps = 0;
        akbps = 0;
 
        rtt = 0;
        pktLostRate = 0;
        quality = 0;
 
        isHardwareVenc = false;
        videoCodecId = 0;
        width = 0;
        height = 0;
 
        totalBytes = 0;
        audioBytes = 0;
        videoBytes = 0;
 
        cpuAppUsage = 0;
        cpuTotalUsage = 0;
 
        memoryAppUsage = 0;
        memoryTotalUsage = 0;
        memoryAppUsed = 0;
    }
};
 
struct PlayQuality {
    double fps;     
    double vdjFps;  
    double vdecFps; 
    double vrndFps; 
    double kbps;    
 
    double afps;    
    double adjFps;  
    double adecFps; 
    double arndFps; 
    double akbps;   
 
    double audioBreakRate;     
    double videoBreakRate;     
    int rtt;                   
    int pktLostRate;           
    int peerToPeerDelay;       
    int peerToPeerPktLostRate; 
    int quality;               
    int delay;                 
    double
        mos; 
 
    bool isHardwareVdec; 
    int videoCodecId;    
    int width;           
    int height;          
 
    double totalBytes; 
    double audioBytes; 
    double videoBytes; 
 
    double cpuAppUsage;   
    double cpuTotalUsage; 
 
    double memoryAppUsage;   
    double memoryTotalUsage; 
    double memoryAppUsed;    
    int avTimestampDiff; 
 
    unsigned int audioCumulativeBreakCount; 
    unsigned int audioCumulativeBreakTime;  
    unsigned int audioCumulativeDecodeTime; 
    double audioCumulativeBreakRate;        
    unsigned int videoCumulativeBreakCount; 
    unsigned int videoCumulativeBreakTime;  
    unsigned int videoCumulativeDecodeTime; 
    double videoCumulativeBreakRate;        
    int muteVideo;
    int muteAudio;
 
    PlayQuality() {
        fps = 0;
        vdjFps = 0;
        vdecFps = 0;
        vrndFps = 0;
        kbps = 0;
 
        afps = 0;
        adjFps = 0;
        adecFps = 0;
        arndFps = 0;
        akbps = 0;
 
        audioBreakRate = 0;
        videoBreakRate = 0;
        rtt = 0;
        pktLostRate = 0;
        peerToPeerDelay = 0;
        peerToPeerPktLostRate = 0;
        quality = 0;
        delay = 0;
        mos = -1;
 
        isHardwareVdec = false;
        videoCodecId = 0;
        width = 0;
        height = 0;
 
        totalBytes = 0;
        audioBytes = 0;
        videoBytes = 0;
 
        cpuAppUsage = 0;
        cpuTotalUsage = 0;
 
        memoryAppUsage = 0;
        memoryTotalUsage = 0;
        memoryAppUsed = 0;
 
        avTimestampDiff = 0;
 
        audioCumulativeBreakCount = 0;
        audioCumulativeBreakTime = 0;
        audioCumulativeDecodeTime = 0;
        audioCumulativeBreakRate = 0;
        videoCumulativeBreakCount = 0;
        videoCumulativeBreakTime = 0;
        videoCumulativeDecodeTime = 0;
        videoCumulativeBreakRate = 0;
        muteVideo = 0;
        muteAudio = 0;
    }
};
 
struct ZegoPlayStats {
    double rxKBitrate;      
    double rxAudioKBitrate; 
    double rxVideoKBitrate; 
 
    ZegoPlayStats() {
        rxKBitrate = 0;
        rxAudioKBitrate = 0;
        rxVideoKBitrate = 0;
    }
};
 
enum PublishChannelIndex {
    PUBLISH_CHN_MAIN = 0, 
    PUBLISH_CHN_AUX,   
    PUBLISH_CHN_THIRD, 
    PUBLISH_CHN_FOURTH, 
};
 
enum VideoStreamLayer {
    VideoStreamLayer_Auto = -1,      
    VideoStreamLayer_BaseLayer = 0,  
    VideoStreamLayer_ExtendLayer = 1 
};
 
enum MediaInfoType {
    SideInfoZegoDefined = 0,
    SeiZegoDefined = 1,
    SeiUserUnregisted = 2
};
 
enum SeiSendType {
    SeiSendSingleFrame = 0,
    SeiSendInVideoFrame = 1
};
 
struct SoundLevelInfo {
    unsigned int soundLevelID;
    unsigned char soundLevel;
 
    SoundLevelInfo() {
        soundLevelID = 0;
        soundLevel = 0;
    }
};
 
enum ZegoAECMode {
    AEC_MODE_AGGRESSIVE,
    AEC_MODE_MEDIUM,
    AEC_MODE_SOFT,
    AEC_MODE_AI,
};
 
enum ZegoANSMode {
    ANS_MODE_LOW = 0,
    ANS_MODE_MEDIUM = 1,
    ANS_MODE_HIGH = 2,
    ANS_MODE_AI = 3,
    ANS_MODE_AI_BALANCED = 4,
    ANS_MODE_AI_LOW_LATENCY = 5,
    ANS_MODE_AI_AGGRESSIVE = 6,
};
 
enum ZegoDeviceErrorCode {
    ZEGO_DEVICE_ERROR_GENERIC = -1,
    ZEGO_DEVICE_ERROR_INVALID_ID = -2,
    ZEGO_DEVICE_ERROR_NO_AUTHORIZATION = -3,
    ZEGO_DEVICE_ERROR_ZERO_FPS = -4,
    ZEGO_DEVICE_ERROR_IN_USE_BY_OTHER = -5,
    ZEGO_DEVICE_ERROR_UNPLUGGED = -6,
    ZEGO_DEVICE_ERROR_REBOOT_REQUIRED = -7,
    ZEGO_DEVICE_ERROR_MEDIA_SERVICES_LOST = -8,
    ZEGO_DEVICE_ERROR_IN_USE_BY_SIRI = -9,
    ZEGO_DEVICE_ERROR_SOUND_LEVEL_TOO_LOW = -10,
    ZEGO_DEVICE_ERROR_MAGNETIC_CASE = -11,
    ZEGO_DEVICE_ERROR_AUDIO_SESSION_DEACTIVE = -100,
    ZEGO_DEVICE_ERROR_AUDIO_SESSION_CATEGORY_CHANGE = -101,
};
 
enum ZegoNotifyDeviceStateMode {
    ZEGO_NOTIFY_DEVICE_STATE_MODE_OPEN = 0,
    ZEGO_NOTIFY_DEVICE_STATE_MODE_CLOSE = 1,
};
 
enum ZegoDeviceErrorReason {
    ZEGO_DEVICE_ERROR_REASON_GENERIC = -1,
    ZEGO_DEVICE_ERROR_REASON_INVALID_ID = -2,
    ZEGO_DEVICE_ERROR_REASON_NO_AUTHORIZATION = -3,
    ZEGO_DEVICE_ERROR_REASON_ZERO_FPS = -4,
    ZEGO_DEVICE_ERROR_REASON_IN_USE_BY_OTHER = -5,
    ZEGO_DEVICE_ERROR_REASON_UNPLUGGED = -6,
    ZEGO_DEVICE_ERROR_REASON_REBOOT_REQUIRED = -7,
    ZEGO_DEVICE_ERROR_REASON_MEDIA_SERVICES_LOST = -8,
    ZEGO_DEVICE_ERROR_REASON_IN_USE_BY_SIRI = -9,
    ZEGO_DEVICE_ERROR_REASON_SOUND_LEVEL_TOO_LOW = -10,
    ZEGO_DEVICE_ERROR_REASON_MAGNETIC_CASE = -11,
    ZEGO_DEVICE_ERROR_REASON_NONE = 0,
    ZEGO_DEVICE_ERROR_REASON_DISABLED = 2,
    ZEGO_DEVICE_ERROR_REASON_MUTE = 3,
    ZEGO_DEVICE_ERROR_REASON_INTERRUPTION = 4,
    ZEGO_DEVICE_ERROR_REASON_IN_BACKGROUND = 5,
    ZEGO_DEVICE_ERROR_REASON_MULTI_FOREGROUND_APP = 6,
    ZEGO_DEVICE_ERROR_REASON_SYSTEM_PRESSURE = 7,
};
 
enum ChannelExtraParamKey {
    // ZEGO_CHANNEL_PARAM_KEY_VIDEO_SWENCODER_USAGE = 0,
    // ZEGO_CHANNEL_PARAM_KEY_VIDEO_X264_CONFIG = 1,
    ZEGO_CHANNEL_PARAM_KEY_AV_CAPTURE_DEVICE = 2,
};
 
enum ZegoAudioRoute {
    ZEGO_AUDIO_ROUTE_SPEAKER = 0,
    ZEGO_AUDIO_ROUTE_HEADSET,
    ZEGO_AUDIO_ROUTE_BLUETOOTH,
    ZEGO_AUDIO_ROUTE_RECEIVER,
    ZEGO_AUDIO_ROUTE_USB_AUDIO,
    ZEGO_AUDIO_ROUTE_AIR_PLAY
};
 
struct ZegoCodecCapabilityInfo {
    ZegoVideoCodecAvc codecId;
    int isHardware;
 
    ZegoCodecCapabilityInfo() {
        codecId = ZegoVideoCodecAvc::VIDEO_CODEC_DEFAULT;
        isHardware = 0;
    }
};
 
enum ZegoCodecError {
    ZEGO_CODEC_ERROR_NONE = 0,
    ZEGO_CODEC_ERROR_NOT_SUPPORT = -1,
    ZEGO_CODEC_ERROR_FAILED = -2,
    ZEGO_CODEC_ERROR_LOW_FPS = -3,
};
 
enum ZegoStreamResourceMode {
    DEFAULT = 0,
    CDN_ONLY = 1,
    L3_ONLY = 2,
    RTC_ONLY = 3,
    CDN_PLUS = 4,
    CUSTOM = 5
};
 
enum ZegoAudioMixMode {
    ZEGO_AUDIO_MIX_MODE_RAW = 0,
    ZEGO_AUDIO_MIX_MODE_FOCUSED
};
 
enum ZegoTrafficControlFocusOn {
    ZEGO_TRAFFIC_CONTROL_FOCUS_ON_LOCAL_ONLY = 0,
    ZEGO_TRAFFIC_CONTROL_FOCUS_ON_REMOTE = 1,
};
 
enum ZegoVideoSourceType {
    VIDEO_SRC_DEFAULT = 0,
    VIDEO_SRC_NONE = 1,
    VIDEO_SRC_CAMERA = 2,
    VIDEO_SRC_EXTERNAL_CAPTURE = 3,
    VIDEO_SRC_MAIN_PUBLISH_CHN = 4,
    VIDEO_SRC_PLAYER = 5,
    VIDEO_SRC_SCREEN_CAPTURE = 6,
    VIDEO_SRC_SECONDARY_CAMERA = 7,
};
 
enum ZegoAudioSourceType {
    AUDIO_SRC_NONE = 0,             
    AUDIO_SRC_MIC = 1,              
    AUDIO_SRC_EXTERNAL_CAPTURE = 2, 
    AUDIO_SRC_MEDIA_CAPTURE = 3,    
    AUDIO_SRC_MAIN_PUBLISH_CHN = 4, 
    AUDIO_SRC_PLAYER = 5, 
};
 
enum ZegoVideoEncodeMode {
    ZEGO_VIDEO_ENCODE_MODE_LOW_DELAY = 0,
    ZEGO_VIDEO_ENCODE_MODE_LOW_BITRATE = 1,
};
 
struct ZegoRect {
    int left;
    int top;
    int right;
    int bottom;
 
    ZegoRect() {
        left = 0;
        top = 0;
        right = 0;
        bottom = 0;
    }
};
 
struct ZegoSize {
    int width;
    int height;
 
    ZegoSize() {
        width = 0;
        height = 0;
    }
};
 
enum AudioVADType {
    // 噪声
    AudioVADTypeNoise = 0,
    // 人声
    AudioVADTypeSpeech = 1,
};
 
enum ZegoEncodeProfile {
    ZegoEncodeProfileBaseline = 0,
    ZegoEncodeProfileMain = 1,
    ZegoEncodeProfileHigh = 2
};
 
enum ZegoOrientationMode {
    ZegoOrientationModeCustom = 0,
 
    ZegoOrientationModeAdaption = 1,
 
    ZegoOrientationModeAlignment = 2,
 
    ZegoOrientationModeFixedResolutionRatio = 3
};
 
enum ZegoCDNProtocol {
    ZEGO_CDN_PROTOCOL_TCP = 1,
    ZEGO_CDN_PROTOCOL_QUIC = 2
};
 
struct ZegoCDNPublishTarget {
    const char *url;
    ZegoCDNProtocol *protocol_ordered_list;
    int protocol_ordered_list_count;
    const char **quic_version_list;
    int quic_version_list_count;
 
    int quic_connect_mode;
 
    ZegoCDNPublishTarget() {
        url = nullptr;
        protocol_ordered_list = nullptr;
        protocol_ordered_list_count = 0;
        quic_version_list = nullptr;
        quic_version_list_count = 0;
        quic_connect_mode = 0;
    }
};
 
//推流时视频流审查模式
enum ZegoStreamCensorshipMode {
    CENSORSHIP_NONE = 0,           //不审查
    CENSORSHIP_AUDIO = 1,          //仅审查流中的音频
    CENSORSHIP_VIDEO = 2,          //仅审查流中的视频(不包含音频)
    CENSORSHIP_AUDIO_AND_VIDEO = 3 //审查流中的音频和视频
};
 
// 能力协商范围
enum ZegoCapabilityNegotiationType {
    ZEGO_CAPABILITY_NEGOTIATION_TYPE_NONE = 0,      // 关闭协商
    ZEGO_CAPABILITY_NEGOTIATION_TYPE_ALL = 1,       // 房间内所有用户协商
    ZEGO_CAPABILITY_NEGOTIATION_TYPE_PUBLISHER = 2, // 麦上用户协商
};
 
enum ZegoResourceType {
    ZEGO_RESOURCE_TYPE_CDN = 0,
    ZEGO_RESOURCE_TYPE_RTC,
    ZEGO_RESOURCE_TYPE_L3,
};
 
enum ZegoSupportHttpDNS {
    ZEGO_SUPPORT_HTTP_DNS_NONE = 0,
    ZEGO_SUPPORT_HTTP_DNS_WANGSU = 1,
    ZEGO_SUPPORT_HTTP_DNS_TENCENT = 2,
    ZEGO_SUPPORT_HTTP_DNS_ALIYUN = 3,
};
 
enum ZegoGeoFenceType {
    // 不使用
    ZegoGeoFenceTypeNone = 0,
    // 包含列表所有区域
    ZegoGeoFenceTypeInclude = 1,
    // 排除列表所有区域
    ZegoGeoFenceTypeExclude = 2,
};
 
enum ZegoGeoFenceAreaCode {
    // 中国大陆（不包含港澳台）
    ZegoGeoFenceAreaCodeCN = 2,
    // 北美
    ZegoGeoFenceAreaCodeNA = 3,
    // 欧洲，包括英国
    ZegoGeoFenceAreaCodeEU = 4,
    // 亚洲，不包括中国大陆、印度
    ZegoGeoFenceAreaCodeAS = 5,
    // 印度
    ZegoGeoFenceAreaCodeIN = 6,
};
 
struct ZegoView {
    void *view;      
    bool alphaBlend; 
 
    ZegoView() {
        view = nullptr;
        alphaBlend = false;
    }
};
 
enum ZegoAlphaLayoutType {
    ZEGO_ALPHA_LAYOUT_TYPE_NONE = 0,
    ZEGO_ALPHA_LAYOUT_TYPE_LEFT = 1,
    ZEGO_ALPHA_LAYOUT_TYPE_RIGHT = 2,
    ZEGO_ALPHA_LAYOUT_TYPE_BOTTOM = 3,
    ZEGO_ALPHA_LAYOUT_TYPE_RIGHT_TOP = 4
};
 
enum ZegoObjectSegmentationType {
    ZEGO_OBJECT_SEGMENTATION_TYPE_ANY_BACKGROUND = 0,
    ZEGO_OBJECT_SEGMENTATION_TYPE_GREEN_SCREEN_BACKGROUND = 1
};
 
enum ZegoBackgroundProcessType {
    ZEGO_BACKGROUND_PROCESS_TYPE_TRANSPARENT = 0,
 
    ZEGO_BACKGROUND_PROCESS_TYPE_COLOR = 1,
 
    ZEGO_BACKGROUND_PROCESS_TYPE_BLUR = 2,
 
    ZEGO_BACKGROUND_PROCESS_TYPE_IMAGE = 3,
 
    ZEGO_BACKGROUND_PROCESS_TYPE_VIDEO = 4
};
 
enum ZegoBackgroundBlurLevel {
    ZEGO_BACKGROUND_BLUR_LEVEL_LOW = 0,
 
    ZEGO_BACKGROUND_BLUR_LEVEL_MEDIUM = 1,
 
    ZEGO_BACKGROUND_BLUR_LEVEL_HIGH = 2
};
struct ZegoBackgroundConfig {
    ZegoBackgroundProcessType processType;
 
    int color;
 
    const char *imageURL;
 
    const char *videoURL;
 
    ZegoBackgroundBlurLevel blurLevel;
 
    ZegoBackgroundConfig()
        : processType(ZEGO_BACKGROUND_PROCESS_TYPE_TRANSPARENT), color(0), imageURL(NULL),
          videoURL(NULL), blurLevel(ZEGO_BACKGROUND_BLUR_LEVEL_MEDIUM) {}
};
 
struct ZegoObjectSegmentationConfig {
    ZegoObjectSegmentationType objectSegmentationType;
 
    ZegoBackgroundConfig backgroundConfig;
 
    ZegoObjectSegmentationConfig()
        : objectSegmentationType(ZEGO_OBJECT_SEGMENTATION_TYPE_ANY_BACKGROUND) {}
};
 
enum ZegoObjectSegmentationState {
    ZEGO_OBJECT_SEGMENTATION_STATE_OFF = 0,
 
    ZEGO_OBJECT_SEGMENTATION_STATE_ON = 1
};
 
struct ZegoPublishDualStreamConfig {
    VideoStreamLayer layer;
    int encodeWidth;
    int encodeHeight;
    int fps;
    int bitrate;
 
    ZegoPublishDualStreamConfig() {
        layer = VideoStreamLayer_Auto;
        encodeWidth = 0;
        encodeHeight = 0;
        fps = 0;
        bitrate = 0;
    }
};
 
struct ZegoAudioFrameParam {
    int sampleRate;
 
    int channel;
};
 
struct ZegoScreenCaptureConfig {
    bool captureVideo;
 
    bool captureAudio;
 
    unsigned int microphoneVolume;
 
    unsigned int applicationVolume;
 
    struct ZegoAudioFrameParam audioParam;
 
    struct ZegoRect cropRect;
 
    ZegoScreenCaptureConfig()
        : captureVideo(false), captureAudio(false), microphoneVolume(0), applicationVolume(0),
          cropRect(ZegoRect()) {
        audioParam.channel = 2;
        audioParam.sampleRate = 16000;
    }
};
 
enum ZegoDumpDataType {
    ZEGO_DUMP_DATA_TYPE_AUDIO = 0,
};
 
struct ZegoDumpDataConfig {
    ZegoDumpDataType data_type;
 
    ZegoDumpDataConfig() : data_type(ZEGO_DUMP_DATA_TYPE_AUDIO) {}
};
 
struct ZegoColorEnhancementParams {
    float intensity;
 
    float skinToneProtectionLevel;
 
    float lipColorProtectionLevel;
 
    ZegoColorEnhancementParams() {
        intensity = 0;
        skinToneProtectionLevel = 1;
        lipColorProtectionLevel = 0;
    }
};
 
enum ZegoPlayResourceType {
    ZEGO_PLAY_RESOURCE_TYPE_DEFAULT = 0,
    ZEGO_PLAY_RESOURCE_TYPE_CDN = 1,
    ZEGO_PLAY_RESOURCE_TYPE_L3 = 2,
};
 
enum ZegoVideoBackendType {
    ZEGO_VIDEO_BACKEND_TYPE_OPENGL2 = 0,
    ZEGO_VIDEO_BACKEND_TYPE_OPENGL3 = 1,
};
 
enum ZegoVideoDenoiseMode {
    OFF = 0,
    ON = 1,
    AUTO = 2,
};
 
enum ZegoVideoDenoiseStrength {
    LIGHT = 1,
    MEDIUM = 2,
    HEAVY = 3,
};
 
struct ZegoVideoDenoiseParams {
    ZegoVideoDenoiseMode mode;
    ZegoVideoDenoiseStrength strength;
 
    ZegoVideoDenoiseParams() {
        mode = ZegoVideoDenoiseMode::OFF;
        strength = ZegoVideoDenoiseStrength::LIGHT;
    }
};
 
enum ZegoDummyCaptureImageMode {
    ZEGO_DUMMY_CAPTURE_IMAGE_MODE_MANUAL = 0,
 
    ZEGO_DUMMY_CAPTURE_IMAGE_MODE_AUTO = 1,
 
};
 
struct ZegoDummyCaptureImageParams {
    char path[ZEGO_MAX_PATH_LEN];
 
    ZegoDummyCaptureImageMode mode;
 
    ZegoDummyCaptureImageParams() {
        path[0] = '\0';
        mode = ZEGO_DUMMY_CAPTURE_IMAGE_MODE_MANUAL;
    }
};
 
enum ZegoLowlightEnhanceMode {
    ZEGO_LOWLIGHT_ENHANCE_MODE_OFF = 0,
    ZEGO_LOWLIGHT_ENHANCE_MODE_ON = 1,
    ZEGO_LOWLIGHT_ENHANCE_MODE_AUTO = 2
};
 
enum ZegoLowlightEnhanceType {
    ZEGO_LOWLIGHT_ENHANCE_TYPE_NORMAL = 0,
    ZEGO_LOWLIGHT_ENHANCE_TYPE_AI = 1,
};
 
struct ZegoLowlightEnhanceParams {
    ZegoLowlightEnhanceMode mode;
    ZegoLowlightEnhanceType type;
 
    ZegoLowlightEnhanceParams() {
        mode = ZEGO_LOWLIGHT_ENHANCE_MODE_OFF;
        type = ZEGO_LOWLIGHT_ENHANCE_TYPE_NORMAL;
    }
};
 
struct ZegoFacePositionInfo {
    ZegoRect position;
};
 
struct ZegoFaceDetectionInfo {
    int imageWidth;
    int imageHeight;
    int facePositionInfoListSize;
    const ZegoFacePositionInfo *facePositionInfoList;
 
    ZegoFaceDetectionInfo() {
        imageWidth = 0;
        imageHeight = 0;
        facePositionInfoListSize = 0;
        facePositionInfoList = nullptr;
    }
};
 
struct RtcStatsInfo {
    double totalTxBandwidth; 
    int avgTxRtt;            
    int avgTxPacketLossRate; 
    double totalRxBandwidth; 
    int avgRxRtt;            
    int avgRxPacketLossRate; 
    int avgPeerToPeerDelay;  
 
    RtcStatsInfo() {
        totalTxBandwidth = 0.0;
        avgTxRtt = 0;
        avgTxPacketLossRate = 0;
        totalRxBandwidth = 0.0;
        avgRxRtt = 0;
        avgRxPacketLossRate = 0;
        avgPeerToPeerDelay = 0;
    }
};
 
} // namespace AV
} // namespace ZEGO
 
#ifdef __cplusplus
extern "C" {
#endif
struct ZegoStreamExtraPlayInfo;
 
ZEGOAVKIT_API struct ZegoStreamExtraPlayInfo *zego_stream_extra_info_create();
ZEGOAVKIT_API void zego_stream_extra_info_destroy(struct ZegoStreamExtraPlayInfo *info);
 
ZEGOAVKIT_API void zego_stream_extra_info_add_rtmp_url(struct ZegoStreamExtraPlayInfo *info,
                                                       const char *url);
ZEGOAVKIT_API void zego_stream_extra_info_add_rtmp_url_with_param(
    struct ZegoStreamExtraPlayInfo *info, const char *url, ZEGO::AV::ZegoCDNProtocol protocol,
    const char **quic_version_list, const int quic_version_list_count);
ZEGOAVKIT_API void zego_stream_extra_info_add_rtmp_url_with_param_ex(
    struct ZegoStreamExtraPlayInfo *info, const char *url, ZEGO::AV::ZegoCDNProtocol protocol,
    const char **quic_version_list, const int quic_version_list_count,
    ZEGO::AV::ZegoSupportHttpDNS httpdns);
 
ZEGOAVKIT_API void zego_stream_extra_info_add_rtmp_url_with_quic_mode_param_ex(
    struct ZegoStreamExtraPlayInfo *info, const char *url, ZEGO::AV::ZegoCDNProtocol protocol,
    const char **quic_version_list, const int quic_version_list_count,
    ZEGO::AV::ZegoSupportHttpDNS httpdns, int quicConnectMode);
 
ZEGOAVKIT_API void zego_stream_extra_info_add_rtmp_url_with_custom_params(
    struct ZegoStreamExtraPlayInfo *info, const char *url, ZEGO::AV::ZegoCDNProtocol protocol,
    const char **quic_version_list, const int quic_version_list_count,
    ZEGO::AV::ZegoSupportHttpDNS httpdns, int quicConnectMode, const char *custom_params);
 
ZEGOAVKIT_API void zego_stream_extra_info_add_flv_url(struct ZegoStreamExtraPlayInfo *info,
                                                      const char *url);
ZEGOAVKIT_API void zego_stream_extra_info_add_flv_url_with_param(
    struct ZegoStreamExtraPlayInfo *info, const char *url, ZEGO::AV::ZegoCDNProtocol protocol,
    const char **quic_version_list, const int quic_version_list_count);
ZEGOAVKIT_API void zego_stream_extra_info_add_flv_url_with_param_ex(
    struct ZegoStreamExtraPlayInfo *info, const char *url, ZEGO::AV::ZegoCDNProtocol protocol,
    const char **quic_version_list, const int quic_version_list_count,
    ZEGO::AV::ZegoSupportHttpDNS httpdns);
 
ZEGOAVKIT_API void zego_stream_extra_info_add_flv_url_with_quic_mode_param_ex(
    struct ZegoStreamExtraPlayInfo *info, const char *url, ZEGO::AV::ZegoCDNProtocol protocol,
    const char **quic_version_list, const int quic_version_list_count,
    ZEGO::AV::ZegoSupportHttpDNS httpdns, int quicConnectMode);
 
ZEGOAVKIT_API void zego_stream_extra_info_add_flv_url_with_custom_params(
    struct ZegoStreamExtraPlayInfo *info, const char *url, ZEGO::AV::ZegoCDNProtocol protocol,
    const char **quic_version_list, const int quic_version_list_count,
    ZEGO::AV::ZegoSupportHttpDNS httpdns, int quicConnectMode, const char *custom_params);
 
ZEGOAVKIT_API void zego_stream_extra_info_set_params(struct ZegoStreamExtraPlayInfo *info,
                                                     const char *params);
ZEGOAVKIT_API void zego_stream_extra_info_set_decrypt_key(struct ZegoStreamExtraPlayInfo *info,
                                                          const unsigned char *key, int keylen);
ZEGOAVKIT_API void zego_stream_extra_info_set_cross_app_info(struct ZegoStreamExtraPlayInfo *info,
                                                             unsigned int appid,
                                                             const unsigned char *token,
                                                             int tokenlen);
ZEGOAVKIT_API void zego_stream_extra_info_should_switch_server(struct ZegoStreamExtraPlayInfo *info,
                                                               bool should);
ZEGOAVKIT_API void zego_stream_extra_info_set_play_mode(struct ZegoStreamExtraPlayInfo *info,
                                                        ZEGO::AV::ZegoStreamResourceMode mode);
ZEGOAVKIT_API void
zego_stream_extra_info_set_video_codec_id(struct ZegoStreamExtraPlayInfo *info,
                                          ZEGO::AV::ZegoVideoCodecAvc videoCodecID);
ZEGOAVKIT_API void
zego_stream_extra_info_set_source_resource_type(struct ZegoStreamExtraPlayInfo *info,
                                                ZEGO::AV::ZegoResourceType sourceResourceType);
 
ZEGOAVKIT_API void
zego_stream_extra_info_set_codec_template_id(struct ZegoStreamExtraPlayInfo *info,
                                             int codec_template_id);
 
ZEGOAVKIT_API void
zego_stream_extra_info_enable_auto_switch_when_publish(struct ZegoStreamExtraPlayInfo *info,
                                                       bool enable);
 
ZEGOAVKIT_API void zego_stream_extra_info_set_play_resource_type_when_stop_publish(
    struct ZegoStreamExtraPlayInfo *info, ZEGO::AV::ZegoPlayResourceType type);
 
ZEGOAVKIT_API void
zego_stream_extra_info_enable_adaptive_switch(struct ZegoStreamExtraPlayInfo *info, int enable);
 
ZEGOAVKIT_API void
zego_stream_extra_info_add_adaptive_template(struct ZegoStreamExtraPlayInfo *info, int template_id);
 
ZEGOAVKIT_API void zego_stream_extra_info_set_custom_resource_type(
    struct ZegoStreamExtraPlayInfo *info, ZEGO::AV::ZegoResourceType before_publish,
    ZEGO::AV::ZegoResourceType publishing, ZEGO::AV::ZegoResourceType after_publish);
 
#ifdef __cplusplus
} // __cplusplus defined.
#endif
 
#endif /* zego_api_defines_h */