nertc_engine_ex.h

浏览该文件的文档.

 
#ifndef NERTC_ENGINE_EX_H
#define NERTC_ENGINE_EX_H
 
#include "nertc_base.h"
#include "nertc_base_types.h"
#include "nertc_engine_defines.h"
#include "nertc_engine_event_handler.h"
#include "nertc_engine_media_stats_observer.h"
#include "nertc_engine.h"
#include "nertc_channel.h"
#include "nertc_engine_video_encoder_qos_observer.h"
#include "nertc_engine_predecode_observer.h"

namespace nertc
{

class IRtcEngineEx : public IRtcEngine
{
public:
    virtual ~IRtcEngineEx() {}

    virtual IRtcChannel* createChannel(const char* channel_name) = 0;

    virtual NERtcConnectionStateType getConnectionState() = 0;

    virtual int muteLocalAudioStream(bool mute) = 0;

    virtual int enableLocalSubStreamAudio(bool enabled) = 0;

    virtual int muteLocalSubStreamAudio(bool mute) = 0;

    virtual int setAudioProfile(NERtcAudioProfileType profile, NERtcAudioScenarioType scenario) = 0;

    virtual int setAudioProfile(NERtcAudioProfileType profile) = 0;

    virtual int setAudioScenario(NERtcAudioScenarioType scenario) = 0;

    virtual int setAudioEffectPreset(NERtcVoiceChangerType type) = 0;

    virtual int setVoiceBeautifierPreset(NERtcVoiceBeautifierType type) = 0;

    virtual int setLocalVoicePitch(double pitch) = 0;

    virtual int setLocalVoiceEqualization(NERtcVoiceEqualizationBand band_frequency, int band_gain) = 0;
  
    virtual int setAINSMode(NERtcAudioAINSMode mode) = 0;

    virtual int subscribeRemoteAudioStream(uid_t uid, bool subscribe) = 0;

    virtual int subscribeRemoteSubStreamAudio(uid_t uid, bool subscribe) = 0;

    virtual int subscribeAllRemoteAudioStream(bool subscribe) = 0;
   
    virtual int setAudioSubscribeOnlyBy(uid_t* uid_array, uint32_t size) = 0;

    virtual int setSubscribeAudioAllowlist(uid_t* uid_array, uint32_t size) = 0;

    virtual int setSubscribeAudioBlocklist(NERtcAudioStreamType type, uid_t* uid_array, uint32_t size) = 0;

    virtual void setStreamAlignmentProperty(bool enable) = 0;

    virtual int64_t getNtpTimeOffset() = 0;

    virtual int setCameraCaptureConfig(const NERtcCameraCaptureConfig& config) = 0;

    virtual int setCameraCaptureConfig(NERtcVideoStreamType type, const NERtcCameraCaptureConfig& config) = 0;

    virtual int setVideoConfig(const NERtcVideoConfig& config) = 0;

    virtual int setVideoConfig(NERtcVideoStreamType type, const NERtcVideoConfig& config) = 0;

    virtual int enableDualStreamMode(bool enable) = 0;

    virtual int setVideoStreamLayerCount(NERtcVideoStreamLayerCount layer_count) = 0;
    virtual int setupLocalSubStreamVideoCanvas(NERtcVideoCanvas* canvas) = 0;
  
    virtual int setupLocalVideoStreamCanvas(NERtcVideoCanvas* canvas, NERtcVideoStreamType stream_type) = 0;

    virtual int setLocalSubStreamRenderMode(NERtcVideoScalingMode scaling_mode) = 0;

    virtual int setLocalRenderMode(NERtcVideoScalingMode scaling_mode) = 0;

    virtual int setLocalRenderMode(NERtcVideoScalingMode scaling_mode, NERtcVideoStreamType stream_type) = 0;
    
    virtual int setLocalVideoMirrorMode(NERtcVideoMirrorMode mirror_mode) = 0;

    virtual int setLocalVideoMirrorMode(NERtcVideoStreamType type, NERtcVideoMirrorMode mirror_mode) = 0;

    virtual int setRemoteRenderMode(uid_t uid, NERtcVideoScalingMode scaling_mode) = 0;

    virtual int setRemoteRenderMode(uid_t uid, NERtcVideoScalingMode scaling_mode, NERtcVideoStreamType stream_type) = 0;

    virtual int setupRemoteSubStreamVideoCanvas(uid_t uid, NERtcVideoCanvas* canvas) = 0;
  
