nertc_engine_defines.h

浏览该文件的文档.

 
#ifndef NERTC_ENGINE_DEFINES_H
#define NERTC_ENGINE_DEFINES_H
 
#include <string.h>
#include "nertc_base_types.h"
#define kNERtcMaxPlaneCount 4
#define kNERtcEncryptByteLength 128
#define kNERtcCustomInfoLength 128
#define kNERtcMaxChannelNameLength 64
#define kNERtcMaxTokenLength 256
#define kNERtcMaxDeviceIDLength 256
#define kNERtcMaxDeviceNameLength 256
#define kNERtcMaxURILength 256
#define kNERtcMaxTaskIDLength 64
#define kNERtcMaxBuffLength 1024
#define kNERtcMaxSEIBufferLength 4096
 
#define kDefaultAudioMixProgressInterval 1000
 
#define kMinAudioMixProgressInterval 100
 
#define kMaxAudioMixProgressInterval 10000
 
#define kNERtcExternalVideoDeviceID "nertc-video-external-device"
 
#define kNERtcExternalSubVideoDeviceID "nertc-subvideo-external-device"
 
#define kNERtcAudioDeviceAutoID "nertc-audio-device-auto"
 
namespace nertc {
typedef uint64_t uid_t;
typedef uint64_t channel_id_t;
typedef void* source_id_t;
 
typedef enum {
    kNERtcIIDAudioDeviceManager = 1,
    kNERtcIIDVideoDeviceManager = 2,
} NERtcInterfaceIdType;
 
typedef enum {
    kNERtcClientRoleBroadcaster = 0,
    kNERtcClientRoleAudience = 1,
} NERtcClientRole;
 
typedef enum {
    kNERtcChannelProfileCommunication = 0,
    kNERtcChannelProfileLiveBroadcasting = 1,
    kNERtcChannelProfileVideoCall = 3,
    
    kNERtcChannelProfileHighQualityVideoCall = 4,
    
    kNERtcChannelProfileChatroom = 5,
    
    kNERtcChannelProfileHighQualityChatroom = 6,
    
    kNERtcChannelProfileMeeting = 7,
    
    kNERtcChannelProfileKaraoke = 8,
} NERtcChannelProfileType;
 
typedef enum {
    kNERtcMediaPriorityHigh = 50,
    kNERtcMediaPriorityNormal = 100,
} NERtcMediaPriorityType;
 
typedef enum {
  kNERtcLayoutFloatingRightVertical = 0,
  kNERtcLayoutFloatingLeftVertical,
  kNERtcLayoutSplitScreen,
  kNERtcLayoutSplitScreenScaling,
  kNERtcLayoutCustom,
  kNERtcLayoutAudioOnly,
} NERtcLiveStreamLayoutMode;
 
struct NERtcLiveStreamTaskOption {
    char task_id[kNERtcMaxTaskIDLength];
    char stream_url[kNERtcMaxURILength];
    bool server_record_enabled;
    NERtcLiveStreamLayoutMode layout_mode;
    uid_t main_picture_account_id;
    char layout_parameters[kNERtcMaxBuffLength];
 
    NERtcLiveStreamTaskOption()
        : server_record_enabled(false), layout_mode(kNERtcLayoutFloatingRightVertical), main_picture_account_id(0) {
        memset(task_id, 0, sizeof(task_id));
        memset(stream_url, 0, sizeof(stream_url));
        memset(layout_parameters, 0, sizeof(layout_parameters));
    }
};
 
typedef enum {
    kNERtcLsModeVideo = 0,
    kNERtcLsModeAudio = 1,
} NERtcLiveStreamMode;
 
typedef enum {
    kNERtcLsModeVideoScaleFit = 0,
    kNERtcLsModeVideoScaleCropFill = 1,
} NERtcLiveStreamVideoScaleMode;
 
struct NERtcLiveStreamUserTranscoding {
    uid_t uid;
    bool video_push;
    NERtcLiveStreamVideoScaleMode adaption;
    int x;
    int y;
    int width;
    int height;
    bool audio_push;
    int z_order;
 
    NERtcLiveStreamUserTranscoding()
        : uid(0)
        , video_push(true)
        , adaption(kNERtcLsModeVideoScaleFit)
        , x(0)
        , y(0)
        , width(0)
        , height(0)
        , audio_push(true)
        , z_order(0) {}
};
 
struct NERtcLiveStreamImageInfo {
    char url[kNERtcMaxURILength];
    int x;
    int y;
    int width;
    int height;
 
    int z_order;
 
    NERtcLiveStreamImageInfo() : x(0), y(0), width(0), height(0), z_order(0) { memset(url, 0, sizeof(url)); }
};
 
struct NERtcLiveStreamLayout {
    int width;
    int height;
    unsigned int background_color;
    unsigned int user_count;
    NERtcLiveStreamUserTranscoding* users;
    NERtcLiveStreamImageInfo* bg_image;
 
    int bg_image_count;
 
    NERtcLiveStreamLayout()
        : width(0), height(0), background_color(0), user_count(0), users(NULL), bg_image(NULL), bg_image_count(1) {}
};
 
typedef enum {
    kNERtcLiveStreamAudioSampleRate32000 = 32000,
    kNERtcLiveStreamAudioSampleRate44100 = 44100,
    kNERtcLiveStreamAudioSampleRate48000 = 48000,
} NERtcLiveStreamAudioSampleRate;
 
typedef enum {
    kNERtcLiveStreamAudioCodecProfileLCAAC = 0,
    kNERtcLiveStreamAudioCodecProfileHEAAC = 1,
} NERtcLiveStreamAudioCodecProfile;
 
struct NERtcLiveConfig {
    bool single_video_passthrough;
    int audio_bitrate;
 
    NERtcLiveStreamAudioSampleRate sampleRate;
 
    int channels;
 
    NERtcLiveStreamAudioCodecProfile audioCodecProfile;
 
    bool interrupted_place_image;
 
    NERtcLiveConfig()
        : single_video_passthrough(false)
        , audio_bitrate(0)
        , sampleRate(kNERtcLiveStreamAudioSampleRate48000)
        , channels(2)
        , audioCodecProfile(kNERtcLiveStreamAudioCodecProfileLCAAC)
        , interrupted_place_image(false) {}
};
 
struct NERtcLiveStreamTaskInfo {
    char task_id[kNERtcMaxTaskIDLength];
    char stream_url[kNERtcMaxURILength];
    bool server_record_enabled;
    NERtcLiveStreamMode ls_mode;
    NERtcLiveStreamLayout layout;
    NERtcLiveConfig config;
    char extraInfo[kNERtcMaxSEIBufferLength];
 
