package com.mediatek.extservice;

import a.b.c.a.a;
import android.graphics.Rect;
import android.os.Parcel;
import android.os.Parcelable;

/* JADX INFO: loaded from: classes.dex */
public final class CaptureConfig implements Parcelable {
    private static final int BW_LIMIT_SET_LITMIT = 0;
    private static final int BW_LIMIT_SET_NO_LITMIT = 1;
    private static final int BW_LIMIT_USER_NOT_SET = -1;
    private static final boolean DEFAULT_BUFFER_STABLE = false;
    private static final byte DEFAULT_EXTIN_PORT_NUM = 1;
    private static final int DEFAULT_FRAME_RATE = 30;
    private static final int DEFAULT_OUTPUT_H = 1080;
    private static final int DEFAULT_OUTPUT_W = 1920;
    private static final int DEFAULT_PITCH_SIZE = 0;
    private static final int DEFAULT_ROTATE_ANGLE = 0;
    private static final int DEFAULT_STREAM_ID = 0;
    private static final int DEFAULT_SUB_BUFFER_NUMS = 0;
    private static final byte MAX_EXTIN_PORT_NUM = 4;
    private static final int MAX_SUB_BUFFER_NUMS = 8;
    private static final int MAX_SUPPORT_FRAME_RATE = 60;
    private static final byte MIN_EXTIN_PORT_NUM = 1;
    private static final int MIN_SUB_BUFFER_NUMS = 3;
    private CapturePoint mCapturePoint;
    private static final CaptureFormat DEFAULT_FORAMT = CaptureFormat.YUV422;
    private static final CaptureColorSpace DEFAULT_COLOR_SPACE = CaptureColorSpace.NONE;
    private static final Rect DEFAULT_CROP_RECT = null;
    private static final ExtInPortType DEFAULT_EXTIN_PORT_TYPE = ExtInPortType.HDMI;
    public static final Parcelable.Creator<CaptureConfig> CREATOR = new Parcelable.Creator<CaptureConfig>() { // from class: com.mediatek.extservice.CaptureConfig.1
        /* JADX WARN: Can't rename method to resolve collision */
        @Override // android.os.Parcelable.Creator
        public CaptureConfig createFromParcel(Parcel parcel) {
            return new CaptureConfig(parcel);
        }

        /* JADX WARN: Can't rename method to resolve collision */
        @Override // android.os.Parcelable.Creator
        public CaptureConfig[] newArray(int i2) {
            return new CaptureConfig[i2];
        }
    };
    private Rect mCropRect = DEFAULT_CROP_RECT;
    private int mStreamId = 0;
    private int mOutputWidth = 0;
    private int mOutputHeight = 0;
    private int mOutputFramerate = 30;
    private int mOutputPitch = 0;
    private int mRotateAngle = 0;
    private int mSubBufferNums = 0;
    private int mLimitBwType = -1;
    private byte mExtInPortNum = 1;
    private CaptureFormat mOutputFormat = DEFAULT_FORAMT;
    private CaptureColorSpace mOutputColorSpace = DEFAULT_COLOR_SPACE;
    private ExtInPortType mExtInPortType = DEFAULT_EXTIN_PORT_TYPE;
    private boolean mStable = false;
    private boolean mDstDataRangeLimit = false;
    private boolean mCtsDebugEnabled = false;

    public CaptureConfig() {
    }

    public CaptureConfig(Parcel parcel) {
        readFromParcel(parcel);
    }

    public static CaptureConfig createDefaultConfig(CapturePoint capturePoint) {
        CaptureConfig captureConfig = new CaptureConfig();
        captureConfig.setCapturePoint(capturePoint);
        captureConfig.setOutputWidth(DEFAULT_OUTPUT_W);
        captureConfig.setOutputHeight(DEFAULT_OUTPUT_H);
        return captureConfig;
    }

