NertcEngineDefines.h

浏览该文件的文档.

 
#pragma once
 
#include "NertcBaseTypes.h"
#define kNERtcMaxPlaneCount 4
#define kNERtcEncryptByteLength 128
#define kNERtcCustomInfoLength 128
#define kNERtcMaxChannelNameLength 128
#define kNERtcMaxTokenLength 256
#define kNERtcMaxDeviceIDLength 256
#define kNERtcMaxDeviceNameLength 256
#define kNERtcMaxURILength 256
#define kNERtcMaxTaskIDLength 64
#define kNERtcMaxBuffLength 1024
#define kNERtcMaxSEIBufferLength 4096
#define kNERtcExternalVideoDeviceID "nertc-video-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];
};
 
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;
};
 
struct NERtcLiveStreamImageInfo {
  char url[kNERtcMaxURILength];
  int x;
  int y;
  int width;
  int height;
  int z_order;
};
 
 
struct NERtcLiveStreamLayout {
  int width;
  int height;
  unsigned int background_color;
  unsigned int user_count;
  NERtcLiveStreamUserTranscoding* users;
  NERtcLiveStreamImageInfo* bg_image;
 
   int bg_image_count;
};
 
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;
};
 
struct NERtcLiveStreamTaskInfo {
  char task_id[kNERtcMaxTaskIDLength];
  char stream_url[kNERtcMaxURILength];
  bool server_record_enabled;
  NERtcLiveStreamMode ls_mode;
  NERtcLiveStreamLayout layout;
  NERtcLiveConfig config;
  char extra_info[kNERtcMaxSEIBufferLength];
};
 
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,
  kNERtcAudioScenarioChatroom = 3,
} 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;
 
typedef enum {
  kNERtcCameraOutputDefault = 0,
  kNERtcCameraOutputQuality = 1,
  kNERtcCameraOutputManual = 2,
} NERtcCameraPreference;
 
struct NERtcCameraCaptureConfig {
  NERtcCameraPreference preference;
  int capture_width;
  int capture_height;
};
 
typedef enum {
  kNERtcVideoProfileLowest = 0,
  kNERtcVideoProfileLow = 1,
  kNERtcVideoProfileStandard = 2,
  kNERtcVideoProfileHD720P = 3,
  kNERtcVideoProfileHD1080P = 4,
  kNERtcVideoProfileNone = 5,
  kNERtcVideoProfileMAX = kNERtcVideoProfileHD1080P,
  kNERtcVideoProfileFake = 6,
} 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];
};
 
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;
};
 
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 {
  kNERtcScreenCaptureStatusStart = 1,
 
  kNERtcScreenCaptureStatusPause = 2,
 
  kNERtcScreenCaptureStatusResume = 3,
 
  kNERtcScreenCaptureStatusStop = 4,
 
  kNERtcScreenCaptureStatusCovered = 5
} NERtcScreenCaptureStatus;
 
struct NERtcRectangle {
  int x;
  int y;
  int width;
  int height;
};
 
struct NERtcVideoDimensions {
  int width;
  int height;
};
 
typedef enum {
  kNERtcSubStreamContentPreferMotion = 0,
  kNERtcSubStreamContentPreferDetails = 1,
} NERtcSubStreamContentPrefer;
 
struct NERtcScreenCaptureParameters {
  NERtcScreenProfileType profile;
  NERtcVideoDimensions dimensions;
  int frame_rate;
  int bitrate;
  bool capture_mouse_cursor;
  bool window_focus;
  source_id_t* excluded_window_list;
  int excluded_window_count;
  NERtcSubStreamContentPrefer prefer;
 
  NERtcDegradationPreference degradation_preference;
};
 
struct NERtcVideoCanvas {
  bool use_external_render;
  onFrameDataCallback cb;
  void* user_data;
  void* window;
  NERtcVideoScalingMode scaling_mode;
  
  uint32_t background_color;
};
 
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;
};
 
struct NERtcAudioFormat {
  NERtcAudioType type;
  uint32_t channels;
  uint32_t sample_rate;
  uint32_t bytes_per_sample;
  uint32_t samples_per_channel;
};
 
struct NERtcAudioFrame {
  NERtcAudioFormat format;
  void* data;
};
 
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;
};
class INERtcAudioFrameObserver {
 public:
  virtual ~INERtcAudioFrameObserver() {}
  virtual void onAudioFrameDidRecord(NERtcAudioFrame* frame) = 0;
  virtual void onSubstreamAudioFrameDidRecord(NERtcAudioFrame *frame);
  virtual void onAudioFrameWillPlayback(NERtcAudioFrame* frame) = 0;
  virtual void onMixedAudioFrame(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,
} 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;
  int count;
    uint32_t offset[4];
  uint32_t stride[4];
  NERtcVideoRotation rotation;
  void* buffer;
  int64_t buffer_length;
};
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;
};
 