    NERtcLiveStreamTaskInfo() : server_record_enabled(false), ls_mode(kNERtcLsModeVideo) {
        memset(task_id, 0, sizeof(task_id));
        memset(stream_url, 0, sizeof(stream_url));
        memset(extraInfo, 0, sizeof(extraInfo));
    }
};
 
typedef enum {
    kNERtcLsStatePushing = 505,
    kNERtcLsStatePushFail = 506,
    kNERtcLsStatePushStopped = 511,
    kNERtcLsStateImageError = 512,
} NERtcLiveStreamStateCode;
 
typedef enum {
    kNERtcOSiOS = 1,
    kNERtcOSAndroid = 2,
    kNERtcOSPC = 3,
    kNERtcOSWebRTC = 4,
} NERtcOSCategory;
 
typedef enum {
    kNERtcAudioProfileDefault = 0,
    kNERtcAudioProfileStandard = 1,
    kNERtcAudioProfileStandardExtend = 2,
    kNERtcAudioProfileMiddleQuality = 3,
    kNERtcAudioProfileMiddleQualityStereo = 4,
    kNERtcAudioProfileHighQuality = 5,
    kNERtcAudioProfileHighQualityStereo = 6,
} NERtcAudioProfileType;
 
typedef enum {
    kNERtcAudioScenarioDefault = 0,
    kNERtcAudioScenarioSpeech = 1,
    kNERtcAudioScenarioMusic = 2,
} NERtcAudioScenarioType;
 
typedef enum {
    kNERtcVoiceChangerOff = 0,
    kNERtcVoiceChangerRobot = 1,
    kNERtcVoiceChangerGaint = 2,
    kNERtcVoiceChangerHorror = 3,
    kNERtcVoiceChangerMature = 4,
    kNERtcVoiceChangerManToWoman = 5,
    kNERtcVoiceChangerWomanToMan = 6,
    kNERtcVoiceChangerManToLoli = 7,
    kNERtcVoiceChangerWomanToLoli = 8,
} NERtcVoiceChangerType;
 
typedef enum {
    kNERtcVoiceBeautifierOff = 0,
    kNERtcVoiceBeautifierMuffled = 1,
    kNERtcVoiceBeautifierMellow = 2,
    kNERtcVoiceBeautifierClear = 3,
    kNERtcVoiceBeautifierMagnetic = 4,
    kNERtcVoiceBeautifierRecordingstudio = 5,
    kNERtcVoiceBeautifierNature = 6,
    kNERtcVoiceBeautifierKTV = 7,
    kNERtcVoiceBeautifierRemote = 8,
    kNERtcVoiceBeautifierChurch = 9,
    kNERtcVoiceBeautifierBedroom = 10,
    kNERtcVoiceBeautifierLive = 11,
} NERtcVoiceBeautifierType;
 
typedef enum {
    kNERtcVoiceEqualizationBand_31 = 0,
    kNERtcVoiceEqualizationBand_62 = 1,
    kNERtcVoiceEqualizationBand_125 = 2,
    kNERtcVoiceEqualizationBand_250 = 3,
    kNERtcVoiceEqualizationBand_500 = 4,
    kNERtcVoiceEqualizationBand_1K = 5,
    kNERtcVoiceEqualizationBand_2K = 6,
    kNERtcVoiceEqualizationBand_4K = 7,
    kNERtcVoiceEqualizationBand_8K = 8,
    kNERtcVoiceEqualizationBand_16K = 9,
} NERtcVoiceEqualizationBand;
 
struct NERtcCameraCaptureConfig {
    int captureWidth;
    int captureHeight;
 
    NERtcCameraCaptureConfig() : captureWidth(0), captureHeight(0) {}
};
 
typedef enum {
    kNERtcVideoProfileLowest = 0,
    kNERtcVideoProfileLow = 1,
    kNERtcVideoProfileStandard = 2,
    kNERtcVideoProfileHD720P = 3,
    kNERtcVideoProfileHD1080P = 4,
    kNERtcVideoProfileNone = 5,
    kNERtcVideoProfileMAX = kNERtcVideoProfileHD1080P,
} NERtcVideoProfileType;
 
typedef enum {
    kNERtcRemoteVideoStreamTypeHigh = 0,
    kNERtcRemoteVideoStreamTypeLow = 1,
    kNERtcRemoteVideoStreamTypeMid = 2,
    kNERtcRemoteVideoStreamTypeNone = 3,
} NERtcRemoteVideoStreamType;
 
typedef enum {
    kNERtcAudioDeviceUnknown = 0,
    kNERtcAudioDeviceRecord,
    kNERtcAudioDevicePlayout,
} NERtcAudioDeviceType;
 
typedef enum {
    kNERtcAudioDeviceActive = 0,
    kNERtcAudioDeviceUnactive,
    kNERtcAudioDeviceSelectChanged = 100,
} NERtcAudioDeviceState;
 
typedef enum {
    kNERtcAudioDeviceTransportTypeUnknown = 0,
    kNERtcAudioDeviceTransportTypeBluetooth = 1,
    kNERtcAudioDeviceTransportTypeBluetoothA2DP = 2,
    kNERtcAudioDeviceTransportTypeBluetoothLE = 3,
    kNERtcAudioDeviceTransportTypeUSB = 4,
    kNERtcAudioDeviceTransportTypeHDMI = 5,
    kNERtcAudioDeviceTransportTypeBuiltIn = 6,
    kNERtcAudioDeviceTransportTypeThunderbolt = 7,
    kNERtcAudioDeviceTransportTypeAirPlay = 8,
    kNERtcAudioDeviceTransportTypeVirtual = 9,
    kNERtcAudioDeviceTransportTypeOther = 10,
} NERtcAudioDeviceTransportType;
 
typedef enum {
    kNERtcVideoDeviceTransportTypeUnknown = 0,
    kNERtcVideoDeviceTransportTypeUSB = 1,
    kNERtcVideoDeviceTransportTypeVirtual = 2,
    kNERtcVideoDeviceTransportTypeOther = 3,
} NERtcVideoDeviceTransportType;
 
struct NERtcDeviceInfo {
    char device_id[kNERtcMaxDeviceIDLength];
    char device_name[kNERtcMaxDeviceNameLength];
    int transport_type;
    bool suspected_unavailable;
    bool system_default_device;
    bool select_priority_device;
    NERtcDeviceInfo()
        : transport_type(0), suspected_unavailable(false), system_default_device(false), select_priority_device(false) {
      memset(device_id, 0, kNERtcMaxDeviceIDLength);
      memset(device_name, 0, kNERtcMaxDeviceNameLength);
    }
};
 
typedef enum {
    kNERtcVideoDeviceUnknown = 0,
    kNERtcVideoDeviceCapture,
} NERtcVideoDeviceType;
 
typedef enum {
    kNERtcVideoDeviceAdded = 0,
    kNERtcVideoDeviceRemoved,
} NERtcVideoDeviceState;
 
typedef enum {
    kNERtcVideoScaleFit = 0,
    kNERtcVideoScaleFullFill = 1,
    kNERtcVideoScaleCropFill = 2,
} NERtcVideoScalingMode;
 
typedef enum {
    kNERtcVideoMirrorModeAuto = 0,
    kNERtcVideoMirrorModeEnabled = 1,
    kNERtcVideoMirrorModeDisabled = 2,
} NERtcVideoMirrorMode;
 
typedef enum {
 
    kNERtcVideoOutputOrientationModeAdaptative = 0,
 
    kNERtcVideoOutputOrientationModeFixedLandscape = 1,
 
    kNERtcVideoOutputOrientationModeFixedPortrait = 2,
 
} NERtcVideoOutputOrientationMode;
typedef enum {
    kNERtcConnectionStateDisconnected = 1,
    kNERtcConnectionStateConnecting = 2,
    kNERtcConnectionStateConnected = 3,
    kNERtcConnectionStateReconnecting = 4,
    kNERtcConnectionStateFailed = 5,
} NERtcConnectionStateType;
 
typedef enum {
    kNERtcReasonConnectionChangedLeaveChannel = 1,
    kNERtcReasonConnectionChangedChannelClosed = 2,
    kNERtcReasonConnectionChangedBeKicked = 3,
    kNERtcReasonConnectionChangedTimeOut = 4,
    kNERtcReasonConnectionChangedJoinChannel = 5,
    kNERtcReasonConnectionChangedJoinSucceed = 6,
    kNERtcReasonConnectionChangedReJoinSucceed = 7,
    kNERtcReasonConnectionChangedMediaConnectionDisconnected = 8,
    kNERtcReasonConnectionChangedSignalDisconnected = 9,
    kNERtcReasonConnectionChangedRequestChannelFailed = 10,
    kNERtcReasonConnectionChangedJoinChannelFailed = 11,
    kNERtcReasonConnectionChangedReDispatch = 12,
    kNERtcReasonConnectionChangedSettingProxyServer = 13
 
} NERtcReasonConnectionChangedType;
 
typedef enum {
    kNERtcNetworkConnectionTypeNone = 0,
    kNERtcNetworkConnectionTypeUnknown = 1,
    kNERtcNetworkConnectionType2G = 2,
    kNERtcNetworkConnectionType3G = 3,
    kNERtcNetworkConnectionType4G = 4,
    kNERtcNetworkConnectionType5G = 5,
    kNERtcNetworkConnectionTypeWiFi = 6,
    kNERtcNetworkConnectionTypeWWAN = 7,
    
    kNERtcNetworkConnectionTypeEthernet = 8,
 
} NERtcNetworkConnectionType;
 
 
struct NERtcAudioVolumeInfo {
    uid_t uid;
    unsigned int volume;
    