    public static CaptureConfig createFullSizeOutputConfig(CapturePoint capturePoint) {
        CaptureConfig captureConfig = new CaptureConfig();
        captureConfig.setCapturePoint(capturePoint);
        return captureConfig;
    }

    @Override // android.os.Parcelable
    public int describeContents() {
        return 0;
    }

    public CapturePoint getCapturePoint() {
        return this.mCapturePoint;
    }

    public Rect getCropRect() {
        return this.mCropRect;
    }

    public boolean getDstDataRangeLimit() {
        return this.mDstDataRangeLimit;
    }

    public byte getExtInPortNum() {
        return this.mExtInPortNum;
    }

    public ExtInPortType getExtInPortType() {
        return this.mExtInPortType;
    }

    public int getLimitBwType() {
        return this.mLimitBwType;
    }

    public CaptureColorSpace getOutputColorSpace() {
        return this.mOutputColorSpace;
    }

    public CaptureFormat getOutputFormat() {
        return this.mOutputFormat;
    }

    public int getOutputFramerate() {
        return this.mOutputFramerate;
    }

    public int getOutputHeight() {
        return this.mOutputHeight;
    }

    public int getOutputPitch() {
        return this.mOutputPitch;
    }

    public int getOutputWidth() {
        return this.mOutputWidth;
    }

    public int getRotateAngle() {
        return this.mRotateAngle;
    }

    public boolean getStable() {
        return this.mStable;
    }

    public int getStreamId() {
        return this.mStreamId;
    }

    public int getSubBufferNums() {
        return this.mSubBufferNums;
    }

    public boolean isCtsDebugEnabled() {
        return this.mCtsDebugEnabled;
    }

    public void readFromParcel(Parcel parcel) {
        this.mCapturePoint = (CapturePoint) parcel.readParcelable(CaptureConfig.class.getClassLoader());
        this.mStreamId = parcel.readInt();
        this.mCropRect = (Rect) parcel.readParcelable(CaptureConfig.class.getClassLoader());
        this.mOutputWidth = parcel.readInt();
        this.mOutputHeight = parcel.readInt();
        this.mOutputFramerate = parcel.readInt();
        this.mOutputPitch = parcel.readInt();
        this.mRotateAngle = parcel.readInt();
        this.mSubBufferNums = parcel.readInt();
        this.mLimitBwType = parcel.readInt();
        this.mExtInPortNum = parcel.readByte();
        this.mOutputFormat = (CaptureFormat) parcel.readParcelable(CaptureConfig.class.getClassLoader());
        this.mOutputColorSpace = (CaptureColorSpace) parcel.readParcelable(CaptureConfig.class.getClassLoader());
        this.mExtInPortType = (ExtInPortType) parcel.readParcelable(CaptureConfig.class.getClassLoader());
        this.mStable = parcel.readByte() != 0;
        this.mDstDataRangeLimit = parcel.readByte() != 0;
        this.mCtsDebugEnabled = parcel.readByte() != 0;
    }

    public void setBwLimit(boolean z) {
        this.mLimitBwType = !z ? 1 : 0;
    }

    public void setCapturePoint(CapturePoint capturePoint) {
        this.mCapturePoint = capturePoint;
    }

    public void setCropRect(Rect rect) {
        if (rect == null || rect.width() <= 0 || rect.height() <= 0) {
            return;
        }
        this.mCropRect = rect;
    }

    public void setCtsDebugEnabled(boolean z) {
        this.mCtsDebugEnabled = z;
    }

    public void setDstDataRangeLimit(boolean z) {
        this.mDstDataRangeLimit = z;
    }

    public void setExtInPortNum(byte b2) {
        if (b2 < 1 || b2 > 4) {
            return;
        }
        this.mExtInPortNum = b2;
    }

    public void setExtInPortType(ExtInPortType extInPortType) {
        this.mExtInPortType = extInPortType;
    }

    public void setOutputColorSpace(CaptureColorSpace captureColorSpace) {
        this.mOutputColorSpace = captureColorSpace;
    }

