AlivcLivePushConfig.java

package com.alivc.live.pusher;
 
import static com.alivc.live.pusher.AlivcAudioSampleRateEnum.AUDIO_SAMPLE_RATE_48000;
import static com.alivc.live.pusher.AlivcLivePushCameraTypeEnum.CAMERA_TYPE_FRONT;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_MAX_DIFF_PTS;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_MAX_TIMEOUT_COUNT;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_AUDIO_ONLY;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_AUTO_FOCUS;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_FLASH;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_INT_AUDIO_RETRY_COUNT;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_INT_INIT_BITRATE;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_INT_MIN_BITRATE;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_INT_RETRY_INTERVAL;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_INT_TARGET_BITRATE;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_PREVIEW_MIRROR;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_PUSH_MIRROR;
import static com.alivc.live.pusher.AlivcLivePushConstants.DEFAULT_VALUE_VIDEO_ONLY;
import static com.alivc.live.pusher.AlivcResolutionEnum.DEFAULT_VALUE_INT_DEFINITION;
 
import android.content.Intent;
import android.graphics.ImageFormat;
import android.media.AudioFormat;
import android.os.Build;
 
import com.alivc.live.annotations.AlivcLiveMode;
 
import java.io.Serializable;
import java.util.ArrayList;
 
@Visible
public class AlivcLivePushConfig implements Serializable {
    public static final String CONFIG = "AlivcLivePushConfig";
 
    private AlivcLiveMode mLivePushMode = AlivcLiveMode.AlivcLiveBasicMode;
 
    private AlivcResolutionEnum mResolution = DEFAULT_VALUE_INT_DEFINITION;
    private AlivcFpsEnum mFps = AlivcFpsEnum.FPS_20;
    private int mTargetVideoBitrate = DEFAULT_VALUE_INT_TARGET_BITRATE;
    private int mMinVideoBitrate = DEFAULT_VALUE_INT_MIN_BITRATE;
    private int mInitialVideoBitrate = DEFAULT_VALUE_INT_INIT_BITRATE;
    private int mBFrames = 0;
    private static Intent mediaProjectionPermissionResultData = null;
    private AlivcPreviewOrientationEnum mPreviewOrientation = AlivcPreviewOrientationEnum.ORIENTATION_PORTRAIT;
    private AlivcPreviewRotationEnum mPreviewRotation = AlivcPreviewRotationEnum.ROTATION_0;
    private AlivcPreviewDisplayMode mPreviewDisplayMode = AlivcPreviewDisplayMode.ALIVC_LIVE_PUSHER_PREVIEW_ASPECT_FIT;
    private AlivcLivePushCameraTypeEnum mCameraType = CAMERA_TYPE_FRONT;
    private boolean mPreviewMirror = DEFAULT_VALUE_PREVIEW_MIRROR;
    private boolean mPushMirror = DEFAULT_VALUE_PUSH_MIRROR;
    private boolean mAudioOnly = DEFAULT_VALUE_AUDIO_ONLY;
    private boolean mVideoOnly = DEFAULT_VALUE_VIDEO_ONLY;
    private boolean mAutoFocus = DEFAULT_VALUE_AUTO_FOCUS;
    private boolean mFocusBySensor = false;
    private boolean mFlash = DEFAULT_VALUE_FLASH;
 
    //rtmp module
    private int mConnectRetryCount = DEFAULT_VALUE_INT_AUDIO_RETRY_COUNT;
    private int mConnectRetryInterval = DEFAULT_VALUE_INT_RETRY_INTERVAL;
 
    private long mPtsMaxDiff = DEFAULT_MAX_DIFF_PTS; // 音频在前
    private int mMaxTimeoutCount = DEFAULT_MAX_TIMEOUT_COUNT;
    //private int mAlarmRemainPacketSize = DEFAULT_START_ALRAM_PACKET_SIZE;
    //private int mUndoAlarmRemainPacketSize = DEFAULT_STOP_ALARM_PACKET_SIZE;
 