    unsigned int sub_stream_volume;
};
 
struct NERtcStats {
    uint32_t cpu_app_usage;
    uint32_t cpu_idle_usage;
    uint32_t cpu_total_usage;
    uint32_t memory_app_usage;
    uint32_t memory_total_usage;
    uint32_t memory_app_kbytes;
    int total_duration;
    uint64_t tx_bytes;
    uint64_t rx_bytes;
    uint64_t tx_audio_bytes;
    uint64_t tx_video_bytes;
    uint64_t rx_audio_bytes;
    uint64_t rx_video_bytes;
    int tx_audio_kbitrate;
    int rx_audio_kbitrate;
    int tx_video_kbitrate;
    int rx_video_kbitrate;
    int up_rtt;
    int down_rtt;
    int tx_audio_packet_loss_rate;
    int tx_video_packet_loss_rate;
    int tx_audio_packet_loss_sum;
    int tx_video_packet_loss_sum;
    int tx_audio_jitter;
    int tx_video_jitter;
    int rx_audio_packet_loss_rate;
    int rx_video_packet_loss_rate;
    int rx_audio_packet_loss_sum;
    int rx_video_packet_loss_sum;
    int rx_audio_jitter;
    int rx_video_jitter;
};
 
struct NERtcVideoLayerSendStats {
    int layer_type;
    int width;
    int height;
    int capture_width;
    int capture_height;
    int capture_frame_rate;
    int render_frame_rate;
    int encoder_frame_rate;
    int sent_frame_rate;
    int sent_bitrate;
    int target_bitrate;
    int encoder_bitrate;
    char codec_name[kNERtcMaxDeviceNameLength];
    bool drop_bandwidth_strategy_enabled;
 
    NERtcVideoLayerSendStats() {
        memset(this, 0, sizeof(NERtcVideoLayerSendStats));
    }
};
struct NERtcVideoSendStats {
    NERtcVideoLayerSendStats* video_layers_list;
    int video_layers_count;
};
 
struct NERtcVideoLayerRecvStats {
    int layer_type;
    int width;
    int height;
    int received_bitrate;
    int received_frame_rate;
    int decoder_frame_rate;
    int render_frame_rate;
    int packet_loss_rate;
    int total_frozen_time;
    int frozen_rate;
    char codec_name[kNERtcMaxDeviceNameLength];
    int peer_to_peer_delay;
 
    NERtcVideoLayerRecvStats() {
        memset(this, 0, sizeof(*this));
    }
};
 
struct NERtcVideoRecvStats {
    uid_t uid;
    NERtcVideoLayerRecvStats* video_layers_list;
    int video_layers_count;
};
 
typedef enum {
    kNERtcAudioStreamTypeMain = 0,
 
    kNERtcAudioStreamTypeSub = 1,
} NERtcAudioStreamType;
 
struct NERtcAudioLayerSendStats {
    NERtcAudioStreamType stream_type;
    int num_channels;
    int sent_sample_rate;
    int sent_bitrate;
    int audio_loss_rate;
    int64_t rtt;
    unsigned int volume;
    unsigned int cap_volume;
};
 
struct NERtcAudioSendStats {
    NERtcAudioLayerSendStats* audio_layers_list;
    int audio_layers_count;
};
struct NERtcAudioLayerRecvStats {
    NERtcAudioStreamType stream_type;
    int received_bitrate;
    int total_frozen_time;
    int frozen_rate;
    int audio_loss_rate;
    unsigned int volume;
    int av_timestamp_diff;
    int peer_to_peer_delay;
};
struct NERtcAudioRecvStats {
    uid_t uid;
    NERtcAudioLayerRecvStats* audio_layers_list;
    int audio_layers_count;
};
 
typedef enum {
    kNERtcNetworkQualityUnknown = 0,
    kNERtcNetworkQualityExcellent = 1,
    kNERtcNetworkQualityGood = 2,
    kNERtcNetworkQualityPoor = 3,
    kNERtcNetworkQualityBad = 4,
    kNERtcNetworkQualityVeryBad = 5,
    kNERtcNetworkQualityDown = 6,
} NERtcNetworkQualityType;
 
struct NERtcNetworkQualityInfo {
    uid_t uid;
    NERtcNetworkQualityType tx_quality;
    NERtcNetworkQualityType rx_quality;
};
 
typedef enum {
    kNERtcVideoCropModeDefault = 0,
    kNERtcVideoCropMode16x9 = 1,
    kNERtcVideoCropMode4x3 = 2,
    kNERtcVideoCropMode1x1 = 3,
} NERtcVideoCropMode;
 
typedef enum {
    kNERtcVideoFramerateFpsDefault = 0,
    kNERtcVideoFramerateFps_7 = 7,
    kNERtcVideoFramerateFps_10 = 10,
    kNERtcVideoFramerateFps_15 = 15,
    kNERtcVideoFramerateFps_24 = 24,
    kNERtcVideoFramerateFps_30 = 30,
    kNERtcVideoFramerateFps_60 = 60,
} NERtcVideoFramerateType;
 
typedef enum {
    kNERtcDegradationDefault = 0,
    kNERtcDegradationMaintainFramerate = 1,
    kNERtcDegradationMaintainQuality = 2,
    kNERtcDegradationBalanced = 3,
} NERtcDegradationPreference;
 
struct NERtcVideoConfig {
    NERtcVideoProfileType max_profile;
    uint32_t width;
    uint32_t height;
    NERtcVideoCropMode crop_mode_;
    NERtcVideoFramerateType framerate;
    NERtcVideoFramerateType min_framerate;
    uint32_t bitrate;
    uint32_t min_bitrate;
    NERtcDegradationPreference degradation_preference;
    NERtcVideoMirrorMode mirror_mode;
    NERtcVideoOutputOrientationMode orientation_mode;
 
    NERtcVideoConfig()
        : max_profile(kNERtcVideoProfileHD720P)
        , width(0)
        , height(0)
        , crop_mode_(kNERtcVideoCropModeDefault)
        , framerate(kNERtcVideoFramerateFpsDefault)
        , min_framerate(kNERtcVideoFramerateFpsDefault)
        , bitrate(0)
        , min_bitrate(0)
        , degradation_preference(kNERtcDegradationDefault)
        , mirror_mode(kNERtcVideoMirrorModeAuto)
        , orientation_mode(kNERtcVideoOutputOrientationModeAdaptative) {}
};
 
typedef void (*onFrameDataCallback)(uid_t uid, void* data, uint32_t type, uint32_t width, uint32_t height,
                                    uint32_t count, uint32_t offset[4], uint32_t stride[4], uint32_t rotation,
                                    void* user_data);
 
typedef enum {
    kNERtcScreenProfile480P = 0,
    kNERtcScreenProfileHD720P = 1,
    kNERtcScreenProfileHD1080P = 2,
    kNERtcScreenProfileCustom = 3,
    kNERtcScreenProfileNone = 4,
    kNERtcScreenProfileMAX = kNERtcScreenProfileHD1080P,
} NERtcScreenProfileType;
 
typedef enum {
    kScreenCaptureStatusStart = 1,
 
    kScreenCaptureStatusPause = 2,
 
    kScreenCaptureStatusResume = 3,
 
    kScreenCaptureStatusStop = 4,
 
    kScreenCaptureStatusCovered = 5,
 
    kScreenCaptureStatusAbort = 6
} NERtcScreenCaptureStatus;
 
struct NERtcRectangle {
    int x;
    int y;
    int width;
    int height;
 
    NERtcRectangle() : x(0), y(0), width(0), height(0) {}
    NERtcRectangle(int xx, int yy, int ww, int hh) : x(xx), y(yy), width(ww), height(hh) {}
};
 
typedef enum {
  kUnknown = -1,
  kWindow = 0,
  kScreen = 1,
  kCustom = 2,
} NERtcScreenCaptureSourceType;
 
typedef enum {
  kSetPos = 0,
  kSetAbove = 1,
  kSetBelow = 2,
  kHide = 3,
  kShow = 4,
} NERtcScreenCaptureCustomHLBorderAction;
 
struct NERtcScreenCaptureSourceData {
  NERtcScreenCaptureSourceType type;
 