    virtual int setupRemoteVideoStreamCanvas(uid_t uid, NERtcVideoCanvas* canvas, NERtcVideoStreamType stream_type) = 0;

    virtual int subscribeRemoteVideoSubStream(uid_t uid, bool subscribe) = 0;

    virtual int setRemoteSubSteamRenderMode(uid_t uid, NERtcVideoScalingMode scaling_mode) = 0;

    virtual int startVideoPreview() = 0;

    virtual int startVideoPreview(NERtcVideoStreamType type) = 0;

    virtual int stopVideoPreview() = 0;

    virtual int stopVideoPreview(NERtcVideoStreamType type) = 0;

    virtual int muteLocalVideoStream(bool mute) = 0;

    virtual int muteLocalVideoStream(NERtcVideoStreamType type, bool mute) = 0;

    virtual int setLocalMediaPriority(NERtcMediaPriorityType priority, bool is_preemptive) = 0;

    virtual int setParameters(const char* parameters) = 0;
  
    virtual const char* getParameters(const char* parameters, const char* extra_info) = 0;

    virtual int setRecordingAudioFrameParameters(NERtcAudioFrameRequestFormat *format) = 0;

    virtual int setPlaybackAudioFrameParameters(NERtcAudioFrameRequestFormat *format) = 0;
    
    virtual int setPlaybackAudioFrameBeforeMixingParameters(NERtcAudioFrameRequestFormat *format) = 0;

    virtual int setMixedAudioFrameParameters(int sample_rate) = 0;

    virtual int setAudioFrameObserver(INERtcAudioFrameObserver *observer) = 0;

    virtual int startAudioDump() = 0;
    
    virtual int startAudioDump(NERtcAudioDumpType type) = 0;

    virtual int stopAudioDump() = 0;

    virtual int setVideoDump(NERtcVideoDumpType type) = 0;

    virtual int startAudioMixing(NERtcCreateAudioMixingOption *option) = 0;

    virtual int stopAudioMixing() = 0;

    virtual int pauseAudioMixing() = 0;

    virtual int resumeAudioMixing() = 0;

    virtual int setAudioMixingSendVolume(uint32_t volume) = 0;

    virtual int getAudioMixingSendVolume(uint32_t *volume) = 0;

    virtual int setAudioMixingPlaybackVolume(uint32_t volume) = 0;

    virtual int getAudioMixingPlaybackVolume(uint32_t *volume) = 0;

    virtual int getAudioMixingDuration(uint64_t *duration) = 0;

    virtual int getAudioMixingCurrentPosition(uint64_t *position) = 0;

    virtual int setAudioMixingPosition(uint64_t seek_position) = 0;

    virtual int playEffect(uint32_t effect_id, NERtcCreateAudioEffectOption *option) = 0;

    virtual int stopEffect(uint32_t effect_id) = 0;

    virtual int stopAllEffects() = 0;

    virtual int pauseEffect(uint32_t effect_id) = 0;

    virtual int resumeEffect(uint32_t effect_id) = 0;

    virtual int pauseAllEffects() = 0;

    virtual int resumeAllEffects() = 0;

    virtual int setEffectSendVolume(uint32_t effect_id, uint32_t volume) = 0;
    virtual int getEffectSendVolume(uint32_t effect_id, uint32_t *volume) = 0;

    virtual int setEffectPlaybackVolume(uint32_t effect_id, uint32_t volume) = 0;

    virtual int getEffectPlaybackVolume(uint32_t effect_id, uint32_t *volume) = 0;

    virtual int setAudioMixingPitch(int32_t pitch) = 0;

    virtual int getAudioMixingPitch(int32_t* pitch) = 0;

    virtual int setEffectPitch(uint32_t effect_id, int32_t pitch) = 0;

    virtual int getEffectPitch(uint32_t effect_id, int32_t* pitch) = 0;

    virtual int enableLoopbackRecording(bool enabled, const char *device_name) = 0;

    virtual int adjustLoopbackRecordingSignalVolume(int volume) = 0;

    virtual int enableEarback(bool enabled, uint32_t volume) = 0;

    virtual int setEarbackVolume(uint32_t volume) = 0;

    virtual int setStatsObserver(IRtcMediaStatsObserver *observer) = 0;
 

    virtual int setVideoEncoderQosObserver(INERtcVideoEncoderQosObserver *observer) = 0;

    virtual int setPreDecodeObserver(INERtcPreDecodeObserver *observer) = 0;

