LiveRoom-Publisher.h

Go to the documentation of this file.

//
//  LiveRoom-Publisher.h
//  zegoliveroom
//
//  Created by Randy Qiu on 2017/1/23.
//
//
 
#ifndef LiveRoom_Publisher_h
#define LiveRoom_Publisher_h
 
#include "./LiveRoomDefines-Publisher.h"
#include "./LiveRoomCallback-Publisher.h"
#include "./LiveRoomDefines.h"
 
namespace AVE
{
    class VideoCaptureFactory;
    class MediaCaptureFactory;
    class VideoFilterFactory;
    struct AudioFrame;
    struct ExtAudioProcSet;
    typedef ExtAudioProcSet ExtPrepSet;
 
    typedef void (*OnAudioProcCallback)(const AudioFrame& inFrame, AudioFrame& outFrame);
 
    typedef OnAudioProcCallback OnPrepCallback;
 
    typedef void (*OnAudioPcmDataCallback)(void *callbackContext, int channelIndex,
                                          const AudioFrame &outFrame);
 
    typedef OnAudioPcmDataCallback OnAlignedAudioAuxCallback;
}
 
namespace ZEGO
{
    namespace LIVEROOM
    {
        ZEGO_API int GetMaxPublishChannelCount();
 
        ZEGO_API bool SetLivePublisherCallback(ILivePublisherCallback* pCB);
        