  source_id_t source_id;
 
  NERtcScreenCaptureStatus status;
 
  NERtcScreenCaptureCustomHLBorderAction action;
 
  NERtcRectangle capture_rect;
 
  int level;
 
  NERtcScreenCaptureSourceData()
    : type(kUnknown)
    , source_id(0)
    , status(kScreenCaptureStatusStart)
    , action(kSetPos)
    , level(0) {}
};
 
struct NERtcVideoDimensions {
    int width;
    int height;
 
    NERtcVideoDimensions() : width(0), height(0) {}
    NERtcVideoDimensions(int ww, int hh) : width(ww), height(hh) {}
};
 
typedef NERtcVideoDimensions NERtcDimensions;
 
typedef enum {
    kNERtcSubStreamContentPreferMotion = 0,
    kNERtcSubStreamContentPreferDetails = 1, 
} NERtcSubStreamContentPrefer;
 
struct NERtcScreenCaptureParameters {
    NERtcScreenProfileType profile;
    NERtcVideoDimensions dimensions;
    int frame_rate;
    int min_framerate;
    int bitrate;
    int min_bitrate;
    bool capture_mouse_cursor;
    bool window_focus;
    source_id_t* excluded_window_list;
    int excluded_window_count;
    NERtcSubStreamContentPrefer prefer;
 
    NERtcDegradationPreference degradation_preference;
 
    bool enable_high_performance;
 
    bool enable_high_light;
 
    int high_light_width;
 
    unsigned int high_light_color;
 
    int high_light_length;
 
    bool exclude_highlight_box;
  
    bool force_update_data;
 
    NERtcScreenCaptureParameters()
        : profile(kNERtcScreenProfileHD1080P)
        , frame_rate(5)
        , min_framerate(0)
        , bitrate(0)
        , min_bitrate(0)
        , capture_mouse_cursor(true)
        , window_focus(true)
        , excluded_window_list(NULL)
        , excluded_window_count(0)
        , prefer(kNERtcSubStreamContentPreferMotion)
        , degradation_preference(kNERtcDegradationMaintainQuality)
        , enable_high_performance(true)
        , enable_high_light(true)
        , high_light_width(6)
        , high_light_color(0xFF7EDE00)
        , high_light_length(120)
        , exclude_highlight_box(true)
        , force_update_data(false) {}
};
 
struct NERtcVideoCanvas {
    onFrameDataCallback cb;
    void* user_data;
    void* window;
    NERtcVideoScalingMode scaling_mode;
 
    NERtcVideoMirrorMode mirror_mode;
 
    uint32_t background_color;
 
    NERtcVideoCanvas()
        : user_data(NULL)
        , window(NULL)
        , cb(NULL)
        , scaling_mode(kNERtcVideoScaleFit)
        , mirror_mode(kNERtcVideoMirrorModeDisabled)
        , background_color(0) {}
};
 
typedef enum {
    kNERtcRecordTypeAll = 0,
    kNERtcRecordTypeMix = 1,
    kNERtcRecordTypeSingle = 2,
 
} NERtcRecordType;
 
typedef enum {
    kNERtcAudioTypePCM16 = 0,
} NERtcAudioType;
 
typedef enum {
    kNERtcRawAudioFrameOpModeReadOnly = 0,
    kNERtcRawAudioFrameOpModeReadWrite,
} NERtcRawAudioFrameOpModeType;
 
struct NERtcAudioFrameRequestFormat {
    uint32_t channels;
    uint32_t sample_rate;
    NERtcRawAudioFrameOpModeType mode;
 
    NERtcAudioFrameRequestFormat() : channels(0), sample_rate(0), mode(kNERtcRawAudioFrameOpModeReadWrite) {}
};
 
struct NERtcAudioFormat {
    NERtcAudioType type;
    uint32_t channels;
    uint32_t sample_rate;
    uint32_t bytes_per_sample;
    uint32_t samples_per_channel;
 
    NERtcAudioFormat()
        : type(kNERtcAudioTypePCM16), channels(1), sample_rate(48000), bytes_per_sample(2), samples_per_channel(480) {}
};
 
struct NERtcAudioFrame {
    NERtcAudioFormat format;
    void* data;
    int64_t sync_timestamp;
 
    NERtcAudioFrame() : data(NULL), sync_timestamp(-1) {}
};
 
typedef enum {
    kNERtcAudioPayloadTypeOPUS = 111,
} NERtcAudioPayloadType;
 
struct NERtcAudioEncodedFrame {
    unsigned char* data;
    int64_t timestamp_us;
    int sample_rate;
    int channels;
    int samples_per_channel;
    int encoded_len;
    int encoded_timestamp;
    NERtcAudioPayloadType payload_type;
 
    uint8_t rms_level;
    NERtcAudioEncodedFrame()
        : data(nullptr)
        , timestamp_us(0)
        , sample_rate(0)
        , channels(0)
        , samples_per_channel(0)
        , encoded_len(0)
        , encoded_timestamp(0)
        , payload_type(kNERtcAudioPayloadTypeOPUS)
        , rms_level(100) {}
};
 
class INERtcAudioFrameObserver {
public:
    virtual ~INERtcAudioFrameObserver() {}
    virtual void onAudioFrameDidRecord(NERtcAudioFrame* frame) = 0;
 
    virtual void onSubStreamAudioFrameDidRecord(NERtcAudioFrame* frame) = 0;
  
    virtual void onAudioFrameWillPlayback(NERtcAudioFrame* frame) = 0;
    virtual void onMixedAudioFrame(NERtcAudioFrame* frame) = 0;
    virtual void onPlaybackAudioFrameBeforeMixing(uint64_t userID, NERtcAudioFrame* frame) = 0;
 
    virtual void onPlaybackAudioFrameBeforeMixing(uint64_t userID, NERtcAudioFrame* frame, channel_id_t cid) = 0;
 
    virtual void onPlaybackSubStreamAudioFrameBeforeMixing(uint64_t userID, NERtcAudioFrame* frame,
                                                           channel_id_t cid) = 0;
};
 
typedef enum {
    kNERtcVideoTypeI420 = 0,
    kNERtcVideoTypeNV12 = 1,
    kNERtcVideoTypeNV21 = 2,
    kNERtcVideoTypeBGRA = 3,
    kNERtcVideoTypeARGB = 4,
    kNERtcVideoTypeCVPixelBuffer = 5,
    kNERtcVideoTypeRGBA = 6,
} NERtcVideoType;
 
typedef enum {
    kNERtcVideoRotation_0 = 0,
    kNERtcVideoRotation_90 = 90,
    kNERtcVideoRotation_180 = 180,
    kNERtcVideoRotation_270 = 270,
} NERtcVideoRotation;
 
struct NERtcVideoFrame {
    NERtcVideoType format;
    uint64_t timestamp;
    uint32_t width;
    uint32_t height;
    NERtcVideoRotation rotation;
    void* buffer;
 
    NERtcVideoFrame()
        : format(kNERtcVideoTypeI420)
        , timestamp(0)
        , width(0)
        , height(0)
        , rotation(kNERtcVideoRotation_0)
        , buffer(NULL) {}
};
 
typedef enum {
    kNERtcVideoCodecTypeH264 = 3,
} NERtcVideoCodecType;
 
typedef enum {
    kNERtcNalFrameTypeIDR = 1,
    kNERtcNalFrameTypeI = 2,
    kNERtcNalFrameTypeP = 3,
} NERtcNalFrameType;
 
struct NERtcVideoEncodedFrame {
    NERtcVideoCodecType codec_type;
    NERtcNalFrameType frame_type;
    int nal_count;
    int* nal_length;
    unsigned char* nal_data;
    int64_t timestamp_us;
    int width;
    int height;
};
 
typedef enum {
    kNERtcSessionLeaveNormal = 0,
    kNERtcSessionLeaveForFailOver = 1,
    kNERtcSessionLeaveUpdate = 2,
    kNERtcSessionLeaveForKick = 3,
    kNERtcSessionLeaveTimeOut = 4,
} NERtcSessionLeaveReason;
 
typedef enum {
    kNERtcAudioMixingStateFinished = 0,
    kNERtcAudioMixingStateFailed = 1,
} NERtcAudioMixingState;
 
struct NERtcCreateAudioMixingOption {
    char path[kNERtcMaxURILength];
    int loop_count;
    bool send_enabled;
    uint32_t send_volume;
    bool playback_enabled;
    uint32_t playback_volume;
 