    private AlivcAudioChannelEnum mAudioChannels = AlivcAudioChannelEnum.AUDIO_CHANNEL_TWO;
    private AlivcEncodeModeEnum mVideoEncodeMode = AlivcEncodeModeEnum.Encode_MODE_HARD;
    private AlivcEncodeType mVideoEncodeType = AlivcEncodeType.Encode_TYPE_H264;
    private AlivcEncodeModeEnum mAudioEncodeMode = AlivcEncodeModeEnum.Encode_MODE_SOFT;
    private int mVideoFormat = ImageFormat.NV21;
    private int mAudioFormat = AudioFormat.ENCODING_PCM_16BIT;
    private AlivcImageFormat mAlivcExternMainImageFormat = AlivcImageFormat.IMAGE_FORMAT_YUV420P;
    private AlivcSoundFormat mAlivcExternMainSoundFormat = AlivcSoundFormat.SOUND_FORMAT_S16;
 
    private AlivcVideoEncodeGopEnum mVideoEncodeGop = AlivcVideoEncodeGopEnum.GOP_TWO;
 
    private int mExposure = 0;
 
    private boolean mUseAliPlayerForBGM = false;
 
    private boolean enableNarrowbandHDForScreenPusher = true;
 
    private boolean enableRTSForInteractiveMode = false;
 
    //最小帧率
    private AlivcFpsEnum minFps = AlivcFpsEnum.FPS_8;
 
    private boolean enableBitrateControl = true;
    private boolean enableAutoResolution = false;
 
    private boolean initBitFlag = false;
    private boolean minBitFlag = false;
    private boolean targetBitFlag = false;
 
    private boolean externMainStream = false;
 
    private int sendDataTimeout = 3000;
    private AlivcQualityModeEnum qualityMode = AlivcQualityModeEnum.QM_RESOLUTION_FIRST;
 
    private AlivcAudioAACProfileEnum audioProfile = AlivcAudioAACProfileEnum.AAC_LC;
    private int audioBitRate = 64000;
    private AlivcAudioSceneModeEnum audioSceneMode = AlivcAudioSceneModeEnum.AUDIO_SCENE_MUSIC_MODE;
    private AlivcAudioSampleRateEnum mAudioSampleRate = AUDIO_SAMPLE_RATE_48000;
    private String mPausePushImagePath = "";
    private String mNetworkPoorPushImagePath = "";
 
    private boolean requireGLSharedContext = false;
    private boolean mAudioCaptureWithoutMix = false;
 
    private boolean h5CompatibleMode = false;
 
    private boolean enableDataChannelMessage = false;
 
    private String mExtraInfo;
 
    private String userName;
 
    private AlivcLivePushMonitorLevel monitorLevel = AlivcLivePushMonitorLevel.ALL;
 
    public AlivcLivePushConfig() {
        mediaProjectionPermissionResultData = null;
        if (Build.MANUFACTURER.equals("Letv") || Build.MODEL.equals("Le X620")) {
            mAudioCaptureWithoutMix = true;
        }
    }
 
    private ArrayList<WaterMarkInfo> waterMarkInfos = new ArrayList<>();
 
    public int getVideoFormat() {
        return mVideoFormat;
    }
 
    public void setVideoFormat(int videoFormat) {
        this.mVideoFormat = videoFormat;
    }
 
    public int getAudioFormat() {
        return mAudioFormat;
    }
 
    public void setAudioFormat(int audioFormat) {
        this.mAudioFormat = audioFormat;
    }
 
    public void setLivePushMode(AlivcLiveMode pushMode) {
        this.mLivePushMode = pushMode;
        // 不同模式下，分辨率对应的width/height/initial bitrate/target bitrate/min bitrate不一样，需刷新
        setResolution(mResolution);
    }
 
    public AlivcLiveMode getLivePushMode() {
        return mLivePushMode;
    }
 
    private boolean checkLiveInteractiveMode() {
        return mLivePushMode == AlivcLiveMode.AlivcLiveInteractiveMode;
    }
 
    public AlivcResolutionEnum getResolution() {
        return mResolution;
    }
 
