nerecord_engine_defines.h

Go to the documentation of this file.

 
#ifndef NERECORD_ENGINE_DEFINES_H
#define NERECORD_ENGINE_DEFINES_H
 
#include "nerecord_base_types.h"
#include <string>
#include <cstring>
 
#define kNERtcMaxPlaneCount         4       
#define kNERtcMaxDeviceIDLength     256     
#define kNERtcMaxDeviceNameLength   256     
#define kNERtcMaxURILength          256     
#define kNERtcMaxTaskIDLength       64      
#define kNERtcMaxBuffLength         1024    
#ifndef NULL
#define NULL nullptr
#endif
 
namespace nerecord
{
 
typedef uint64_t uid_t; 
typedef uint64_t channel_id_t;  
typedef enum
{
    kNERtcSessionLeaveNormal = 0,       
    kNERtcSessionLeaveForFailOver = 1,  
    kNERtcSessionLeaveUpdate = 2,       
    kNERtcSessionLeaveForKick = 3,      
    kNERtcSessionLeaveTimeOut = 4,      
} NERtcSessionLeaveReason;
 
typedef enum
{
    kNERtcConnectionStateDisconnected = 1,      
    kNERtcConnectionStateConnecting = 2,        
    kNERtcConnectionStateConnected = 3,         
    kNERtcConnectionStateReconnecting = 4,      
    kNERtcConnectionStateFailed = 5,            
} NERtcConnectionStateType;
 
struct NERtcAudioVolumeInfo
{
    uid_t uid;              
    unsigned int volume;    
};
 
typedef enum
{
    kNERtcVideoProfileLowest = 0,       
    kNERtcVideoProfileLow = 1,          
    kNERtcVideoProfileStandard = 2,     
    kNERtcVideoProfileHD720P = 3,       
    kNERtcVideoProfileHD1080P = 4,      
    kNERtcVideoProfileNone = 5,      
    kNERtcVideoProfileMAX = kNERtcVideoProfileHD1080P,      
} NERtcVideoProfileType;
 
 
typedef enum {
    kNERtcRemoteVideoStreamTypeHigh     = 0, 
    kNERtcRemoteVideoStreamTypeLow      = 1, 
    kNERtcRemoteVideoStreamTypeNone     = 2, 
} NERtcRemoteVideoStreamType;
 
typedef enum {
    kNERTCVideoStreamMain = 0,
    kNERTCVideoStreamSub = 1,
 
} NERtcVideoStreamType;
 
typedef enum
{
    kNERtcAudioTypePCM16 = 0,    
} NERtcAudioType;
 
typedef enum
{
    kNERtcAudioFormatDefault = 0,                           
    kNERtcAudioFormatAAC = kNERtcAudioFormatDefault, 
    kNERtcAudioFormatPCM 
} NERtcAudioFormatType;
 
typedef enum
{
    kNERtcVideoFormatDefault = 0, 
    kNERtcVideoFormatH264 = kNERtcVideoFormatDefault, 
    kNERtcVideoFormatYUV 
} NERtcVideoFormatType;
 
struct NERtcAudioFormat
{
    NERtcAudioType type;        
    uint32_t     channels;      
    uint32_t     sample_rate;    
    uint32_t     bytes_per_sample;    
    uint32_t     samples_per_channel;    
    uint64_t     timestamp;             
};
 
struct NERtcAudioFrame
{
    NERtcAudioFormat format;    
    void *data;     
};
 
 
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;                       
    uint32_t width;                              
    uint32_t height;                             
    uint32_t count;                              
    uint32_t *offset;                            
    uint32_t *stride;                            
    NERtcVideoRotation rotation;                 
    uint64_t timestamp;                 
    void* buffer;                                
};
 
 
enum NERtcAudioProfileType
{
    kNERtcAudioProfileDefault,      
    kNERtcAudioProfileHight,     
    kNERtcAudioProfileStero,     
};
 
enum NERtcRenderMode
{
    kNERtcRenderModeHidden, 
    kNERtcRenderModeFit 
};
 
 
struct NERtcBackground
{
    int border; 
    char color[32];   
    double alpha;   
};
 