        ZEGO_API bool SetPreviewView(void* pView, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool SetPreviewView(const AV::ZegoView &view, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool StartPreview(AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool StopPreview(AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetPublishStreamExtraInfo(const char *pszStreamExtraInfo, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API void SetCustomPublishTarget(const char *pszCustomPublishTarget, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API int AddPublishTarget(const char *strTarget, const char* pszStreamID, int timeout = 0);
        
        ZEGO_API int DeletePublishTarget(const char *strTarget, const char* pszStreamID);
        
        ZEGO_API void SetCDNPublishTarget(const char *pszCDNPublishTarget, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
    
        ZEGO_API bool SetCustomCDNPublishTarget(const AV::ZegoCDNPublishTarget target, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API void SetPublishEncryptKey(const unsigned char *pKey, int nkeyLen, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool SetVideoSource(AV::ZegoVideoSourceType srcType, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_AUX);
 
        ZEGO_API bool SetVideoSource(AV::ZegoVideoSourceType srcType, unsigned int instanceID, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_AUX);
 
        ZEGO_API bool SetAudioSource(AV::ZegoAudioSourceType srcType, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_AUX);
 
        ZEGO_API bool StartPublishing(const char* pszTitle, const char* pszStreamID, int flag, const char* pszParams = 0);
        
        ZEGO_API bool StartPublishing2(const char* pszTitle, const char* pszStreamID, int flag, const char* pszParams = 0, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool StartPublishingWithParams(const ZegoPublishStreamParams* streamParams);
    
        ZEGO_API int MuteVideoPublish(bool mute, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API int MuteAudioPublish(bool mute, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool StopPublishing(int flag = 0, const char* pszMsg = 0, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool RespondJoinLiveReq(int seq, int rspResult, const char* pszRoomID = nullptr);
        
        ZEGO_API int InviteJoinLive(const char* pszUserID, const char* pszRoomID = nullptr);
 
        ZEGO_API int EndJoinLive(const char* pszUserID, const char* pszRoomID = nullptr);
        
        ZEGO_API bool RequireHardwareEncoder(bool bRequired);
 
        ZEGO_API bool RequireHardwareEncoderByChannel(bool enable, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool SetVideoBitrate(int nBitrate, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool SetVideoFPS(int nFps, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetVideoEncodeResolution(int nWidth, int nHeight, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetVideoCaptureResolution(int nWidth, int nHeight, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetVideoKeyFrameInterval(int nIntervalSecond, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool EnableBeautifying(int nFeature, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetPolishStep(float step, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetPolishFactor(float factor, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetWhitenFactor(float factor, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetSharpenFactor(float factor, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetFilter(int nIndex, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool SetLowlightEnhancement(AV::ZegoLowlightEnhanceMode mode, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool SetLowlightEnhancementParams(const AV::ZegoLowlightEnhanceParams &params, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGOAVKIT_API void SetVideoDenoiseParams(const AV::ZegoVideoDenoiseParams &params,
                                                AV::PublishChannelIndex idx);
        
        ZEGO_API bool SetPreviewViewMode(ZegoVideoViewMode mode, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool EnablePreviewMirror(bool bEnabasle, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetVideoMirrorMode(AV::ZegoVideoMirrorMode mode, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetPreviewViewBackgroundColor(int color, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetPreviewRotation(int nRotation, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API bool SetCaptureFrameRotation(int nRotation, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool EnableMic(bool bEnable);
        
        ZEGO_API bool SetAudioBitrate(int bitrate, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API void SetAudioDeviceMode(AV::ZegoAVAPIAudioDeviceMode mode);
        
        ZEGO_API bool EnableAGC(bool bEnable);
    
        ZEGO_API void ResetAGC();
 
        ZEGO_API bool EnableAEC(bool bEnable);
        
        
        ZEGO_API void SetAECMode(AV::ZegoAECMode mode);
    
        ZEGO_API void ResetAEC();
        
        ZEGO_API bool EnableCamera(bool bEnable, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN, AV::ZegoNotifyDeviceStateMode notifyMode = AV::ZEGO_NOTIFY_DEVICE_STATE_MODE_OPEN);
 
        ZEGO_API bool TakeSnapshotPreview(AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool EnableLoopback(bool bEnable);
        
        ZEGO_API void SetLoopbackVolume(int volume);
        
        ZEGO_API void SetCaptureVolume(int volume);
        
        ZEGO_API float GetCaptureSoundLevel();
 
        ZEGO_API void SetDummyCaptureImagePath(const char *filePath, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void SetDummyCaptureImageParams(AV::ZegoDummyCaptureImageParams params, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void SetWaterMarkImagePath(const char *filePath, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API void SetPublishWaterMarkRect(int left, int top, int right, int bottom, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void SetPreviewWaterMarkRect(int left, int top, int right, int bottom, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API bool SetVideoCodecId(AV::ZegoVideoCodecAvc codecId, AV::PublishChannelIndex nChannel = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void SetAudioPrepCallback(AVE::OnPrepCallback callback, const AVE::ExtPrepSet& config);
 
        ZEGO_API void SetAudioPrepAfterLoopbackCallback(AVE::OnAudioProcCallback callback, const AVE::ExtPrepSet& config);
        
        ZEGO_API void SetAlignedAudioAuxDataCallback(AVE::OnAlignedAudioAuxCallback callback,
                                                          void *callbackContext);
 
        ZEGO_API void EnableAlignedAudioAuxData(bool enable, int sampleRate, int channels);
 
        ZEGO_API void SetVideoEncoderRateControlConfig(AV::ZegoVideoEncoderRateControlStrategy strategy, int encoderCRF, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API void EnableCheckPoc(bool bEnable);
        
        ZEGO_API void SetCapturePipelineScaleMode(AV::ZegoCapturePipelineScaleMode mode);
        
        ZEGO_API void SetLatencyMode(AV::ZegoAVAPILatencyMode mode);
        
        ZEGO_API void SetLatencyModeByChannel(AV::ZegoAVAPILatencyMode mode, AV::PublishChannelIndex idx);
        
        ZEGO_API void SetAudioChannelCount(int count);
        
        ZEGO_API void SetAudioChannelCountByChannel(int count, AV::PublishChannelIndex idx);
        
        ZEGO_API void EnableDTX(bool bEnable);
        
        ZEGO_API void EnableVAD(bool bEnable);
    
        ZEGO_API void EnableTrafficControl(int properties, bool bEnable, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGO_API void SetMinVideoBitrateForTrafficControl(int nBitrate, AV::ZegoTrafficControlMinVideoBitrateMode mode = AV::ZEGO_TRAFFIC_CONTROL_MIN_VIDEO_BITRATE_NO_VIDEO, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
        
        ZEGOAVKIT_API void SetMinVideoFpsForTrafficControl(int nFps, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGOAVKIT_API void SetMinVideoResolutionForTrafficControl(int nWidth, int nHeight, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void SetTrafficControlFocusOn(enum AV::ZegoTrafficControlFocusOn focusOn, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
    
        ZEGO_API bool EnableNoiseSuppress(bool bEnable);
 
        ZEGO_API bool SetNoiseSuppressMode(AV::ZegoANSMode mode);
 
        ZEGO_API bool EnableTransientNoiseSuppress(bool bEnable);
    
        ZEGO_API void ResetNoiseSuppress();
 
        ZEGO_API bool SetPublishQualityMonitorCycle(unsigned int timeInMS);
        
        ZEGO_API bool SetAudioEqualizerGain(int bandIndex, float bandGain);
 
        ZEGO_API void EnableScreenCaptureEncodeOptimization(bool enable, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void SetChannelExtraParam(const char *param_config, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void* GetChannelExtraParam(AV::ChannelExtraParamKey key, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API AV::ZegoCodecCapabilityInfo* GetVideoCodecCapabilityList(int& len);
 
        ZEGO_API void FreeVideoCodecCapabilityList(AV::ZegoCodecCapabilityInfo* parrCodecCapability);
 
        ZEGO_API void SetAudioCaptureShiftOnMix(int shiftMS);
 
        ZEGO_API int EnablePublishStreamAlignment(bool enable);
    
        ZEGO_API bool EnableH265EncodeFallback(bool enable);
    
        ZEGO_API bool IsVideoEncoderSupported(AV::ZegoVideoCodecAvc codecID);
 
        ZEGO_API int IsVideoEncoderSupported(AV::ZegoVideoCodecAvc codecID, AV::ZegoVideoCodecBackend codecBackend);
 
        ZEGO_API int SetStreamAlignmentProperty(int alignment, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
#if TARGET_OS_IPHONE
        ZEGO_API void RecoverAudioSessionMode();
 
 
        ZEGO_API void SetPreviewCropRect(AV::ZegoRect cropRect, AV::ZegoSize originalSize, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
#endif // TARGET_OS_IOS
 
        ZEGO_API void SetVideoEncodeMode(AV::ZegoVideoEncodeMode mode, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void SetAudioVADStableStateCallback(AV::IZegoCheckAudioVADCallback* callback);
 
        ZEGO_API void EnableCapturedAudioVADStableStateMonitor(bool enable, int period=3000);
 
        ZEGO_API void EnableAudioPrepVADStableStateMonitor(bool enable, int period=3000);
 
        ZEGO_API void EnableVideoObjectSegmentation(bool enable, AV::ZegoObjectSegmentationType type, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void EnableVideoObjectSegmentation(bool enable, const AV::ZegoObjectSegmentationConfig &config, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void EnableAlphaChannelVideoEncoder(bool enable, AV::ZegoAlphaLayoutType layoutType, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
    
 
        ZEGO_API void SetPublishDualStreamConfig(const AV::ZegoPublishDualStreamConfig* configList, int configListCount, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
    
        ZEGO_API void EnableColorEnhancement(bool enable, AV::ZegoColorEnhancementParams params, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
 
        ZEGO_API void SetBeforeAudioPrepCallback(AV::IZegoBeforeAudioPrepCallback *callback);
 
        ZEGO_API void EnableBeforeAudioPrepCallback(bool enable, int sampleRate, int channel);
 
        ZEGOAVKIT_API void EnableAuxBgmBalance(bool enable);
 
        ZEGO_API void EnableFaceDetection(bool enable, AV::PublishChannelIndex idx = AV::PUBLISH_CHN_MAIN);
    }
}
#endif /* LiveRoom_Publisher_h */