    virtual int enableAudioVolumeIndication(bool enable, uint64_t interval) = 0;
    
    virtual int enableAudioVolumeIndication(bool enable, uint64_t interval, bool enable_vad) = 0;

    virtual IScreenCaptureSourceList* getScreenCaptureSources(const NERtcSize& thumbSize, const NERtcSize& iconSize, const bool includeScreen) = 0;

    virtual int startScreenCaptureByScreenRect(const NERtcRectangle& screen_rect, const NERtcRectangle& region_rect, const NERtcScreenCaptureParameters& capture_params) = 0;

    virtual int startScreenCaptureByDisplayId(source_id_t display_id, const NERtcRectangle& region_rect, const NERtcScreenCaptureParameters& capture_params) = 0;

    virtual int startScreenCaptureByWindowId(source_id_t window_id, const NERtcRectangle& region_rect, const NERtcScreenCaptureParameters& capture_params) = 0;

    virtual int32_t setScreenCaptureSource(const NERtcScreenCaptureSourceInfo& source, const NERtcRectangle& region_rect, const NERtcScreenCaptureParameters& capture_params) = 0;

    virtual int updateScreenCaptureRegion(const NERtcRectangle& region_rect) = 0;

    virtual int setScreenCaptureMouseCursor(bool capture_cursor) = 0;

    virtual int stopScreenCapture() = 0;

    virtual int pauseScreenCapture() = 0;

    virtual int resumeScreenCapture() = 0;
 

    virtual int setExcludeWindowList(source_id_t* window_list, int count) = 0;

    virtual int updateScreenCaptureParameters(const nertc::NERtcScreenCaptureParameters &captureParams) = 0;

    virtual int setExternalVideoSource(bool enabled) = 0;

    virtual int setExternalVideoSource(NERtcVideoStreamType type, bool enabled) = 0;

    virtual int pushExternalVideoFrame(NERtcVideoFrame* frame) = 0;

    virtual int pushExternalVideoFrame(NERtcVideoStreamType type, NERtcVideoFrame* frame) = 0;

    virtual int pushExternalVideoEncodedFrame(NERtcVideoStreamType type, NERtcVideoEncodedFrame* encoded_frame) = 0;

    virtual int setExternalAudioSource(bool enabled, int sample_rate, int channels) = 0;

    virtual int pushExternalAudioFrame(NERtcAudioFrame* frame) = 0;

    virtual int pushExternalAudioEncodedFrame(NERtcAudioEncodedFrame* encoded_frame) = 0;

    virtual int setExternalSubStreamAudioSource(bool enabled, int sample_rate, int channels) = 0;

    virtual int pushExternalSubStreamAudioFrame(NERtcAudioFrame* frame) = 0;

    virtual int pushExternalSubStreamAudioEncodedFrame(NERtcAudioEncodedFrame* encoded_frame) = 0;

    virtual int setExternalAudioRender(bool enabled, int sample_rate, int channels) = 0;

    virtual int pullExternalAudioFrame(void* data, int len) = 0;

    virtual const char* getVersion(int* build) = 0;

    virtual const char* getErrorDescription(int error_code) = 0;

    virtual void uploadSdkInfo() = 0;

    virtual int addLiveStreamTask(const NERtcLiveStreamTaskInfo& info) = 0;

    virtual int updateLiveStreamTask(const NERtcLiveStreamTaskInfo& info) = 0;

    virtual int removeLiveStreamTask(const char* task_id) = 0;

    virtual int sendSEIMsg(const char* data, int length, NERtcVideoStreamType type) = 0;

    virtual int sendSEIMsg(const char* data, int length) = 0;

    virtual int setLocalVideoWatermarkConfigs(bool enabled, NERtcVideoStreamType type, NERtcVideoWatermarkConfig& config) = 0;

    virtual int takeLocalSnapshot(NERtcVideoStreamType stream_type, NERtcTakeSnapshotCallback* callback) = 0;

    virtual int takeRemoteSnapshot(uid_t uid, NERtcVideoStreamType stream_type, NERtcTakeSnapshotCallback* callback) = 0;

    virtual int addRemoteVideoFrameObserver(INERtcRemoteVideoFrameObserver* observer) = 0;

    virtual int startAudioRecording(const char* file_path, int sample_rate, NERtcAudioRecordingQuality quality) = 0;

    virtual int startAudioRecordingWithConfig(const NERtcAudioRecordingConfiguration& config) = 0;