struct NERtcCreateAudioEffectOption {
    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;
};
 
typedef enum {
  kNERTCVideoStreamMain = 0,
  kNERTCVideoStreamSub = 1,
  kNERTCVideoStreamCount,
} NERtcVideoStreamType;
 
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 {
  const char channel_name[kNERtcMaxChannelNameLength];
  const char channel_token[kNERtcMaxTokenLength];
  uid_t uid;
};
 
struct NERtcChannelMediaRelayConfiguration {
  NERtcChannelMediaRelayInfo* src_infos;
  NERtcChannelMediaRelayInfo* dest_infos;
  int dest_count;
};
 
typedef enum {
  kNERtcLocalWatermarkStateSetSuccess,
  kNERtcLocalWatermarkStateDeviceNotSupported,
  kNERtcLocalWatermarkStateImgFormatNotSupported,
  kNERtcLocalWatermarkStateImgNumError,
  kNERtcLocalWatermarkStateImgSizeError,
  kNERtcLocalWatermarkStateFPSError,
  kNERtcLocalWatermarkStateFontError,
  kNERtcLocalWatermarkStateWmAlphaError,
  kNERtcLocalWatermarkStateTextContentEmptyError,
  kNERtcLocalWatermarkStateCancel = 20
} NERtcLocalVideoWatermarkState;
 
struct NERtcVideoWatermarkImageConfig {
  char* image_paths[10];
  int wm_alpha;
  int wm_width;
  int wm_height;
  int offset_x;
  int offset_y;
  int fps;
  bool loop;
};
 
struct NERtcVideoWatermarkTextConfig {
  char content[kNERtcMaxBuffLength];
  char font_name[kNERtcMaxURILength];
  int font_color;
  int font_size;
  int wm_color;
  int wm_alpha;
  int wm_width;
  int wm_height;
  int offset_x;
  int offset_y;
};
 
struct NERtcVideoWatermarkTimestampConfig {
  char font_name[kNERtcMaxURILength];
  int font_color;
  int font_size;
  int wm_color;
  int wm_alpha;
  int wm_width;
  int wm_height;
  int offset_x;
  int offset_y;
};
 
struct NERtcVideoWatermarkConfig {
    typedef enum {
        kNERtcWatermarkTypeImage = 0,
        kNERtcWatermarkTypeText,
        kNERtcWatermarkTypeTimestamp
    }NERtcWatermarkType;
 
    NERtcWatermarkType watermark_type;
    NERtcVideoWatermarkImageConfig image_watermarks;
    NERtcVideoWatermarkTextConfig text_watermarks;
    NERtcVideoWatermarkTimestampConfig timestamp_watermark;
};
 
class NERtcTakeSnapshotCallback {
 public:
  virtual ~NERtcTakeSnapshotCallback() {}
 /*
  * Returns the screenshot result.
  * @param errorCode The error code. For more information, see {@link NERtcErrorCode}.
  * @param image The screenshot. Images on macOS are in CGImageRef format.
  * @endif
  * @if Chinese
  * 截图结果回调。
  * @param errorCode 错误码。详细信息请参考 {@link NERtcErrorCode}。
  * @param image 截图图片。默认为图片文件所在路径。
  * @endif
  */
  virtual void onTakeSnapshotCallback(uid_t uid, NERtcVideoStreamType stream_type, int error_code, void* 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 {
  kNERtcAudioRecordingCycleTime0 = 0,
  kNERtcAudioRecordingCycleTime10 = 10,
  kNERtcAudioRecordingCycleTime60 = 60,
  kNERtcAudioRecordingCycleTime360 = 360,
  kNERtcAudioRecordingCycleTime900 = 900
} NERtcAudioRecordingCycleTime;
 
struct NERtcAudioRecordingConfiguration {
  // 录音文件在本地保存的绝对路径，需要精确到文件名及格式。例如：sdcard/xxx/audio.aac。请确保指定的路径存在并且可写。目前仅支持
  // WAV 或 AAC 文件格式。
  char file_path[kNERtcMaxURILength];
 
  // 录音采样率（Hz），可以设为 16000、32000（默认）、44100 或 48000。
  int sample_rate;
 
  // 录音音质，只在 AAC 格式下有效。详细信息请参考 {@link NERtcAudioRecordingQuality}。
  NERtcAudioRecordingQuality quality;
 
  // 录音文件所包含的内容。详细信息请参考 {@link NERtcAudioRecordingPosition}。
  NERtcAudioRecordingPosition position;
 
  // 录制过程中，循环缓存的最大时间长度，单位(s)。详细信息请参考 {@link NERtcAudioRecordingCycleTime}。
  NERtcAudioRecordingCycleTime cycle_time;
};
 
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];
};
 
