nertc_engine_defines.h

Go to the documentation of this file.

#ifndef NERTC_ENGINE_DEFINES_H
#define NERTC_ENGINE_DEFINES_H

#include "nertc_base_types.h"

#define kNERtcMaxPlaneCount         4       
#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 enum
{
    kNERtcIIDAudioDeviceManager = 1,                
    kNERtcIIDVideoDeviceManager = 2,                
} NERtcInterfaceIdType;

typedef enum {
    kNERtcClientRoleBroadcaster     = 0,            
    kNERtcClientRoleAudience        = 1,            
}NERtcClientRole;

typedef enum 
{
    kNERtcChannelProfileCommunication       = 0,    
    kNERtcChannelProfileLiveBroadcasting    = 1,    
} NERtcChannelProfileType;

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
{
    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, 
} 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;
};

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;

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;                  
    void* 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 {
    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;

typedef enum {
    kNERtcStreamChannelTypeMainStream   = 0, 
    kNERtcStreamChannelTypeSubStream    = 1, 
} NERtcStreamChannelType;

#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 kNERtcKeyTest1v1                    "test_1v1"                  
} // namespace nertc

#endif