    public void setResolution(AlivcResolutionEnum resolution) {
        this.mResolution = resolution;
 
        if (!targetBitFlag) {
            mTargetVideoBitrate = AlivcResolutionEnum.getTargetBitrate(resolution, mLivePushMode);
        }
 
        if (!initBitFlag) {
            mInitialVideoBitrate = AlivcResolutionEnum.getInitBitrate(resolution, mLivePushMode);
        }
 
        if (!minBitFlag) {
            mMinVideoBitrate = AlivcResolutionEnum.getMinBitrate(resolution, mLivePushMode);
        }
    }
 
    public String getExtraInfo() {
        return mExtraInfo;
    }
 
    public void setExtraInfo(String extraInfo) {
        mExtraInfo = extraInfo;
    }
 
    public String getUserName() {
        return userName;
    }
 
    public void setUserName(String userName) {
        this.userName = userName;
    }
 
    public boolean isH5CompatibleMode() {
        return h5CompatibleMode;
    }
 
    public void setH5CompatibleMode(boolean h5CompatibleMode) {
        this.h5CompatibleMode = h5CompatibleMode;
    }
 
    public boolean isEnableDataChannelMessage() {
        return enableDataChannelMessage;
    }
 
    public void setEnableDataChannelMessage(boolean enableDataChannelMessage) {
        this.enableDataChannelMessage = enableDataChannelMessage;
    }
 
    public AlivcLivePushMonitorLevel getMonitorLevel() {
        return monitorLevel;
    }
 
    public void setMonitorLevel(AlivcLivePushMonitorLevel monitorLevel) {
        this.monitorLevel = monitorLevel;
    }
 
    public int getFps() {
        return mFps.getFps();
    }
 
    public void setFps(AlivcFpsEnum fps) {
        this.mFps = fps;
    }
 
    public int getTargetVideoBitrate() {
        return mTargetVideoBitrate;
    }
 
    public void setTargetVideoBitrate(int targetBitRate) {
        this.mTargetVideoBitrate = targetBitRate;
        this.targetBitFlag = true;
    }
 
    public int getMinVideoBitrate() {
        return mMinVideoBitrate;
    }
 
    public void setMinVideoBitrate(int minBitrate) {
        this.mMinVideoBitrate = minBitrate;
        this.minBitFlag = true;
    }
 
    public int getBFrames() {
        return mBFrames;
    }
 
    public void setBFrames(int bFrame) {
        this.mBFrames = bFrame;
    }
 
    public AlivcAudioSampleRateEnum getAudioSampleRate() {
        return mAudioSampleRate;
    }
 
    public void setAudioSampleRate(AlivcAudioSampleRateEnum audioSample) {
        this.mAudioSampleRate = audioSample;
    }
 
    public int getPreviewOrientation() {
        return mPreviewOrientation.getOrientation();
    }
 
    public void setPreviewOrientation(AlivcPreviewOrientationEnum previewOrientation) {
        this.mPreviewOrientation = previewOrientation;
    }
 
    public int getPreviewRotation() {
        return mPreviewRotation.getRotation();
    }
 
    public void setPreviewRotation(AlivcPreviewRotationEnum rotation) {
        this.mPreviewRotation = rotation;
    }
 
    public int getCameraType() {
        return mCameraType.getCameraId();
    }
 
    public void setCameraType(AlivcLivePushCameraTypeEnum cameraType) {
        this.mCameraType = cameraType;
    }
 
    public boolean isPreviewMirror() {
        return mPreviewMirror;
    }
 
    public void setPreviewMirror(boolean mirror) {
        this.mPreviewMirror = mirror;
    }
 
    public boolean isAudioOnly() {
        return mAudioOnly;
    }
 
    public void setAudioOnly(boolean audioOnly) {
        this.mAudioOnly = audioOnly;
    }
 
    public boolean isVideoOnly() {
        return mVideoOnly;
    }
 
    public void setVideoOnly(boolean videoOnly) {
        this.mVideoOnly = videoOnly;
    }
 
    public boolean isAutoFocus() {
        return mAutoFocus;
    }
 
    public void setAutoFocus(boolean autoFocus) {
        this.mAutoFocus = autoFocus;
    }
 
    public boolean isFocusBySensor() {
        return mFocusBySensor;
    }
 
    public void setFocusBySensor(boolean focusBySensor) {
        this.mFocusBySensor = focusBySensor;
    }
 
    public boolean isFlash() {
        return mFlash;
    }
 