    virtual int stopAudioRecording() = 0;

    virtual int adjustUserPlaybackSignalVolume(uid_t uid, int volume) = 0;

    virtual int adjustChannelPlaybackSignalVolume(uint32_t volume) = 0;
    
    virtual int startChannelMediaRelay(NERtcChannelMediaRelayConfiguration *config) = 0;

    virtual int updateChannelMediaRelay(NERtcChannelMediaRelayConfiguration *config) = 0;

    virtual int stopChannelMediaRelay() = 0;

    virtual int pauseAllMediaRelay() = 0;

    virtual int resumeAllMediaRelay() = 0;

    virtual int setLocalPublishFallbackOption(NERtcStreamFallbackOption option) = 0;

    virtual int setRemoteSubscribeFallbackOption(NERtcStreamFallbackOption option) = 0;

    virtual int enableSuperResolution(bool enable) = 0;

    virtual int enableEncryption(bool enable, NERtcEncryptionConfig config) = 0;

    virtual int startLastmileProbeTest(const NERtcLastmileProbeConfig& config) = 0;

    virtual int stopLastmileProbeTest() = 0;

    virtual int setRemoteHighPriorityAudioStream(bool enabled, uid_t uid) = 0;

    virtual int setRemoteHighPriorityAudioStream(bool enabled, uid_t uid, NERtcAudioStreamType stream_type) = 0;

    virtual int clearRemoteHighPriorityAudioStream() = 0;

    virtual int checkNECastAudioDriver() = 0;

    virtual int enableVirtualBackground(bool enabled, VirtualBackgroundSource backgroundSource, bool force = false) = 0;

    virtual int isFeatureSupported(NERtcFeatureType featureType, bool* support) = 0;

    virtual NERTCFeatureSupportType getFeatureSupportedType(NERtcFeatureType feature_type) = 0;

    virtual NERtcNetworkConnectionType getNetworkType() = 0;

    virtual int setCloudProxy(int proxyType) = 0;
    
    virtual int enableLocalData(bool enabled) = 0;

    virtual int subscribeRemoteData(uid_t uid, bool subscribe) = 0;

    virtual int sendData(void* pData, uint64_t size) = 0;

    virtual int startBeauty(const char* file_path) = 0;

    virtual void stopBeauty() = 0;

    virtual void enableBeauty(bool enabled) = 0;

    virtual void enableBeautyMirrorMode(bool enabled) = 0;

    virtual float getBeautyEffect(NERtcBeautyEffectType type) = 0;

    virtual int setBeautyEffect(NERtcBeautyEffectType type, float level) = 0;

    virtual int addBeautyFilter(const char* file_path) = 0;

    virtual int removeBeautyFilter() = 0;

    virtual int setBeautyFilterLevel(float level) = 0;

    virtual int addBeautySticker(const char* file_path) = 0;

    virtual int removeBeautySticker() = 0;

    virtual int addBeautyMakeup(const char* file_path) = 0;

    virtual int removeBeautyMakeup() = 0;

    virtual int setLocalVoiceReverbParam(NERtcReverbParam& param) = 0;

    virtual int enableMediaPub(bool enabled, NERtcMediaPubType media_type) = 0;

    virtual int updatePermissionKey(const char* key) = 0;

    virtual int setEffectPosition(uint32_t effect_id, uint64_t timestamp_ms) = 0;

    virtual int getEffectCurrentPosition(uint64_t effect_id, uint64_t* timestamp_ms) = 0;

    virtual int getEffectDuration(uint64_t effect_id, uint64_t* duration_ms) = 0;
  
  virtual int reportCustomEvent(const char* event_name, const char* custom_identify, const char* parameters) = 0;

  virtual int setRangeAudioMode(NERtcRangeAudioMode mode) = 0;

  virtual int setRangeAudioTeamID(int32_t team_id) = 0;
  
  virtual int setAudioRecvRange(int audible_distance, int conversational_distance, NERtcDistanceRolloffModel roll_off) = 0;

  virtual int updateSelfPosition(const NERtcPositionInfo& info) = 0;

  virtual int enableSpatializerRoomEffects(bool enable) = 0;

  virtual int setSpatializerRoomProperty(const NERtcSpatializerRoomProperty& room_property) = 0;

  virtual int setSpatializerRenderMode(NERtcSpatializerRenderMode mode) = 0;

  virtual int initSpatializer() = 0;