    uint64_t start_timestamp;
 
    NERtcAudioStreamType send_with_audio_type;
 
    uint32_t progress_interval;
 
    NERtcCreateAudioMixingOption()
        : loop_count(1)
        , send_enabled(true)
        , send_volume(100)
        , playback_enabled(true)
        , playback_volume(100)
        , start_timestamp(0)
        , send_with_audio_type(kNERtcAudioStreamTypeMain)
        , progress_interval(kDefaultAudioMixProgressInterval) {
        memset(path, 0, sizeof(path));
    }
};
 
struct NERtcCreateAudioEffectOption {
    char path[kNERtcMaxURILength];
    int loop_count;
    bool send_enabled;
    uint32_t send_volume;
    bool playback_enabled;
    uint32_t playback_volume;
 
    NERtcAudioStreamType send_with_audio_type;
 
    uint64_t start_timestamp;
 
    uint32_t progress_interval;
 
    NERtcCreateAudioEffectOption()
        : loop_count(1)
        , send_enabled(true)
        , send_volume(100)
        , playback_enabled(true)
        , playback_volume(100)
        , send_with_audio_type(kNERtcAudioStreamTypeMain)
        , start_timestamp(0)
        , progress_interval(kDefaultAudioMixProgressInterval) {
        memset(path, 0, sizeof(path));
    }
};
 
typedef enum {
    kNERTCVideoStreamMain = 0,
    kNERTCVideoStreamSub = 1,
    kNERTCVideoStreamThird = 2,
    kNERTCVideoStreamFourth = 3,
    
} NERtcVideoStreamType;
 
typedef enum {
    kNERtcVideoStreamLayerCountOne = 1,
    kNERtcVideoStreamLayerCountTwo = 2,
    kNERtcVideoStreamLayerCountThree = 3,
} NERtcVideoStreamLayerCount;
 
typedef enum {
  kNERTCVirtualBackground = 0,
 
 
} NERtcFeatureType;
 
typedef enum {
  kNERTCFeatureSupportFull = 0,
  
  kNERTCFeatureSupportHardwareLimit = 1,
  
  kNERTCFeatureSupportPerformanceLimit = 2
} NERTCFeatureSupportType;
 
typedef enum {
    kNERtcChannelMediaRelayStateIdle = 0,
    kNERtcChannelMediaRelayStateConnecting = 1,
    kNERtcChannelMediaRelayStateRunning = 2,
    kNERtcChannelMediaRelayStateFailure = 3,
} NERtcChannelMediaRelayState;
 
typedef enum {
    kNERtcChannelMediaRelayEventDisconnect = 0,
    kNERtcChannelMediaRelayEventConnecting = 1,
    kNERtcChannelMediaRelayEventConnected = 2,
    kNERtcChannelMediaRelayEventVideoSentToDestChannelSuccess = 3,
    kNERtcChannelMediaRelayEventAudioSentToDestChannelSuccess = 4,
    kNERtcChannelMediaRelayEventOtherStreamSentToDestChannelSuccess = 5,
    kNERtcChannelMediaRelayEventFailure = 100,
} NERtcChannelMediaRelayEvent;
 
struct NERtcChannelMediaRelayInfo {
    char channel_name[kNERtcMaxChannelNameLength];
    char channel_token[kNERtcMaxTokenLength];
    uid_t uid;
 
    NERtcChannelMediaRelayInfo() : uid(0) {
        memset(channel_name, 0, sizeof(channel_name));
        memset(channel_token, 0, sizeof(channel_token));
    }
};
 
struct NERtcChannelMediaRelayConfiguration {
    NERtcChannelMediaRelayInfo* src_infos;
    NERtcChannelMediaRelayInfo* dest_infos;
    int dest_count;
 
    NERtcChannelMediaRelayConfiguration() : src_infos(NULL), dest_infos(NULL), dest_count(0) {}
};
 
enum NERtcLocalVideoWatermarkState {
    kNERtcLocalWatermarkStateSetSuccess,
    kNERtcLocalWatermarkStateDeviceNotSupported,
    kNERtcLocalWatermarkStateImgFormatNotSupported,
    kNERtcLocalWatermarkStateImgNumError,
    kNERtcLocalWatermarkStateImgSizeError,
    kNERtcLocalWatermarkStateFPSError,
    kNERtcLocalWatermarkStateFontError,
    kNERtcLocalWatermarkStateWmAlphaError,
    kNERtcLocalWatermarkStateTextContentEmptyError,
    kNERtcLocalWatermarkStateCancel = 20
};
 
 
struct NERtcVideoWatermarkImageConfig {
  char image_paths[10][kNERtcMaxURILength];
 
  float wm_alpha;
 
  int wm_width;
 
  int wm_height;
 
  int offset_x;
 
  int offset_y;
  unsigned int fps;
  bool loop;
 
  NERtcVideoWatermarkImageConfig() : wm_alpha(1.0f), wm_width(0), wm_height(0), offset_x(0), offset_y(0), fps(0), loop(true) {
    memset(image_paths, 0, sizeof(image_paths));
  }
};
 
 
 
 
struct NERtcVideoWatermarkTextConfig {
  char content[kNERtcMaxBuffLength];
  char font_name[kNERtcMaxURILength];
  int font_color;
  int font_size;
  int wm_color;
  float wm_alpha;
  int wm_width;
  int wm_height;
  int offset_x;
  int offset_y;
 
  NERtcVideoWatermarkTextConfig()
      : font_color(0xFFFFFFFF),
        font_size(15),
        wm_color(0x88888888),
        wm_alpha(1.0f),
        wm_width(0),
        wm_height(0),
        offset_x(0),
        offset_y(0) {
    memset(content, 0, sizeof(content));
    memset(font_name, 0, sizeof(font_name));
  }
};
 
struct NERtcVideoWatermarkTimestampConfig {
  char font_name[kNERtcMaxURILength];
  int font_color;
  int font_size;
  int wm_color;
  float wm_alpha;
  int wm_width;
  int wm_height;
  int offset_x;
  int offset_y;
 
  NERtcVideoWatermarkTimestampConfig()
      : font_color(0xFFFFFFFF),
        font_size(15),
        wm_color(0x88888888),
        wm_alpha(1.0f),
        wm_width(0),
        wm_height(0),
        offset_x(0),
        offset_y(0) {
    memset(font_name, 0, sizeof(font_name));
  }
};
 
struct NERtcVideoWatermarkConfig {
    enum NERtcWatermarkType {
        kNERtcWatermarkTypeImage = 0,
        kNERtcWatermarkTypeText,
        kNERtcWatermarkTypeTimestamp
    };
 
    NERtcWatermarkType watermark_type;
 
    NERtcVideoWatermarkImageConfig image_watermarks;
    NERtcVideoWatermarkTextConfig text_watermarks;
    NERtcVideoWatermarkTimestampConfig timestamp_watermark;
 
