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_DEFINITION;
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 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;
    private int mWidth = AlivcResolutionEnum.getResolutionWidth(DEFAULT_VALUE_INT_DEFINITION, mLivePushMode);
    private int mHeight = AlivcResolutionEnum.getResolutionHeight(DEFAULT_VALUE_INT_DEFINITION, mLivePushMode);

    //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 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_DEFAULT_MODE;
    private AlivcAudioSampleRateEnum mAudioSampleRate = AUDIO_SAMPLE_RATE_48000;
    private String mPausePushImagePath = "";
    private String mNetworkPoorPushImagePath = "";

    private boolean requireGLSharedContext = false;
    private boolean mAudioCaptureWithoutMix = false;

    private String mExtraInfo;

    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);
        }

        this.mWidth = AlivcResolutionEnum.getResolutionWidth(resolution, mLivePushMode);
        this.mHeight = AlivcResolutionEnum.getResolutionHeight(resolution, mLivePushMode);
    }

    public String getExtraInfo() {
        return mExtraInfo;
    }

    public void setExtraInfo(String extraInfo) {
        mExtraInfo = extraInfo;
    }

    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 mWidth;
    }

    public int getHeight() {
        return mHeight;
    }

    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 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;
            }
        }
    }

    ArrayList<WaterMarkInfo> getWaterMarkInfos() {
        return waterMarkInfos;
    }

} // end of live_pusher