  virtual int enableSpatializer(bool enable, bool apply_to_team) = 0;

  virtual int startPushStreaming(const NERtcPushStreamingConfig& config) = 0;

  virtual int stopPushStreaming() = 0;

  virtual int setupPlayStreamingCanvas(const char* stream_id, NERtcVideoCanvas* canvas) = 0;

  virtual int startPlayStreaming(const char* stream_id, NERtcPlayStreamingConfig* config) = 0;

  virtual int stopPlayStreaming(const char* stream_id) = 0;

  virtual int pausePlayStreaming(const char* stream_id) = 0;

  virtual int resumePlayStreaming(const char* stream_id) = 0;

  virtual int muteVideoForPlayStreaming(const char* stream_id, bool mute) = 0;

  virtual int muteAudioForPlayStreaming(const char* stream_id, bool mute) = 0;

  virtual int seekPlayStreaming(const char* stream_id, int64_t position_ms) = 0;

  virtual int addLocalRecorderStreamForTask(const NERtcLocalRecordingConfig& config, const char* task_id) = 0;

  virtual int removeLocalRecorderStreamForTask(const char* task_id) = 0;

  virtual int addLocalRecorderStreamLayoutForTask(const NERtcLocalRecordingLayoutConfig& config,
                                                  uid_t uid,
                                                  NERtcVideoStreamType stream_type,
                                                  int stream_layer,
                                                  const char* task_id) = 0;

  virtual int removeLocalRecorderStreamLayoutForTask(uid_t uid,
                                                     NERtcVideoStreamType stream_type,
                                                     int stream_layer,
                                                     const char* task_id) = 0;

  virtual int updateLocalRecorderStreamLayoutForTask(const NERtcLocalRecordingStreamInfo* infos,
                                                     int infos_count,
                                                     const char* task_id) = 0;

  virtual int replaceLocalRecorderStreamLayoutForTask(const NERtcLocalRecordingStreamInfo* infos,
                                                      int infos_count,
                                                      const char* task_id) = 0;

  virtual int updateLocalRecorderWaterMarksForTask(const NERtcVideoWatermarkConfig *watermarks, int count, const char* task_id) = 0;

  virtual int pushLocalRecorderVideoFrameForTask(uid_t uid, NERtcVideoStreamType stream_type, const int stream_layer, const char* task_id, NERtcVideoFrame* frame) = 0;

  virtual int showLocalRecorderStreamDefaultCoverForTask(bool show_enabled,
                                                         uid_t uid,
                                                         NERtcVideoStreamType stream_type,
                                                         int stream_layer,
                                                         const char* task_id) = 0;

  virtual int stopLocalRecorderRemuxMp4(const char* task_id) = 0;

  virtual int remuxFlvToMp4(const char* flv_path, const char* mp4_path, const bool save_ori) = 0;

  virtual int stopRemuxFlvToMp4() = 0;

  virtual int startASRCaption(NERtcASRCaptionConfig config) = 0;
  
  virtual int stopASRCaption() = 0;
  
  virtual int aiManualInterrupt(uint64_t dst_uid) = 0;
  
  virtual int startVoiceprintRegistration() = 0;
  
  virtual int cancelVoiceprintRegistration() = 0;
  
  virtual int stopVoiceprintRegistration() = 0;
  
  virtual int setVoiceprintInfo(NERtcVoiceprintInfo* voiceprint_infos, int count) = 0;

  virtual int setLocalVideoMosaic(bool enabled, NERtcVideoStreamType type, const NERtcFrameNormalizedRect& rect) = 0;

  virtual int setRemoteVideoMosaic(bool enabled, uid_t uid, NERtcVideoStreamType type, const NERtcFrameNormalizedRect& rect) = 0;

  virtual int startBlendExternalVideo(NERtcVideoStreamType stream_type, const NERtcVideoExternalBlendConfig& config) = 0;

  virtual int stopBlendExternalVideo(NERtcVideoStreamType stream_type) = 0;

  virtual int pushBlendExternalVideoFrame(NERtcVideoStreamType stream_type, const NERtcVideoFrame* frame) = 0;

  virtual int enableVideoDenoise(bool enabled, NERtcVideoStreamType stream_type) = 0;

  virtual int enableVideoLowlightEnhance(bool enabled, NERtcVideoLowlightEnhanceLevel level, NERtcVideoStreamType stream_type) = 0;
};
 
} //namespace nertc
 
#endif