struct NERtcRegion
{
    uid_t uid;              
    bool substream;              
    double x;               
    double y;               
    double width;      
    double height;     
    double alpha;       
    NERtcRenderMode renderMode;    
    NERtcRegion()
    {
        substream = false;
    }
};
 
 
enum NERtcWatermarkType
{
    kNERtcWatermarkTypeLitera,      
    kNERtcWatermarkTypeTimestamp, 
    kNERtcWatermarkTypeImage                
};
 
 
struct NERtcLiteraWatermarkConfig
{
    const char *wm_litera;      
    const char  *font_file_path;       
    uint32_t    font_size;       
    uint32_t    offset_x;      
    uint32_t    offset_y;      
    NERtcBackground background;       
};
 
struct NERtcTimestampWatermarkConfig
{
    const char *font_file_path;       
    uint32_t    font_size;      
    uint32_t    offset_x;      
    uint32_t    offset_y;     
    NERtcBackground background;       
};
 
struct NERtcImageWatermarkConfig
{
    const char *image_path;      
    uint32_t    offset_x;      
    uint32_t    offset_y;     
    uint32_t    wm_width;       
    uint32_t    wm_height;      
};
 
 
union NERtcWatermarkConfigUnion
{
    NERtcLiteraWatermarkConfig litera;       
    NERtcTimestampWatermarkConfig timestamp;       
    NERtcImageWatermarkConfig image;       
};
 
 
struct WatermarkConfig
{
    NERtcWatermarkType   type;       
    NERtcWatermarkConfigUnion config;       
};
 
 
enum NERtcLayoutType
{
    kNERtcLayoutGrid,                
    kNERtcLayoutCustom,      
};
 
struct NERtcVideoRecordResolution
{
    int vanvasWidth;        
    int vanvasHeight;       
    int fps;       
    int bps;       
    NERtcVideoRecordResolution()
    : vanvasWidth(360)
    , vanvasHeight(640)
    , fps(15)
    , bps(400000)
    { }
};
 
 
struct VideoLayout
{
    NERtcLayoutType layout; 
    const char *backgroundColor;    
    uint32_t regionCount;   
    NERtcRegion *regions;        
    const char *appData;    
    int appDataLength;      
    uint32_t wm_num;        
    WatermarkConfig *wm_configs; 
    VideoLayout()
    : layout(kNERtcLayoutGrid)
    ,  backgroundColor(NULL)
    , regionCount(0)
    , regions(NULL)
    , appData(NULL)
    , appDataLength(0)
    , wm_num(0)
    , wm_configs(NULL)
    {}
};
 
typedef VideoLayout VideoMixingLayout;
 
 
typedef enum {
    kNERtcLogLevelFatal    = 0,        
    kNERtcLogLevelError    = 1,        
    kNERtcLogLevelWarning  = 2,        
    kNERtcLogLevelInfo     = 3,        
    kNERtcLogLevelDetailInfo   = 4,    
    kNERtcLogLevelVerbos   = 5,        
    kNERtcLogLevelDebug    = 6,        
    kNERtcLogLevelOff      = 7,        
} NERtcLogLevel;
 
struct NERtcStats
{
    uint32_t cpu_app_usage;     
    uint32_t cpu_idle_usage;    
    uint32_t cpu_total_usage;   
    uint32_t memory_app_usage;  
    uint32_t memory_total_usage;
    uint32_t memory_app_kbytes; 
    int total_duration;         
    uint64_t tx_bytes;          
    uint64_t rx_bytes;          
    uint64_t tx_audio_bytes;    
    uint64_t tx_video_bytes;    
    uint64_t rx_audio_bytes;    
    uint64_t rx_video_bytes;    
    int tx_audio_kbitrate;      
    int rx_audio_kbitrate;      
    int tx_video_kbitrate;      
    int rx_video_kbitrate;      
    int up_rtt;                 
    int down_rtt;               
    int tx_audio_packet_loss_rate;  
    int tx_video_packet_loss_rate;  
    int tx_audio_packet_loss_sum;   
    int tx_video_packet_loss_sum;   
    int tx_audio_jitter;            
    int tx_video_jitter;            
    int rx_audio_packet_loss_rate;  
    int rx_video_packet_loss_rate;  
    int rx_audio_packet_loss_sum;   
    int rx_video_packet_loss_sum;   
    int rx_audio_jitter;            
    int rx_video_jitter;            
};
 
