nertc_engine_defines.h

浏览该文件的文档.

 
#ifndef NERTC_ENGINE_DEFINES_H
#define NERTC_ENGINE_DEFINES_H
 
#include "nertc_base_types.h"
 
#define kNERtcMaxPlaneCount          4        
#define kNERtcEncryptByteLength      128      
#define kNERtcMaxChannelNameLength   128      
#define kNERtcMaxTokenLength         256      
#define kNERtcMaxDeviceIDLength      256      
#define kNERtcMaxDeviceNameLength    256      
#define kNERtcMaxURILength           256      
#define kNERtcMaxTaskIDLength        64       
#define kNERtcMaxBuffLength          1024     
#define kNERtcMacSEIBufferLength     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;
};
 
struct NERtcLiveStreamLayout {
    int width;
    int height;
    unsigned int background_color;
    unsigned int user_count;
    NERtcLiveStreamUserTranscoding *users;
    NERtcLiveStreamImageInfo* bg_image;
};
 
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 extraInfo [kNERtcMacSEIBufferLength]; 
};
 
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;
 
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;  
};
 
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_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; 
};
 
struct NERtcAudioSendStats
{
    int num_channels;       
    int sent_sample_rate;   
    int sent_bitrate;       
    int audio_loss_rate;    
    int64_t rtt;            
    unsigned int volume;    
};
 
struct NERtcAudioRecvStats
{
    uid_t uid;             
    int received_bitrate;  
    int total_frozen_time; 
    int frozen_rate;       
    int audio_loss_rate;   
    unsigned int volume;   
};
 
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 {
    kScreenCaptureStatusStart = 1,  
    kScreenCaptureStatusPause = 2,  
    kScreenCaptureStatusResume = 3, 
    kScreenCaptureStatusStop = 4,   
    kScreenCaptureStatusCovered = 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;   
};
 
struct NERtcVideoCanvas
{
    onFrameDataCallback cb;
    void *user_data;
    void *window;
    NERtcVideoScalingMode scaling_mode;
};
 
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 = kNERtcRawAudioFrameOpModeReadWrite; 
};
 
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;              
};
 
class INERtcAudioFrameObserver
{
public:
    virtual ~INERtcAudioFrameObserver() {}
    virtual void onAudioFrameDidRecord(NERtcAudioFrame *frame) = 0;
    virtual void onAudioFrameWillPlayback(NERtcAudioFrame *frame) = 0;
    virtual void onMixedAudioFrame(NERtcAudioFrame * frame) = 0;
    virtual void onPlaybackAudioFrameBeforeMixing(uint64_t userID, NERtcAudioFrame * frame) = 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;               
};
 
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;
};
 
struct NERtcCreateAudioEffectOption
{
    char path[kNERtcMaxURILength];
    int loop_count;
    bool send_enabled;
    uint32_t send_volume;
    bool playback_enabled;
    uint32_t playback_volume;
};
 
typedef enum {
    kNERTCVideoStreamMain = 0,  
    kNERTCVideoStreamSub = 1,   
    kNERTCVideoStreamCount,     
} NERtcVideoStreamType;
 
struct NERtcTextWatermarkConfig {
 
    char content[kNERtcMaxBuffLength];
    char font_path[kNERtcMaxURILength]; 
    int font_size;                      
    int font_color;                     
    int offset_x;                       
    int offset_y;                       
    int wm_color;                       
    int wm_width;                       
    int wm_height;                      
};
 
struct NERtcTimestampWatermarkConfig {
    char font_path[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;                        
};
 
typedef enum {
    kNERtcChannelMediaRelayStateIdle        = 0,
    kNERtcChannelMediaRelayStateConnecting  = 1,
    kNERtcChannelMediaRelayStateRunning     = 2,
    kNERtcChannelMediaRelayStateFailure     = 3,
} NERtcChannelMediaRelayState;
 
typedef enum {
    /* Current media stream relay gets disconnected. */
    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;                         
};
 
struct NERtcImageWatermarkConfig {
    char image_paths[10][kNERtcMaxURILength];   
    int offset_x;           
    int offset_y;           
    int image_width;        
    int image_height;       
    int fps;                
    bool loop;              
};
 
struct NERtcCanvasWatermarkConfig {
    NERtcImageWatermarkConfig* image_watermarks;        
    int image_count_;                                   
    NERtcTextWatermarkConfig* text_watermarks;          
    int text_count_;                                    
    NERtcTimestampWatermarkConfig* timestamp_watermark; 
};
 
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 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;                              
};
 
typedef enum {
    kNERtcAudioRecordingQualityLow = 0,         
    kNERtcAudioRecordingQualityMedium = 1,      
    kNERtcAudioRecordingQualityHigh = 2,        
} NERtcAudioRecordingQuality;
 
typedef enum {
    kNERtcAudioRecordErrorSuffix = 1,           
    kNERtcAudioRecordOpenFileFailed = 2,        
    kNERtcAudioRecordStart = 3,                 
    kNERtcAudioRecordError = 4,                 
    kNERtcAudioRecordFinish = 5,                
} NERtcAudioRecordingCode;
 
typedef enum {
    kNERtcStreamFallbackDisabled = 0,
 
    kNERtcStreamFallbackVideoStreamLow = 1,
 
    kNERtcStreamFallbackAudioOnly = 2,
} RTCStreamFallbackOption;
 
typedef enum {
    kNERtcGMCryptoSM4ECB= 0,
} NERtcEncryptionMode;
 
struct NERtcEncryptionConfig {
    NERtcEncryptionMode mode ;                              
    char                key[kNERtcEncryptByteLength];       
};
 
typedef enum {
    kNERtcTransportTypeNoneProxy = 0,    
    kNERtcTransportTypeUDPProxy  = 1,                       
} NERtcTransportType;
 
#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 kNERtcKeyEnableReportVolumeWhenMute "enable_report_volume_when_mute" 
}// namespace "nertc
 
#endif