    public void setFlash(boolean flash) {
        this.mFlash = flash;
    }
 
    public int getSendDataTimeout() {
        return sendDataTimeout;
    }
 
    public void setSendDataTimeout(int sendDataTimeout) {
        this.sendDataTimeout = sendDataTimeout;
    }
 
    public String getPausePushImage() {
        return mPausePushImagePath;
    }
 
    public void setPausePushImage(String path) {
        mPausePushImagePath = path;
    }
 
    public String getNetworkPoorPushImage() {
        return mNetworkPoorPushImagePath;
    }
 
    public void setNetworkPoorPushImage(String path) {
        mNetworkPoorPushImagePath = path;
    }
 
    public int getInitialVideoBitrate() {
        return mInitialVideoBitrate;
    }
 
    public void setInitialVideoBitrate(int initialVideoBitrate) {
        this.mInitialVideoBitrate = initialVideoBitrate;
        this.initBitFlag = true;
    }
 
    public int getConnectRetryCount() {
        return mConnectRetryCount;
    }
 
    public void setConnectRetryCount(int connectRetryCount) {
        this.mConnectRetryCount = connectRetryCount;
    }
 
    public int getConnectRetryInterval() {
        return mConnectRetryInterval;
    }
 
    public void setConnectRetryInterval(int connectRetryInterval) {
        this.mConnectRetryInterval = connectRetryInterval;
    }
 
    public boolean isPushMirror() {
        return mPushMirror;
    }
 
    public void setPushMirror(boolean pushMirror) {
        this.mPushMirror = pushMirror;
    }
 
    public AlivcEncodeModeEnum getVideoEncodeMode() {
        return mVideoEncodeMode;
    }
 
    public void setVideoEncodeMode(AlivcEncodeModeEnum videoEncodeMode) {
        this.mVideoEncodeMode = videoEncodeMode;
    }
 
    public AlivcEncodeType getVideoEncodeType() {
        return mVideoEncodeType;
    }
 
    public void setVideoEncodeType(AlivcEncodeType videoEncodeType) {
        this.mVideoEncodeType = videoEncodeType;
    }
 
    public AlivcEncodeModeEnum getAudioEncodeMode() {
        return mAudioEncodeMode;
    }
 
    public void setAudioEncodeMode(AlivcEncodeModeEnum audioEncodeMode) {
        this.mAudioEncodeMode = audioEncodeMode;
    }
 
    public int getWidth() {
        return AlivcResolutionEnum.getResolutionWidth(mResolution, mLivePushMode);
    }
 
    public int getHeight() {
        return AlivcResolutionEnum.getResolutionHeight(mResolution, mLivePushMode);
    }
 
    public int getAudioChannels() {
        return mAudioChannels.getChannelCount();
    }
 
    public void setAudioChannels(AlivcAudioChannelEnum audioChannels) {
        mAudioChannels = audioChannels;
    }
 
    public int getVideoEncodeGop() {
        return mVideoEncodeGop.getGop();
    }
 
    public void setVideoEncodeGop(AlivcVideoEncodeGopEnum videoEncodeGop) {
        mVideoEncodeGop = videoEncodeGop;
    }
 
    public int getExposure() {
        return mExposure;
    }
 
    public void setExposure(int exposure) {
        this.mExposure = exposure;
    }
 
    public void setUseAliPlayerForBGM(boolean useAliPlayerForBGM) {
        mUseAliPlayerForBGM = useAliPlayerForBGM;
    }
 
    public boolean useAliPlayerForBGM() {
        return mUseAliPlayerForBGM;
    }
 
    public void setEnableNarrowbandHDForScreenPusher(boolean enable) {
        enableNarrowbandHDForScreenPusher = enable;
    }
 
    public boolean isEnableNarrowbandHDForScreenPusher() {
        return enableNarrowbandHDForScreenPusher;
    }
 
    public boolean isEnableRTSForInteractiveMode() {
        return enableRTSForInteractiveMode;
    }
 
    public void setEnableRTSForInteractiveMode(boolean enableRTSForInteractiveMode) {
        this.enableRTSForInteractiveMode = enableRTSForInteractiveMode;
    }
 