struct NERtcLastmileProbeConfig {
  bool probe_uplink;
  bool probe_downlink;
  uint32_t expected_uplink_bitratebps;
  uint32_t expected_downlink_bitratebps;
};
 
typedef enum {
  kNERtcLastmileProbeResultComplete = 1,
  kNERtcLastmileProbeResultIncompleteNoBwe = 2,
  kNERtcLastmileProbeResultUnavailable = 3,
} NERtcLastmileProbeResultState;
 
struct NERtcLastmileProbeOneWayResult {
  uint32_t jitter = 0;
  uint32_t packet_loss_rate = 0;
  uint32_t available_band_width = 0;
};
 
struct NERtcLastmileProbeResult {
  uint32_t rtt = 0;
  NERtcLastmileProbeResultState state = kNERtcLastmileProbeResultComplete;
  NERtcLastmileProbeOneWayResult uplink_report;
  NERtcLastmileProbeOneWayResult downlink_report;
};
typedef enum {
    kNERtcTransportTypeNoneProxy = 0,
    kNERtcTransportTypeUDPProxy = 1,
} NERtcTransportType;
 
typedef enum {
    kNERtcInstallCastAudioDriverSuccess = 0,
    kNERtcInstallCastAudioDriverNotAuthorized = 1,
    kNERtcInstallCastAudioDriverFailed = 2,
} NERtcInstallCastAudioDriverResult;
typedef enum{
    kNERtcVirtualBackgroundSourceStateReasonSuccess = 0,
    kNERtcVirtualBackgroundSourceStateReasonImageNotExist = 1,
    kNERtcVirtualBackgroundSourceStateReasonImageFormatNotSupported = 2,
    kNERtcVirtualBackgroundSourceStateReasonColorFormatNotSupported = 3,
    kNERtcVirtualBackgroundSourceStateReasonDeviceNotSupported = 4
} NERtcVirtualBackgroundSourceStateReason;
 
struct NERtcVirtualBackgroundSource {
    typedef enum {
        kNERtcBackgroundColor = 1,
 
        kNERtcBackgroundImage,
    }NERtcBackgroundSourceType;
 
    NERtcBackgroundSourceType background_source_type;
 
    unsigned int color;
 
    char source[kNERtcMaxURILength];
};
 
typedef enum {
  kNERtcAudioDumpTypePCM = 0,
  kNERtcAudioDumpTypeAll = 1,
  kNERtcAudioDumpTypeWAV = 2
} NERtcAudioDumpType;
 
struct NERtcReverbParam {
    float wet_gain;
    float dry_gain;
    float damping;
    float room_size;
    float decay_time;
    float predelay;
};
 
typedef enum {
  kNERtcRangeAudioModeDefault = 0,
  kNERtcRangeAudioModeTeam = 1,
} NERtcRangeAudioMode;
 
struct NERtcJoinChannelOptions {
    char custom_info[kNERtcCustomInfoLength];
    char* permission_key;
    int32_t team_id;
    NERtcRangeAudioMode mode;
    int audible_distance;
 
    NERtcJoinChannelOptions() : permission_key(NULL), team_id(-1), mode(kNERtcRangeAudioModeDefault), audible_distance(-1) {
      memset(custom_info, 0, sizeof(custom_info));
    }
};
 
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(kNERtcRangeAudioModeDefault), audible_distance(-1) {
      memset(custom_info, 0, sizeof(custom_info));
    }
};
 
struct NERtcUserJoinExtraInfo {
    char custom_info[kNERtcCustomInfoLength];
};
 
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;
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,
} NERtcDistanceRolloffModel;
 
struct NERtcPositionInfo {
  float speaker_position[3];
  float speaker_quaternion[4];
  float head_position[3];
  float head_quaternion[4];
  NERtcPositionInfo() {
    memset(speaker_position, 0, sizeof(speaker_position));
    memset(speaker_quaternion, 0, sizeof(speaker_quaternion));
    memset(head_position, 0, sizeof(head_position));
    memset(head_quaternion, 0, sizeof(head_quaternion));
  }
};
 
struct NERtcSpatializerRoomProperty {
  NERtcSpatializerRoomCapacity room_capacity;
  NERtcSpatializerMaterialName material;
  float reflection_scalar;
  float reverb_gain;
  float reverb_time;
  float reverb_brightness;
};
 
typedef enum {
  kNERtcVoiceAuditUnkonwn = -1,
  kNERtcVoiceAuditing = 0,
  kNERtcVoiceAuditFinished = 1,
  kNERtcVoiceAuditServerError = 2,
  kNERtcVoiceAuditUnactivated = 3,
} NERtcVoiceAuditStatus;
 
 
#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 kNERtcKeyEnableAudioASLManualSubscribe "enable_audio_asl_manual_subscribe"
#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 kNERtcKeyEnableVideoCaptureObserver "enable_video_capture_observer"
#define kNERtcKeyVideoPreferHWEncode "video_prefer_hw_encode"
#define kNERtcKeyVideoPreferHWDecode "video_prefer_hw_decode"
 
