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,
} 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,
    kNERtcRemoteVideoStreamTypeNone = 2,
} NERtcRemoteVideoStreamType;
 
typedef enum {
    kNERtcAudioDeviceUnknown = 0,
    kNERtcAudioDeviceRecord,
    kNERtcAudioDevicePlayout,
} NERtcAudioDeviceType;
 
typedef enum {
    kNERtcAudioDeviceActive = 0,
    kNERtcAudioDeviceUnactive,
} 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;
};
 
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;
 
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;
};
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];
};
 
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;
};
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) {}
};
 
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;
 
    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) {}
};
 
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)
        , 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,
    kNERtcVideoTypeCVPixelBuffer = 4,
} 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,
    
} NERtcVideoStreamType;
 
struct NERtcTextWatermarkConfig {
    char content[kNERtcMaxBuffLength];
    char font_name[kNERtcMaxURILength];
    int font_size;
    int font_color;
    int offset_x;
    int offset_y;
    int wm_color;
    int wm_width;
    int wm_height;
 
    NERtcTextWatermarkConfig()
        : font_size(10)
        , font_color(0xFFFFFFFF)
        , offset_x(0)
        , offset_y(0)
        , wm_color(0x88888888)
        , wm_width(0)
        , wm_height(0) {
        memset(content, 0, sizeof(content));
        memset(font_name, 0, sizeof(font_name));
    }
};
 
struct NERtcTimestampWatermarkConfig {
    char font_name[kNERtcMaxURILength];
    int font_size;
    int font_color;
    int offset_x;
    int offset_y;
    int wm_color;
    int wm_width;
    int wm_height;
    int ts_type;
 
    NERtcTimestampWatermarkConfig()
        : font_size(10)
        , font_color(0xFFFFFFFF)
        , offset_x(0)
        , offset_y(0)
        , wm_color(0x88888888)
        , wm_width(0)
        , wm_height(0)
        , ts_type(1) {
        memset(font_name, 0, sizeof(font_name));
    }
};
 
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) {}
};
 
struct NERtcImageWatermarkConfig {
    char image_paths[10][kNERtcMaxURILength];
    int offset_x;
    int offset_y;
    int image_width;
    int image_height;
    int fps;
    bool loop;
 
    NERtcImageWatermarkConfig() : offset_x(0), offset_y(0), image_width(0), image_height(0), fps(0), loop(true) {
        memset(image_paths, 0, sizeof(image_paths));
    }
};
 
struct NERtcCanvasWatermarkConfig {
    NERtcImageWatermarkConfig* image_watermarks;
    int image_count_;
    NERtcTextWatermarkConfig* text_watermarks;
    int text_count_;
    NERtcTimestampWatermarkConfig* timestamp_watermark;
 
    NERtcCanvasWatermarkConfig()
        : image_watermarks(NULL), image_count_(0), text_watermarks(NULL), text_count_(0), timestamp_watermark(NULL) {}
};
 
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 {
    kNERtcSendOnPubNone = 0,
    kNERtcSendOnPubHigh = 1,
    kNERtcSendOnPubLow = 1 << 1,
    kNERtcSendOnPubAll = kNERtcSendOnPubLow | kNERtcSendOnPubHigh,
} NERtcSendOnPubType;
 
struct NERtcServerAddresses {
    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];
    bool use_ipv6;
 
    NERtcServerAddresses() : use_ipv6(false) {
        memset(channel_server, 0, sizeof(channel_server));
        memset(statistics_server, 0, sizeof(statistics_server));
        memset(statistics_dispatch_server, 0, sizeof(statistics_dispatch_server));
        memset(statistics_backup_server, 0, sizeof(statistics_backup_server));
        memset(room_server, 0, sizeof(room_server));
        memset(compat_server, 0, sizeof(compat_server));
        memset(nos_lbs_server, 0, sizeof(nos_lbs_server));
        memset(nos_upload_sever, 0, sizeof(nos_upload_sever));
        memset(nos_token_server, 0, sizeof(nos_token_server));
        memset(cloud_proxy_server, 0, sizeof(cloud_proxy_server));
        memset(websocket_proxy_server, 0, sizeof(websocket_proxy_server));
        memset(quic_proxy_server, 0, sizeof(quic_proxy_server));
        memset(media_proxy_server, 0, sizeof(media_proxy_server));
    }
};
 
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,
} NERtcEncryptionMode;
 
struct NERtcEncryptionConfig {
    NERtcEncryptionMode mode;
    char key[kNERtcEncryptByteLength];
 
    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
};
 
struct VirtualBackgroundSource {
    enum NERtcBackgroundSourceType {
        kNERtcBackgroundColor = 1,
 
        kNERtcBackgroundImage,
    };
 
    NERtcBackgroundSourceType background_source_type;
 
    unsigned int color;
 
    char* source;
 
    VirtualBackgroundSource() : color(0xffffff), source(NULL), background_source_type(kNERtcBackgroundColor) {}
};
 
typedef enum {
    NERtcAudioDumpTypePCM = 0,
    NERtcAudioDumpTypeAll = 1,
    NERtcAudioDumpTypeWAV = 2
} NERtcAudioDumpType;
 
struct NERtcReverbParam {
    float wetGain;
    float dryGain;
    float damping;
    float roomSize;
    float decayTime;
    float preDelay;
};
 
struct NERtcJoinChannelOptions {
    char custom_info[kNERtcCustomInfoLength];
    char* permission_key;
    NERtcJoinChannelOptions() : permission_key(NULL) { 
        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;
 
#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 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