    public int getMinFps() {
        return minFps.getFps();
    }
 
    public void setMinFps(AlivcFpsEnum minFps) {
        this.minFps = minFps;
    }
 
    public AlivcAudioAACProfileEnum getAudioProfile() {
        return audioProfile;
    }
 
    public void setAudioProfile(AlivcAudioAACProfileEnum audioProfile) {
        this.audioProfile = audioProfile;
    }
 
    public int getAudioBitRate() {
        return audioBitRate;
    }
 
    public void setAudioBitRate(int audioBitRate) {
        this.audioBitRate = audioBitRate;
    }
 
    public AlivcAudioSceneModeEnum getAudioSceneMode() {
        return audioSceneMode;
    }
 
    public void setAudioSceneMode(AlivcAudioSceneModeEnum audioSceneMode) {
        this.audioSceneMode = audioSceneMode;
    }
 
    public void setQualityMode(AlivcQualityModeEnum quality) {
        this.qualityMode = quality;
    }
 
    public AlivcQualityModeEnum getQualityMode() {
        return qualityMode;
    }
 
    public Intent getMediaProjectionPermissionResultData() {
        return mediaProjectionPermissionResultData;
    }
 
    public static void setMediaProjectionPermissionResultData(Intent mediaProjectionPermissionResultData) {
        AlivcLivePushConfig.mediaProjectionPermissionResultData = mediaProjectionPermissionResultData;
    }
 
    public boolean isEnableBitrateControl() {
        return enableBitrateControl;
    }
 
    public void setEnableBitrateControl(boolean enableBitrateControl) {
        this.enableBitrateControl = enableBitrateControl;
    }
 
    public boolean isEnableAutoResolution() {
        return enableAutoResolution;
    }
 
    public void setEnableAutoResolution(boolean enableAutoResolution) {
        this.enableAutoResolution = enableAutoResolution;
    }
 
    public boolean isExternMainStream() {
        return externMainStream;
    }
 
    public void setExternMainStream(boolean externMainStream) {
        this.externMainStream = externMainStream;
    }
 
    public void setExternMainStream(boolean externMainStream, AlivcImageFormat imageFormat, AlivcSoundFormat soundFormat) {
        this.externMainStream = externMainStream;
        mAlivcExternMainImageFormat = imageFormat;
        mAlivcExternMainSoundFormat = soundFormat;
    }
 
    public AlivcImageFormat getAlivcExternMainImageFormat() {
        return mAlivcExternMainImageFormat;
    }
 
    public void setAlivcExternMainImageFormat(AlivcImageFormat alivcExternMainImageFormat) {
        this.mAlivcExternMainImageFormat = alivcExternMainImageFormat;
    }
 
    public AlivcSoundFormat getAlivcExternMainSoundFormat() {
        return mAlivcExternMainSoundFormat;
    }
 
    public void setAlivcExternMainSoundFormat(AlivcSoundFormat soundFormat) {
        this.mAlivcExternMainSoundFormat = soundFormat;
    }
 
    public AlivcPreviewDisplayMode getPreviewDisplayMode() {
        return mPreviewDisplayMode;
    }
 
    public void setPreviewDisplayMode(AlivcPreviewDisplayMode displayMode) {
        this.mPreviewDisplayMode = displayMode;
    }
 
    public void setRequireRenderContextNotify(boolean enable) {
        this.requireGLSharedContext = enable;
    }
 
    public boolean getRequireRenderContextNotify() {
        return this.requireGLSharedContext;
    }
 
    public void setAudioCaptureWithoutMix(boolean on) {
        this.mAudioCaptureWithoutMix = on;
    }
 
    public boolean getAudioCaptureWithoutMix() {
        return mAudioCaptureWithoutMix;
    }
 
    @Deprecated
    public void addWaterMark(String path, float x, float y, float width) {
        WaterMarkInfo waterMarkInfo = new WaterMarkInfo();
        waterMarkInfo.mWaterMarkPath = path;
        waterMarkInfo.mWaterMarkCoordX = x;
        waterMarkInfo.mWaterMarkCoordY = y;
        waterMarkInfo.mWaterMarkWidth = width;
        if (waterMarkInfos.size() < 3) {
            waterMarkInfos.add(waterMarkInfo);
        }
    }
 