    public void setOutputFormat(CaptureFormat captureFormat) {
        this.mOutputFormat = captureFormat;
    }

    public void setOutputFramerate(int i2) {
        if (i2 <= 0) {
            return;
        }
        if (i2 >= 60) {
            i2 = 60;
        }
        this.mOutputFramerate = i2;
    }

    public void setOutputHeight(int i2) {
        if (i2 <= 0) {
            return;
        }
        this.mOutputHeight = i2;
    }

    public void setOutputPitch(int i2) {
        if (i2 <= 0) {
            return;
        }
        this.mOutputPitch = i2;
    }

    public void setOutputWidth(int i2) {
        if (i2 <= 0) {
            return;
        }
        this.mOutputWidth = i2;
    }

    public void setRotateAngle(int i2) {
        if (i2 < 0) {
            return;
        }
        this.mRotateAngle = i2;
    }

    public void setStable(boolean z) {
        this.mStable = z;
    }

    public void setStreamId(int i2) {
        if (i2 < 0) {
            return;
        }
        this.mStreamId = i2;
    }

    public void setSubBufferNums(int i2) {
        if (i2 < 3 || i2 > 8) {
            return;
        }
        this.mSubBufferNums = i2;
    }

    public String toString() {
        StringBuilder sbC = a.C("CaptureConfig{mCapturePoint=");
        sbC.append(this.mCapturePoint);
        sbC.append(", mCropRect=");
        sbC.append(this.mCropRect);
        sbC.append(", mStreamId=");
        sbC.append(this.mStreamId);
        sbC.append(", mOutputWidth=");
        sbC.append(this.mOutputWidth);
        sbC.append(", mOutputHeight=");
        sbC.append(this.mOutputHeight);
        sbC.append(", mOutputFramerate=");
        sbC.append(this.mOutputFramerate);
        sbC.append(", mOutputPitch=");
        sbC.append(this.mOutputPitch);
        sbC.append(", mRotateAngle=");
        sbC.append(this.mRotateAngle);
        sbC.append(", mExtInPortType=");
        sbC.append(this.mExtInPortType);
        sbC.append(", mExtInPortNum=");
        sbC.append((int) this.mExtInPortNum);
        sbC.append(", mOutputFormat=");
        sbC.append(this.mOutputFormat);
        sbC.append(", mOutputColorSpace=");
        sbC.append(this.mOutputColorSpace);
        sbC.append(", mStable=");
        sbC.append(this.mStable);
        sbC.append(", mDstDataRangeLimit=");
        sbC.append(this.mDstDataRangeLimit);
        sbC.append(", mCtsDebugEnabled=");
        return a.w(sbC, this.mCtsDebugEnabled, '}');
    }

    @Override // android.os.Parcelable
    public void writeToParcel(Parcel parcel, int i2) {
        parcel.writeParcelable(this.mCapturePoint, i2);
        parcel.writeInt(this.mStreamId);
        parcel.writeParcelable(this.mCropRect, i2);
        parcel.writeInt(this.mOutputWidth);
        parcel.writeInt(this.mOutputHeight);
        parcel.writeInt(this.mOutputFramerate);
        parcel.writeInt(this.mOutputPitch);
        parcel.writeInt(this.mRotateAngle);
        parcel.writeInt(this.mSubBufferNums);
        parcel.writeInt(this.mLimitBwType);
        parcel.writeByte(this.mExtInPortNum);
        parcel.writeParcelable(this.mOutputFormat, i2);
        parcel.writeParcelable(this.mOutputColorSpace, i2);
        parcel.writeParcelable(this.mExtInPortType, i2);
        parcel.writeByte(this.mStable ? (byte) 1 : (byte) 0);
        parcel.writeByte(this.mDstDataRangeLimit ? (byte) 1 : (byte) 0);
        parcel.writeByte(this.mCtsDebugEnabled ? (byte) 1 : (byte) 0);
    }
}