    NERtcVideoWatermarkConfig() : watermark_type(kNERtcWatermarkTypeImage) {}
};
 
 
 
 
class NERtcTakeSnapshotCallback {
public:
    virtual ~NERtcTakeSnapshotCallback() {}
    virtual void onTakeSnapshotResult(int errorCode, const char* image) = 0;
};
 
typedef enum {
    kNERtcLogLevelFatal = 0,
    kNERtcLogLevelError = 1,
    kNERtcLogLevelWarning = 2,
    kNERtcLogLevelInfo = 3,
    kNERtcLogLevelDetailInfo = 4,
    kNERtcLogLevelVerbos = 5,
    kNERtcLogLevelDebug = 6,
    kNERtcLogLevelOff = 7,
} NERtcLogLevel;
 
 
typedef enum {
    kNERtcAreaCodeTypeDefault = 0,
    kNERtcAreaCodeTypeCN = 1,
    kNERtcAreaCodeTypeOverseaDefault = 2,
} NERtcAreaCodeType;
 
typedef enum {
    kNERtcSendOnPubNone = 0,
    kNERtcSendOnPubHigh = 1,
    kNERtcSendOnPubLow = 1 << 1,
    kNERtcSendOnPubAll = kNERtcSendOnPubLow | kNERtcSendOnPubHigh,
} NERtcSendOnPubType;
 
struct NERtcServerAddresses {
    char lbs_server[kNERtcMaxURILength];
    char channel_server[kNERtcMaxURILength];
    char statistics_server[kNERtcMaxURILength];
    char statistics_dispatch_server[kNERtcMaxURILength];
    char statistics_backup_server[kNERtcMaxURILength];
    char room_server[kNERtcMaxURILength];
    char compat_server[kNERtcMaxURILength];
    char nos_lbs_server[kNERtcMaxURILength];
    char nos_upload_sever[kNERtcMaxURILength];
    char nos_token_server[kNERtcMaxURILength];
    char cloud_proxy_server[kNERtcMaxURILength];
    char websocket_proxy_server[kNERtcMaxURILength];
    char quic_proxy_server[kNERtcMaxURILength];
    char media_proxy_server[kNERtcMaxURILength];
    char low_latency_server[kNERtcMaxURILength];
    bool use_ipv6;
 
    NERtcServerAddresses() {
        memset(this, 0, sizeof(NERtcServerAddresses));
        use_ipv6 = false;
    }
};
 
typedef enum {
    kNERtcAudioRecordingQualityLow = 0,
    kNERtcAudioRecordingQualityMedium = 1,
    kNERtcAudioRecordingQualityHigh = 2,
} NERtcAudioRecordingQuality;
 
typedef enum {
    // 录制本地和所有远端用户混音后的音频（默认）
    kNERtcAudioRecordingPositionMixedRecordingAndPlayback = 0,
    // 仅录制本地用户的音频
    kNERtcAudioRecordingPositionRecording = 1,
    // 仅录制所有远端用户的音频
    kNERtcAudioRecordingPositionMixedPlayback = 2
} NERtcAudioRecordingPosition;
 
typedef enum {
    // 音频录制缓存时间为 0，实时写文件（默认）
    kNERtcAudioRecordingCycleTime0 = 0,
    // 音频录制缓存时间为 10s，StopAudioRectording()后，将缓存都写到文件，文件数据时间跨度为: [0,10s]
    kNERtcAudioRecordingCycleTime10 = 10,
    // 音频录制缓存时间为 60s，StopAudioRectording()后，将缓存都写到文件，文件数据时间跨度为: [0,60s]
    kNERtcAudioRecordingCycleTime60 = 60,
    // 音频录制缓存时间为 360s，StopAudioRectording()后，将缓存都写到文件，文件数据时间跨度为: [0,360s]
    kNERtcAudioRecordingCycleTime360 = 360,
    // 音频录制缓存时间为 900s，StopAudioRectording()后，将缓存都写到文件，文件数据时间跨度为: [0,900s]
    kNERtcAudioRecordingCycleTime900 = 900
} NERtcAudioRecordingCycleTime;
 
struct NERtcAudioRecordingConfiguration {
    // 录音文件在本地保存的绝对路径，需要精确到文件名及格式。例如：sdcard/xxx/audio.aac。请确保指定的路径存在并且可写。目前仅支持
    // WAV 或 AAC 文件格式。
    char filePath[kNERtcMaxURILength];
 
    // 录音采样率（Hz），可以设为 16000、32000（默认）、44100 或 48000。
    int sampleRate;
 
    // 录音音质，只在 AAC 格式下有效。详细信息请参考 {@link NERtcAudioRecordingQuality}。
    NERtcAudioRecordingQuality quality;
 
    // 录音文件所包含的内容。详细信息请参考 {@link NERtcAudioRecordingPosition}。
    NERtcAudioRecordingPosition position;
 
    // 录制过程中，循环缓存的最大时间长度，单位(s)。详细信息请参考 {@link NERtcAudioRecordingCycleTime}。
    NERtcAudioRecordingCycleTime cycleTime;
 
    NERtcAudioRecordingConfiguration()
        : sampleRate(32000)
        , quality(kNERtcAudioRecordingQualityLow)
        , position(kNERtcAudioRecordingPositionMixedRecordingAndPlayback)
        , cycleTime(kNERtcAudioRecordingCycleTime0) {
        memset(filePath, 0, sizeof(filePath));
    }
};
 
typedef enum {
    kNERtcAudioRecordErrorSuffix = 1,
    kNERtcAudioRecordOpenFileFailed = 2,
    kNERtcAudioRecordStart = 3,
    kNERtcAudioRecordError = 4,
    kNERtcAudioRecordFinish = 5,
} NERtcAudioRecordingCode;
 
typedef enum {
    kNERtcStreamFallbackDisabled = 0,
 
    kNERtcStreamFallbackVideoStreamLow = 1,
 
    kNERtcStreamFallbackAudioOnly = 2,
} NERtcStreamFallbackOption;
 
typedef enum {
    kNERtcGMCryptoSM4ECB = 0,
  NERtcEncryptionModeCustom,
} NERtcEncryptionMode;
 
struct NERtcMediaPacket {
  // 需要发送或接收的数据的缓存地址
  const unsigned char* buffer;
  // 需要发送或接收的数据的缓存大小
  long size;
};
class INERtcPacketObserver {
 public:
  virtual ~INERtcPacketObserver() {}
 
  virtual bool onSendAudioPacket(NERtcMediaPacket& packet) = 0;
  virtual bool onSendVideoPacket(NERtcMediaPacket& packet) = 0;
  virtual bool onReceiveAudioPacket(NERtcMediaPacket& packet) = 0;
  virtual bool onReceiveVideoPacket(NERtcMediaPacket& packet) = 0;
};
 
struct NERtcEncryptionConfig {
    NERtcEncryptionMode mode;
    char key[kNERtcEncryptByteLength];
    INERtcPacketObserver* observer = nullptr;
 
    NERtcEncryptionConfig() : mode(kNERtcGMCryptoSM4ECB) { memset(key, 0, sizeof(key)); }
};
 
struct NERtcLastmileProbeConfig {
    bool probe_uplink;
    bool probe_downlink;
    uint32_t expected_uplink_bitratebps;
    uint32_t expected_downlink_bitratebps;
 
    NERtcLastmileProbeConfig()
        : probe_uplink(true)
        , probe_downlink(true)
        , expected_uplink_bitratebps(2000000)
        , expected_downlink_bitratebps(2000000) {}
};
 
typedef enum {
    kNERtcLastmileProbeResultComplete = 1,
    kNERtcLastmileProbeResultIncompleteNoBwe = 2,
    kNERtcLastmileProbeResultUnavailable = 3,
} NERtcLastmileProbeResultState;
 
struct NERtcLastmileProbeOneWayResult {
    uint32_t jitter;
    uint32_t packet_loss_rate;
    uint32_t available_band_width;
};
 
struct NERtcLastmileProbeResult {
    uint32_t rtt;
    NERtcLastmileProbeResultState state;
    NERtcLastmileProbeOneWayResult uplink_report;
    NERtcLastmileProbeOneWayResult downlink_report;
};
 
typedef enum {
    kNERtcTransportTypeNoneProxy = 0,
    kNERtcTransportTypeUDPProxy = 1,
} NERtcTransportType;
 
typedef enum {
    kNERtcInstallCastAudioDriverSuccess = 0,
    kNERtcInstallCastAudioDriverNotAuthorized = 1,
    kNERtcInstallCastAudioDriverFailed = 2,
} NERtcInstallCastAudioDriverResult;
 
enum NERtcVirtualBackgroundSourceStateReason {
    kNERtcVirtualBackgroundSourceStateReasonSuccess = 0,
    kNERtcVirtualBackgroundSourceStateReasonImageNotExist = 1,
    kNERtcVirtualBackgroundSourceStateReasonImageFormatNotSupported = 2,
    kNERtcVirtualBackgroundSourceStateReasonColorFormatNotSupported = 3,
    kNERtcVirtualBackgroundSourceStateReasonDeviceNotSupported = 4,
    kNERtcVirtualBackgroundSourceStateReasonVideoDecodeFail = 5
};
 
struct VirtualBackgroundSource {
    enum NERtcBackgroundSourceType {
        kNERtcBackgroundColor = 1,
 