    @Deprecated
    public void clearWaterMark() {
        waterMarkInfos.clear();
    }
 
    @Deprecated
    public void removeWaterMark(String path) {
        for (WaterMarkInfo info : waterMarkInfos) {
            if (path != null && path.equals(info.mWaterMarkPath)) {
                waterMarkInfos.remove(info);
                break;
            }
        }
    }
 
    public ArrayList<WaterMarkInfo> getWaterMarkInfos() {
        return waterMarkInfos;
    }
 
    @Override
    public String toString() {
        return "AlivcLivePushConfig{" +
                "mLivePushMode=" + mLivePushMode +
                ", mResolution=" + mResolution +
                ", mFps=" + mFps +
                ", mTargetVideoBitrate=" + mTargetVideoBitrate +
                ", mMinVideoBitrate=" + mMinVideoBitrate +
                ", mInitialVideoBitrate=" + mInitialVideoBitrate +
                ", mBFrames=" + mBFrames +
                ", mPreviewOrientation=" + mPreviewOrientation +
                ", mPreviewRotation=" + mPreviewRotation +
                ", mPreviewDisplayMode=" + mPreviewDisplayMode +
                ", mCameraType=" + mCameraType +
                ", mPreviewMirror=" + mPreviewMirror +
                ", mPushMirror=" + mPushMirror +
                ", mAudioOnly=" + mAudioOnly +
                ", mVideoOnly=" + mVideoOnly +
                ", mAutoFocus=" + mAutoFocus +
                ", mFocusBySensor=" + mFocusBySensor +
                ", mFlash=" + mFlash +
                ", mConnectRetryCount=" + mConnectRetryCount +
                ", mConnectRetryInterval=" + mConnectRetryInterval +
                ", mPtsMaxDiff=" + mPtsMaxDiff +
                ", mMaxTimeoutCount=" + mMaxTimeoutCount +
                ", mAudioChannels=" + mAudioChannels +
                ", mVideoEncodeMode=" + mVideoEncodeMode +
                ", mVideoEncodeType=" + mVideoEncodeType +
                ", mAudioEncodeMode=" + mAudioEncodeMode +
                ", mVideoFormat=" + mVideoFormat +
                ", mAudioFormat=" + mAudioFormat +
                ", mAlivcExternMainImageFormat=" + mAlivcExternMainImageFormat +
                ", mAlivcExternMainSoundFormat=" + mAlivcExternMainSoundFormat +
                ", mVideoEncodeGop=" + mVideoEncodeGop +
                ", mExposure=" + mExposure +
                ", mUseAliPlayerForBGM=" + mUseAliPlayerForBGM +
                ", enableNarrowbandHDForScreenPusher=" + enableNarrowbandHDForScreenPusher +
                ", enableRTSForInteractiveMode=" + enableRTSForInteractiveMode +
                ", minFps=" + minFps +
                ", enableBitrateControl=" + enableBitrateControl +
                ", enableAutoResolution=" + enableAutoResolution +
                ", initBitFlag=" + initBitFlag +
                ", minBitFlag=" + minBitFlag +
                ", targetBitFlag=" + targetBitFlag +
                ", externMainStream=" + externMainStream +
                ", sendDataTimeout=" + sendDataTimeout +
                ", qualityMode=" + qualityMode +
                ", audioProfile=" + audioProfile +
                ", audioBitRate=" + audioBitRate +
                ", audioSceneMode=" + audioSceneMode +
                ", mAudioSampleRate=" + mAudioSampleRate +
                ", mPausePushImagePath='" + mPausePushImagePath + '\'' +
                ", mNetworkPoorPushImagePath='" + mNetworkPoorPushImagePath + '\'' +
                ", requireGLSharedContext=" + requireGLSharedContext +
                ", mAudioCaptureWithoutMix=" + mAudioCaptureWithoutMix +
                ", h5CompatibleMode=" + h5CompatibleMode +
                ", mExtraInfo='" + mExtraInfo + '\'' +
                ", monitorLevel=" + monitorLevel +
                ", waterMarkInfos=" + waterMarkInfos +
                '}';
    }
} // end of live_pusher