#define kNERtcKeyEnableDynamicToken "enable_dynamic_token"
#define kNERtcKeyVideoStartWithBackCamera "video_start_with_back_camera"
#define kNERtcKeyVideoPreferMetalRender "video_prefer_metal_render"
#define kNERtcKeyDisableOverrideSpeakerOnReceiver "disable_override_speaker_on_receiver"
#define kNERtcKeyDisableSWAECOnHeadset "disable_sw_aec_on_headset"
#define kNERtcKeyEnableAudioBluetoothSCO "enable_audio_bluetooth_sco"
#define kNERtcKeyEnableVideoMirrorWithFrontCamera "enable_video_mirror_with_front_camera"
#define kNERtcKeyVideoCameraType "video_camera_type"
 
#define kNERtcKeyEnableSnapshotWithFile "enable_snapshot_with_file"
 
#define kNERtcKeyAutoSubscribeVideo "auto_subscribe_video"
 
#define kNERtcKeyAutoSubscribeData "auto_subscribe_data"
 
#define kNERtcKeyDisableVideoDecoder "disable_video_decoder"
 
#define kNERtcKeyVideoRenderType "sdk.prefer.video.render"
 
typedef enum{
  kNERtcAudioDeviceNoError = 0, 
  kNERtcAudioDeviceErrorInitRecording, 
  kNERtcAudioDeviceErrorStartRecording,
  kNERtcAudioDeviceErrorStopRecording,
  kNERtcAudioDeviceErrorInitPlayout,
  kNERtcAudioDeviceErrorStartPlayout,
  kNERtcAudioDeviceErrorStopplayout,
  kNERtcAudioDeviceErrorCaptureThreadStop,
  kNERtcAudioDeviceErrorPlayoutThreadStop,
  kNERtcAudioDeviceErrorCaptureSampleRate,
  kNERtcAudioDeviceErrorPlayoutSampleRate,
  kNERtcAudioDeviceErrorConfigSession,
  kNERtcAudioDeviceErrorCodeReporter
}NERtcAudioDeviceError;
 
typedef enum {
  kNERtcVideoDeviceErrorNoFrame = 0,
  kNERtcVideoDeviceErrorNotAvailableInBackground,
  kNERtcVideoDeviceErrorUsingByAnotherClient,
  kNERtcVideoDeviceErrorNotAvailableWithMultipleForegroundApps,
} NERtcVideoDeviceError;
 
typedef enum {
  kNERtcAudioOutputRoutingDefault = 0,
  kNERtcAudioOutputRoutingHeadset,
  kNERtcAudioOutputRoutingEarpiece,
  kNERtcAudioOutputRoutingLoudspeaker,
  kNERtcAudioOutputRoutingBluetooth,
} NERtcAudioOutputRouting;
 
typedef enum {
  kNERtcNetworkTypeUnknown = 0,
  kNERtcNetworkTypeEthernet,
  kNERtcNetworkTypeWifi,
  kNERtcNetworkType2G,
  kNERtcNetworkType3G,
  kNERtcNetworkType4G,
  kNERtcNetworkType5G,
  kNERtcNetworkTypeWWAN,
  kNERtcNetworkTypeBluetooth,
  kNERtcNetworkTypeNone
} NERtcNetworkType;
 
struct NERtcCameraFocusAndExposureInfo {
  float center_x;
  float center_y;
  int32_t left;
  int32_t top;
  int32_t right;
  int32_t bottom;
};
typedef enum {
  kNERtcAudioSessionOperationRestrictionNone = 0,
  kNERtcAudioSessionOperationRestrictionAll,
  kNERtcAudioSessionOperationRestrictionDeactivateSession,
} NERtcAudioSessionOperationRestriction;
 
typedef enum {
  kNERtcAudioFocusOff = 0,
  kNERtcAudioFocusGain = 1,
 
  kNERtcAudioFocusGainTransient = 2,
 
  kNERtcAudioFocusGainTransientMayDuck = 3,
 
  kNERtcAudioFocusGainTransientExclisive = 4,
}NERtcAudioFocusMode;
 
typedef enum {
  kNERtcCameraPositionBack = 0,
 
  kNERtcCameraPositionFront
}NERtcCameraPosition;
 
struct NERtcPoint {
  float x;
  float y;
};
struct NERtcVideoCorrectionConfiguration {
  NERtcPoint top_left;
  NERtcPoint top_right;
  NERtcPoint bottom_left;
  NERtcPoint bottom_right;
  float canvas_width;
  float canvas_height;
  bool enable_mirror;
};
}// namespace nertc