        kNERtcBackgroundImage,
      
        kNERtcBackgroundVideo = 4,
    };
 
    NERtcBackgroundSourceType background_source_type;
 
    unsigned int color;
 
     char* source;
 
    VirtualBackgroundSource() : background_source_type(kNERtcBackgroundColor), color(0xffffff), source(NULL) {}
};
 
typedef enum {
    NERtcAudioDumpTypePCM = 0,
    NERtcAudioDumpTypeAll = 1,
    NERtcAudioDumpTypeWAV = 2
} NERtcAudioDumpType;
 
struct NERtcReverbParam {
    float wetGain;
    float dryGain;
    float damping;
    float roomSize;
    float decayTime;
    float preDelay;
};
 
struct NERtcLowLatencyOptions {
    bool enable_low_latency;
    unsigned int play_timeout;
    NERtcVideoCanvas* play_canvas;
   
    NERtcLowLatencyOptions() : enable_low_latency(false), play_timeout(60), play_canvas(nullptr) {
    }
};
 
struct NERtcJoinChannelOptions {
    char custom_info[kNERtcCustomInfoLength];
    char* permission_key;
    NERtcLowLatencyOptions low_latency_options;
 
    NERtcJoinChannelOptions() : permission_key(NULL) { 
        memset(custom_info, 0, sizeof(custom_info)); 
    }
};
 
typedef enum {
    NERtcRangeAudioModeDefault = 0,
    NERtcRangeAudioModeTeam = 1,
} NERtcRangeAudioMode;
 
struct NERtcJoinChannelOptionsEx {
    char custom_info[kNERtcCustomInfoLength];
    char* permission_key;
    int32_t team_id;
    NERtcRangeAudioMode mode;
    int audible_distance;
 
    NERtcJoinChannelOptionsEx() : permission_key(NULL), team_id(-1), mode(NERtcRangeAudioModeDefault), audible_distance(-1) { 
        memset(custom_info, 0, sizeof(custom_info)); 
    }
};
 
struct NERtcUserJoinExtraInfo {
    char custom_info[kNERtcCustomInfoLength];
    NERtcUserJoinExtraInfo(){ 
        memset(custom_info, 0, sizeof(custom_info));
    }
};
 
typedef enum {
    NERtcMediaPubTypeAudio
} NERtcMediaPubType;
 
typedef enum {
    kNERtcBeautyWhiteTeeth = 0,
 
    kNERtcBeautyLightEye,
 
    kNERtcBeautyWhiten,
 
    kNERtcBeautySmooth,
 
    kNERtcBeautySmallNose,
 
    kNERtcBeautyEyeDis,
 
    kNERtcBeautyEyeAngle,
 
    kNERtcBeautyMouth,
 
    kNERtcBeautyBigEye,
 
    kNERtcBeautySmallFace,
 
    kNERtcBeautyJaw,
 
    kNERtcBeautyThinFace,
 
    kNERtcBeautyFaceRuddy,
 
    kNERtcBeautyLongNose,
 
    kNERtcBeautyRenZhong,
 
    kNERtcBeautyMouthAngle,
 
    kNERtcBeautyRoundEye,
 
    kNERtcBeautyOpenEyeAngle,
 
    kNERtcBeautyVFace,
 
    kNERtcBeautyThinUnderjaw,
 
    kNERtcBeautyNarrowFace,
 
    kNERtcBeautyCheekBone,
 
    kNERtcBeautyFaceSharpen,
 
    kNERtcBeautyMouthWider,
    
    kNERtcBeautyForeheadWrinkles,
    
    kNERtcBeautyDarkCircles,
    
    kNERtcBeautySmileLines,
    
    kNERtcBeautyShortFace
} NERtcBeautyEffectType;
 
struct NERtcSize {
  int width;
  int height;
 
  NERtcSize() : width(0), height(0) {}
  NERtcSize(int w, int h) : width(w), height(h) {}
};
 
struct NERtcThumbImageBuffer {
  const char* buffer;
  unsigned int length;
  unsigned int width;
  unsigned int height;
 
  NERtcThumbImageBuffer() : buffer(nullptr), length(0), width(0), height(0) {}
};
 
struct NERtcScreenCaptureSourceInfo {
  NERtcScreenCaptureSourceType type;
  source_id_t source_id;
  const char* source_name;
  NERtcThumbImageBuffer thumb_image;
  NERtcThumbImageBuffer icon_image;
  const char* process_path;
  const char* source_title;
  bool primaryMonitor;
  
  NERtcScreenCaptureSourceInfo()
    : type(kUnknown)
    , source_id(nullptr)
    , source_name(nullptr)
    , process_path(nullptr)
    , source_title(nullptr)
    , primaryMonitor(false) {}
};
 
class IScreenCaptureSourceList {
protected:
  virtual ~IScreenCaptureSourceList() {};
 
public:
  virtual unsigned int getCount() = 0;
  virtual NERtcScreenCaptureSourceInfo getSourceInfo(unsigned int index) = 0;
  virtual void release() = 0;
};
 
typedef enum {
  kNERtcSpatializerRoomCapacitySmall = 0,
 
  kNERtcSpatializerRoomCapacityMedium = 1,
 
  kNERtcSpatializerRoomCapacityLarge = 2,
 
  kNERtcSpatializerRoomCapacityHuge = 3,
 
  kNERtcSpatializerRoomCapacityNone = 4
} NERtcSpatializerRoomCapacity;
typedef enum {
  kNERtcSpatializerMaterialTransparent = 0,
  kNERtcSpatializerMaterialAcousticCeilingTiles,
  kNERtcSpatializerMaterialBrickBare,
  kNERtcSpatializerMaterialBrickPainted,
  kNERtcSpatializerMaterialConcreteBlockCoarse,
  kNERtcSpatializerMaterialConcreteBlockPainted,
  kNERtcSpatializerMaterialCurtainHeavy,
  kNERtcSpatializerMaterialFiberGlassInsulation,
  kNERtcSpatializerMaterialGlassThin,
  kNERtcSpatializerMaterialGlassThick,
  kNERtcSpatializerMaterialGrass,
  kNERtcSpatializerMaterialLinoleumOnConcrete,
  kNERtcSpatializerMaterialMarble,
  kNERtcSpatializerMaterialMetal,
  kNERtcSpatializerMaterialParquetOnConcrete,
  kNERtcSpatializerMaterialPlasterRough,
  kNERtcSpatializerMaterialPlasterSmooth,
  kNERtcSpatializerMaterialPlywoodPanel,
  kNERtcSpatializerMaterialPolishedConcreteOrTile,
  kNERtcSpatializerMaterialSheetrock,
  kNERtcSpatializerMaterialWaterOrIceSurface,
  kNERtcSpatializerMaterialWoodCeiling,
  kNERtcSpatializerMaterialWoodPanel,
  kNERtcSpatializerMaterialUniform
} NERtcSpatializerMaterialName;
 
typedef enum {
  kNERtcSpatializerRenderStereoPanning = 0,
  kNERtcSpatializerRenderBinauralLowQuality,
  kNERtcSpatializerRenderBinauralMediumQuality,
  kNERtcSpatializerRenderBinauralHighQuality,
  kNERtcSpatializerRenderRoomEffectsOnly
} NERtcSpatializerRenderMode;
 
typedef enum {
  kNERtcDistanceRolloffLogarithmic = 0,
  kNERtcDistanceRolloffLinear,
  kNERtcDistanceRolloffNone,
  kNERtcDistanceRolloffLinearOnly,
} NERtcDistanceRolloffModel;
 
struct NERtcPositionInfo {
  float speaker_position[3];
  float speaker_quaternion[4];
  float head_position[3];
  float head_quaternion[4];
};
 
struct NERtcSpatializerRoomProperty {
  NERtcSpatializerRoomCapacity room_capacity;
  NERtcSpatializerMaterialName material;
  float reflection_scalar;
  float reverb_gain;
  float reverb_time;
  float reverb_brightness;
};
 
 
struct NERtcStreamingRoomInfo {
 
