nerecord_engine.h

Go to the documentation of this file.

 
#ifndef NERECORD_ENGINE_H
#define NERECORD_ENGINE_H
 
#include "nerecord_base.h"
#include "nerecord_base_types.h"
#include "nerecord_engine_defines.h"
#include "nerecord_engine_event_handler.h"
 
namespace nerecord
{
 
    enum SubscribeMode
    {
        ANTI_SPAM_MODE,     
        RECORDER_MODE       
    };
 
struct NERecordEngineContext
{
    const char *app_key;        
    IRecordEngineEventHandler *event_handler;   
    const char *log_dir_path;   
    uint32_t log_file_max_size_KBytes; 
    const char *record_file_root_dir; 
    NERtcRecordFileDirMode record_file_dir_mode; 
    NERtcLogLevel log_level;    
    const char *nerecord_absolute_dir; 
    const char *parameters; 
    SubscribeMode submode;  
    bool audio_enable;          
    bool video_enable;          
    bool video_substream_split;          
    bool mixing_enable;         
    bool mixed_audio_video; 
    bool mixed_audio_substream; 
    bool snapshot_enable; 
    unsigned snapshot_interval; 
    NERtcAudioFormatType decodeAudio; 
    NERtcVideoFormatType decodeVideo; 
    bool auto_subscribe_audio;
    bool auto_subscribe_video;
    bool keep_last_frame;     
    NERtcRemoteVideoStreamType default_stream_type; 
    NERtcAudioProfileType audioProfile; 
    NERtcVideoRecordResolution video_record_resolution; 
    VideoLayout *video_with_substream_layout;  
    bool mixing_param_split; 
    NERtcAudioProfileType mixing_audioProfile; 
    NERtcVideoRecordResolution mixing_video_record_resolution; 
    NERtcServerAddresses *server_config;   
    NERtcAgentAddresses *agent_config;    
    NERecordEngineContext()
    {
        app_key = nullptr;
        event_handler = nullptr;
        log_dir_path = nullptr;
        log_file_max_size_KBytes = 200 * 1024;
        nerecord_absolute_dir = nullptr;
        record_file_root_dir = nullptr;
        record_file_dir_mode = kNERtcRecordFileDirModeDefault;
        log_level = kNERtcLogLevelInfo;
        parameters = nullptr;
        submode = ANTI_SPAM_MODE;
        audio_enable = true;
        video_enable = true;
        video_substream_split = false;
        mixing_enable = false;
        mixed_audio_video = true;
        mixed_audio_substream = true;
        auto_subscribe_audio = true;
        auto_subscribe_video = true;
        decodeAudio = kNERtcAudioFormatDefault;
        decodeVideo = kNERtcVideoFormatDefault;
        snapshot_enable = true;
        snapshot_interval = 5;
        audioProfile = kNERtcAudioProfileDefault;
        default_stream_type = kNERtcRemoteVideoStreamTypeHigh;
        video_with_substream_layout = NULL;
        mixing_param_split = false;
        keep_last_frame = false;
        server_config = NULL;
    }
};
 
class IRecordEngine
{
public:
    virtual ~IRecordEngine() {}
 
    virtual int initialize(const NERecordEngineContext& context) = 0;
 
    virtual void release() = 0;
 
    // virtual int initChannel(const char* channel_name) = 0;
 
    virtual int joinChannel(const char* token, const char* channel_name, uid_t uid) = 0;
    virtual int leaveChannel() = 0;
 
    virtual int subscribeRemoteAudioStream(uid_t uid, bool subscribe) = 0;
 
    virtual int subscribeRemoteVideoStream(uid_t uid, NERtcRemoteVideoStreamType stream_type, bool subscribe) = 0;
 
    virtual int subscribeRemoteVideoSubStream(uid_t uid, bool subscribe)  = 0;
 
    virtual int setVideoMixingLayout(const VideoMixingLayout &layout) = 0;
 
    virtual int startMixingRecord() = 0;
 
    virtual void stopMixingRecord() = 0;
 
    virtual int updateSubscribeAudioUids(uid_t *uids, uint32_t num) = 0;
 
    virtual int updateSubscribeVideoUids(uid_t *uids, uint32_t num) = 0;
 
    virtual void startService() = 0;
 
    virtual void stopService() = 0;
 
    virtual void updateWatermarkConfigs(uint32_t wm_num, const WatermarkConfig *configs) = 0;
 
    virtual void updateWatermarkConfigs(uid_t uid, bool substream, uint32_t wm_num, const WatermarkConfig *configs) = 0;
 
    virtual int enableAudioVolumeIndication(bool enable, uint64_t interval) = 0;
 
    virtual int setUserBackground(uid_t uid, const char *image) = 0;
 
 
    virtual int enableEncryption(bool enable, const NERecordEncryptionConfig &config) = 0;
 
    virtual const NERtcRecordingEngineProperties *getProperties() = 0;
};
 
} //namespace nerecord
 
 
 
 
NERECORD_API nerecord::IRecordEngine* NERECORD_CALL createNERecordEngine();
 
NERECORD_API void NERECORD_CALL destroyNERecordEngine(void *& nerecord_engine_inst);
 
 
 
#endif