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 kNERtcMaxChannelNameLength   64      
#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];
 
    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;
 
    NERtcLiveStreamImageInfo() : x(0), y(0), width(0), height(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;
 
    NERtcLiveStreamLayout() : width(0), height(0), background_color(0), user_count(0), users(NULL), bg_image(NULL) {}
};
 
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;
 
    NERtcLiveConfig()
        : single_video_passthrough(false)
        , audio_bitrate(0)
        , sampleRate(kNERtcLiveStreamAudioSampleRate48000)
        , channels(2)
        , audioCodecProfile(kNERtcLiveStreamAudioCodecProfileLCAAC) {}
};
 
struct NERtcLiveStreamTaskInfo {
    char task_id[kNERtcMaxTaskIDLength];
    char stream_url[kNERtcMaxURILength];
    bool server_record_enabled;
    NERtcLiveStreamMode ls_mode;
    NERtcLiveStreamLayout layout;
    NERtcLiveConfig config;
    char extraInfo [kNERtcMacSEIBufferLength]; 
 
    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;
 
typedef enum {
  kNERtcCameraOutputDefault     = 0,
  kNERtcCameraOutputQuality     = 1,
  kNERtcCameraOutputManual      = 2,
} NERtcCameraPreference;
 
struct NERtcCameraCaptureConfig
{
  NERtcCameraPreference preference;
  int captureWidth;
  int captureHeight;
 
  NERtcCameraCaptureConfig() : preference(kNERtcCameraOutputDefault), captureWidth(0), captureHeight(0) {}
};
 
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_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; 
};
 
struct NERtcAudioSendStats
{
    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 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;
 
    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 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;   
 
    NERtcScreenCaptureParameters()
        : profile(kNERtcScreenProfileHD1080P)
        , frame_rate(5)
        , 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;
 
    NERtcVideoCanvas() : user_data(NULL), window(NULL), scaling_mode(kNERtcVideoScaleFit) {}
};
 
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;              
 
    NERtcAudioFrame() : data(NULL) {}
};
 
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;
 
    virtual void onPlaybackAudioFrameBeforeMixing(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 
{
    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;
 
    NERtcCreateAudioMixingOption()
        : loop_count(1)
        , send_enabled(true)
        , send_volume(100)
        , playback_enabled(true)
        , playback_volume(100) {
        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;
 
    NERtcCreateAudioEffectOption()
        : loop_count(1)
        , send_enabled(true)
        , send_volume(100)
        , playback_enabled(true)
        , playback_volume(100) {
        memset(path, 0, sizeof(path));
    }
};
 
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;                      
 
    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_path, 0, sizeof(font_path));
    }
};
 
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;                        
 
    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_path, 0, sizeof(font_path));
    }
};
 
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) {}
};
 
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;                              
 
    NERtcServerAddresses() : use_ipv6(false) {
        memset(channel_server, 0, sizeof(channel_server));
        memset(statistics_server, 0, sizeof(statistics_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;
 
#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"
 
} // namespace nertc
 
#endif