  uint64_t uid;
 
  const char* channel_name;
  const char* token;
};
 
 
struct NERtcPushStreamingConfig {
  const char* streaming_url;
 
  NERtcStreamingRoomInfo streaming_room_info;
};
 
typedef enum {
  kNERtcLocalRecorderStatusNone = 0,
 
  kNERtcLocalRecorderStatusFlvStart,
 
  kNERtcLocalRecorderStatusFlvEnd,
 
  kNERtcLocalRecorderStatusMp4Start,
 
  kNERtcLocalRecorderStatusMp4End,
 
  kNERtcLocalRecorderStatusRemuxStart,
 
  kNERtcLocalRecorderStatusRemuxEnd,
 
  kNERtcLocalRecorderStatusComplete
} NERtcLocalRecorderStatus;
 
typedef enum {
  kNERtcLocalRecorderErrorNone = 0,
 
  kNERtcLocalRecorderFileOpenFailed,
 
  kNERtcLocalRecorderWriteFailed,
 
  kNERtcLocalRecorderWriteTrailerFailed,
 
  kNERtcLocalRecorderFailed,
 
  kNERtcLocalRecorderCallbackConflict,
 
  kNERtcLocalRecorderTaskAlreadyExist,
 
  kNERtcLocalRecorderTaskNotFound,
 
  kNERtcLocalRecorderSourceNotFoundForTask,
 
  kNERtcLocalRecorderInputOpenFailed,
 
  kNERtcLocalRecorderVideoStreamCreateFailed,
 
  kNERtcLocalRecorderAudioStreamCreateFailed,
 
  kNERtcLocalRecorderCoverImageParseFailed,
 
  kNERtcLocalRecorderPlaceholderImageParseFailed,
 
  kNERtcLocalRecorderAudioConfigInvalid,
 
  kNERtcLocalRecorderRemuxPrcocessRunning,
 
  kNERtcLocalRecorderOutputOpenFailed
} NERtcLocalRecorderError;
 
typedef enum {
  kNERtcLocalRecordingFileTypeMp4 = 0,
 
  kNERtcLocalRecordingFileTypeFlv = 1,
} NERtcLocalRecordingFileType;
 
 
typedef enum {
  kNERtcLocalRecorderAudioFormatAac = 0,
} NERtcLocalRecordingAudioFormat;
 
 
typedef enum {
  kNERtcLocalRecorderVideoWithAudio = 0,
  kNERtcLocalRecorderVideoWithoutAudio = 1,
} NERtcLocalRecordingVideoMode;
 
struct NERtcLocalRecordingConfig {
  char file_path[kNERtcMaxBuffLength];
  char file_name[kNERtcMaxBuffLength];
  int width = 0;
  int height = 0;
  int framerate = 15;
  NERtcLocalRecordingFileType record_file_type = kNERtcLocalRecordingFileTypeMp4;
  bool remux_to_mp4 = false;
  bool video_merge = false;
  bool record_audio = false;
  NERtcLocalRecordingAudioFormat audio_format = kNERtcLocalRecorderAudioFormatAac;
  bool record_video = true;
  NERtcLocalRecordingVideoMode video_record_mode = kNERtcLocalRecorderVideoWithAudio;
  NERtcVideoWatermarkConfig *watermark_list = nullptr;
  int watermark_count = 0;
  char cover_file_path[kNERtcMaxBuffLength];
  NERtcVideoWatermarkConfig* cover_watermark_list = nullptr;
  int cover_watermark_count = 0;
  char default_cover_file_path[kNERtcMaxBuffLength];
  NERtcLocalRecordingConfig() {
    memset(file_path, 0, kNERtcMaxBuffLength);
    memset(file_name, 0, kNERtcMaxBuffLength);
    memset(cover_file_path, 0, kNERtcMaxBuffLength);
    memset(default_cover_file_path, 0, kNERtcMaxBuffLength);
  };
};
 
struct NERtcLocalRecordingLayoutConfig
{
  int offset_x = 0;
  int offset_y = 0;
  int width = 0;
  int height = 0;
  NERtcVideoScalingMode scaling_mode = kNERtcVideoScaleFullFill;
  NERtcVideoWatermarkConfig* watermark_list = nullptr;
  int watermark_count = 0;
  bool is_screen_share = false;
  uint32_t bg_color = 0;
};
 
struct NERtcLocalRecordingStreamInfo {
  uid_t uid;
  NERtcVideoStreamType stream_type;
  int stream_layer;
  NERtcLocalRecordingLayoutConfig layout_config;
 
  NERtcLocalRecordingStreamInfo() : uid(0), stream_type(kNERTCVideoStreamMain), stream_layer(0) {}
};
 
 
typedef enum {
  kNERtcAsrCaptionStartFailed = 0,
  kNERtcAsrCaptionStateStopFailed = 1,
  kNERtcAsrCaptionStateStarted = 2,
  kNERtcAsrCaptionStateStopped = 3
} NERtcAsrCaptionState;
 
struct NERtcASRCaptionConfig {
  char src_language[kNERtcMaxTokenLength];
  char dst_language[kNERtcMaxTokenLength];
  
  NERtcASRCaptionConfig() {
    memset(src_language, 0, kNERtcMaxTokenLength);
    memset(dst_language, 0, kNERtcMaxTokenLength);
  }
};
 
struct NERtcAsrCaptionResult {
  uint64_t user_id;
  bool is_local_user;
  uint64_t timestamp;
  const char* content;
  const char* language;
  bool have_translation;
  const char* translated_text;
  const char* translation_language;
  bool is_final;
  
  NERtcAsrCaptionResult() {
    memset(this, 0, sizeof(NERtcAsrCaptionResult));
  }
};
 
#define kNERtcKeyRecordHostEnabled "record_host_enabled"
#define kNERtcKeyRecordAudioEnabled "record_audio_enabled"
#define kNERtcKeyRecordVideoEnabled "record_video_enabled"
#define kNERtcKeyRecordType "record_type"
#define kNERtcKeyAutoSubscribeAudio "auto_subscribe_audio"
#define kNERtcKeyPublishSelfStreamEnabled "publish_self_stream_enabled"
#define kNERtcKeyLogLevel "log_level"
#define kNERtcKeyAudioProcessingAECEnable "audio_processing_aec_enable"
#define kNERtcKeyAudioAECLowLevelEnable "audio_aec_low_level_enable"
#define kNERtcKeyAudioProcessingAGCEnable "audio_processing_agc_enable"
#define kNERtcKeyAudioProcessingNSEnable "audio_processing_ns_enable"
#define kNERtcKeyAudioProcessingAINSEnable "audio_processing_ai_ns_enable"
#define kNERtcKeyAudioProcessingExternalAudioMixEnable "audio_processing_external_audiomix_enable"
#define kNERtcKeyAudioProcessingEarphone "audio_processing_earphone"
#define kNERtcKeyVideoSendOnPubType "video_sendonpub_type"
#define kNERtcKeyChannel1V1ModeEnabled "channel_1v1_mode_enabled"
#define kNERtcKeyExtraInfo "extra_info"
#define kNERtcKeyAudioDeviceAutoSelectType "audio_device_auto_select_type"
#define kNERtcKeyEnableReportVolumeWhenMute "enable_report_volume_when_mute"
 
#define kNERtcKeyDisableFirstUserCreateChannel "disable_first_user_create_channel"
 
#define kNERtcKeyAutoSubscribeVideo "auto_subscribe_video"
#define kNERtcKeyAutoSubscribeData "auto_subscribe_data"
#define kNERtcKeyEnableVideoCaptureObserver "video_frame_capture"
 
#define kNERtcKeyDisableVideoDecoder "disable_video_decoder"
 
#define kNERtcKeyVideoRenderType "sdk.prefer.video.render"
 
} // namespace nertc
 
#endif