struct NERtcVideoLayerSendStats {
    int layer_type; 
    int width; 
    int height; 
    int capture_width; 
    int capture_height; 
    int capture_frame_rate; 
    int render_frame_rate; 
    int encoder_frame_rate; 
    int sent_frame_rate; 
    int sent_bitrate; 
    int target_bitrate; 
    int encoder_bitrate; 
    char codec_name[kNERtcMaxDeviceNameLength]; 
    bool drop_bandwidth_strategy_enabled; 
};
struct NERtcVideoSendStats
{
    NERtcVideoLayerSendStats* video_layers_list; 
    int video_layers_count; 
};
 
struct NERtcVideoLayerRecvStats
{
    int layer_type; 
    int width; 
    int height; 
    int received_bitrate; 
    int received_frame_rate; 
    int decoder_frame_rate; 
    int render_frame_rate; 
    int packet_loss_rate; 
    int total_frozen_time; 
    int frozen_rate; 
    char codec_name[kNERtcMaxDeviceNameLength]; 
    int peer_to_peer_delay; 
};
 
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; 
    int av_timestamp_diff; 
    int peer_to_peer_delay; 
};
struct NERtcAudioRecvStats
{
    uid_t uid; 
    NERtcAudioLayerRecvStats* audio_layers_list; 
    int audio_layers_count; 
};
 
 
struct NERtcRecordingEngineProperties
{
    const char *storage_dir; 
};
 
enum NERtcRecordFileDirMode
{
    kNERtcRecordFileDirModeDefault,  
    kNERtcRecordFileDirModeCustom  
};
 
struct NERtcServerAddresses {
    char channel_server[kNERtcMaxURILength]; 
    char record_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(record_channel_server, 0, sizeof(record_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));
    }
};
 
struct NERtcAgentAddresses {
    char signal_server[kNERtcMaxURILength];    
    char relay_server[kNERtcMaxURILength]; 
};
 
#define kNERecordEncryptByteLength 128
#define kNERecordCustomInfoLength 128
 
typedef enum {
    kNERecordGMCryptoSM4ECB = 0,
    NERecordEncryptionModeCustom,
} NERecordEncryptionMode;
 
struct NERecordMediaPacket {
  // 需要发送或接收的数据的缓存地址
  const unsigned char* buffer;
  // 需要发送或接收的数据的缓存大小
  long size;
};
 
class INERecordPacketObserver {
 public:
  virtual ~INERecordPacketObserver() {}
 
  virtual bool onSendAudioPacket(NERecordMediaPacket& packet) = 0;
  virtual bool onSendVideoPacket(NERecordMediaPacket& packet) = 0;
  virtual bool onReceiveAudioPacket(NERecordMediaPacket& packet) = 0;
  virtual bool onReceiveVideoPacket(NERecordMediaPacket& packet) = 0;
};
 
struct NERecordEncryptionConfig {
    NERecordEncryptionMode mode;
    char key[kNERecordEncryptByteLength];
    INERecordPacketObserver* observer = nullptr;
 
    void reInit(){
        mode = kNERecordGMCryptoSM4ECB;
        memset(key, 0, sizeof(key));
    }
 
    NERecordEncryptionConfig() : mode(kNERecordGMCryptoSM4ECB) { memset(key, 0, sizeof(key)); }
};
 
#define kNERtcKeyAutoSubscribeAudio         "auto_subscribe_audio"         
#define kNERtcKeyVideoSubscribeAudio        "auto_subscribe_vedio"         
} // namespace nerecord
 
#endif