package androidx.media3.container;

import Z0.o;
import androidx.media3.common.ColorInfo;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.UnstableApi;
import java.nio.ByteBuffer;
import java.util.Arrays;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class NalUnitUtil {
    public static final int EXTENDED_SAR = 255;
    private static final int H264_NAL_UNIT_TYPE_SEI = 6;
    private static final int H264_NAL_UNIT_TYPE_SPS = 7;
    private static final int H265_NAL_UNIT_TYPE_PREFIX_SEI = 39;
    public static final int NAL_UNIT_TYPE_AUD = 9;
    public static final int NAL_UNIT_TYPE_IDR = 5;
    public static final int NAL_UNIT_TYPE_NON_IDR = 1;
    public static final int NAL_UNIT_TYPE_PARTITION_A = 2;
    public static final int NAL_UNIT_TYPE_PPS = 8;
    public static final int NAL_UNIT_TYPE_PREFIX = 14;
    public static final int NAL_UNIT_TYPE_SEI = 6;
    public static final int NAL_UNIT_TYPE_SPS = 7;
    private static final String TAG = "NalUnitUtil";
    public static final byte[] NAL_START_CODE = {0, 0, 0, 1};
    public static final float[] ASPECT_RATIO_IDC_VALUES = {1.0f, 1.0f, 1.0909091f, 0.90909094f, 1.4545455f, 1.2121212f, 2.1818182f, 1.8181819f, 2.909091f, 2.4242425f, 1.6363636f, 1.3636364f, 1.939394f, 1.6161616f, 1.3333334f, 1.5f, 2.0f};
    private static final Object scratchEscapePositionsLock = new Object();
    private static int[] scratchEscapePositions = new int[10];

    public static final class H265SpsData {
        public final int bitDepthChromaMinus8;
        public final int bitDepthLumaMinus8;
        public final int chromaFormatIdc;
        public final int colorRange;
        public final int colorSpace;
        public final int colorTransfer;
        public final int[] constraintBytes;
        public final int generalLevelIdc;
        public final int generalProfileCompatibilityFlags;
        public final int generalProfileIdc;
        public final int generalProfileSpace;
        public final boolean generalTierFlag;
        public final int height;
        public final int maxNumReorderPics;
        public final float pixelWidthHeightRatio;
        public final int seqParameterSetId;
        public final int width;

        public H265SpsData(int i6, boolean z6, int i7, int i8, int i9, int i10, int i11, int[] iArr, int i12, int i13, int i14, int i15, float f6, int i16, int i17, int i18, int i19) {
            this.generalProfileSpace = i6;
            this.generalTierFlag = z6;
            this.generalProfileIdc = i7;
            this.generalProfileCompatibilityFlags = i8;
            this.chromaFormatIdc = i9;
            this.bitDepthLumaMinus8 = i10;
            this.bitDepthChromaMinus8 = i11;
            this.constraintBytes = iArr;
            this.generalLevelIdc = i12;
            this.seqParameterSetId = i13;
            this.width = i14;
            this.height = i15;
            this.pixelWidthHeightRatio = f6;
            this.maxNumReorderPics = i16;
            this.colorSpace = i17;
            this.colorRange = i18;
            this.colorTransfer = i19;
        }
    }

    public static final class PpsData {
        public final boolean bottomFieldPicOrderInFramePresentFlag;
        public final int picParameterSetId;
        public final int seqParameterSetId;

        public PpsData(int i6, int i7, boolean z6) {
            this.picParameterSetId = i6;
            this.seqParameterSetId = i7;
            this.bottomFieldPicOrderInFramePresentFlag = z6;
        }
    }

    public static final class SpsData {
        public final int bitDepthChromaMinus8;
        public final int bitDepthLumaMinus8;
        public final int colorRange;
        public final int colorSpace;
        public final int colorTransfer;
        public final int constraintsFlagsAndReservedZero2Bits;
        public final boolean deltaPicOrderAlwaysZeroFlag;
        public final boolean frameMbsOnlyFlag;
        public final int frameNumLength;
        public final int height;
        public final int levelIdc;
        public final int maxNumRefFrames;
        public final int maxNumReorderFrames;
        public final int picOrderCntLsbLength;
        public final int picOrderCountType;
        public final float pixelWidthHeightRatio;
        public final int profileIdc;
        public final boolean separateColorPlaneFlag;
        public final int seqParameterSetId;
        public final int width;

        public SpsData(int i6, int i7, int i8, int i9, int i10, int i11, int i12, float f6, int i13, int i14, boolean z6, boolean z7, int i15, int i16, int i17, boolean z8, int i18, int i19, int i20, int i21) {
            this.profileIdc = i6;
            this.constraintsFlagsAndReservedZero2Bits = i7;
            this.levelIdc = i8;
            this.seqParameterSetId = i9;
            this.maxNumRefFrames = i10;
            this.width = i11;
            this.height = i12;
            this.pixelWidthHeightRatio = f6;
            this.bitDepthLumaMinus8 = i13;
            this.bitDepthChromaMinus8 = i14;
            this.separateColorPlaneFlag = z6;
            this.frameMbsOnlyFlag = z7;
            this.frameNumLength = i15;
            this.picOrderCountType = i16;
            this.picOrderCntLsbLength = i17;
            this.deltaPicOrderAlwaysZeroFlag = z8;
            this.colorSpace = i18;
            this.colorRange = i19;
            this.colorTransfer = i20;
            this.maxNumReorderFrames = i21;
        }
    }

    private NalUnitUtil() {
    }

    public static void clearPrefixFlags(boolean[] zArr) {
        zArr[0] = false;
        zArr[1] = false;
        zArr[2] = false;
    }

    public static void discardToSps(ByteBuffer byteBuffer) {
        int iPosition = byteBuffer.position();
        int i6 = 0;
        int i7 = 0;
        while (true) {
            int i8 = i6 + 1;
            if (i8 >= iPosition) {
                byteBuffer.clear();
                return;
            }
            int i9 = byteBuffer.get(i6) & 255;
            if (i7 == 3) {
                if (i9 == 1 && (byteBuffer.get(i8) & 31) == 7) {
                    ByteBuffer byteBufferDuplicate = byteBuffer.duplicate();
                    byteBufferDuplicate.position(i6 - 3);
                    byteBufferDuplicate.limit(iPosition);
                    byteBuffer.position(0);
                    byteBuffer.put(byteBufferDuplicate);
                    return;
                }
            } else if (i9 == 0) {
                i7++;
            }
            if (i9 != 0) {
                i7 = 0;
            }
            i6 = i8;
        }
    }

    public static int findNalUnit(byte[] bArr, int i6, int i7, boolean[] zArr) {
        int i8 = i7 - i6;
        Assertions.checkState(i8 >= 0);
        if (i8 == 0) {
            return i7;
        }
        if (zArr[0]) {
            clearPrefixFlags(zArr);
            return i6 - 3;
        }
        if (i8 > 1 && zArr[1] && bArr[i6] == 1) {
            clearPrefixFlags(zArr);
            return i6 - 2;
        }
        if (i8 > 2 && zArr[2] && bArr[i6] == 0 && bArr[i6 + 1] == 1) {
            clearPrefixFlags(zArr);
            return i6 - 1;
        }
        int i9 = i7 - 1;
        int i10 = i6 + 2;
        while (i10 < i9) {
            byte b5 = bArr[i10];
            if ((b5 & 254) == 0) {
                int i11 = i10 - 2;
                if (bArr[i11] == 0 && bArr[i10 - 1] == 0 && b5 == 1) {
                    clearPrefixFlags(zArr);
                    return i11;
                }
                i10 -= 2;
            }
            i10 += 3;
        }
        zArr[0] = i8 <= 2 ? !(i8 != 2 ? !(zArr[1] && bArr[i9] == 1) : !(zArr[2] && bArr[i7 + (-2)] == 0 && bArr[i9] == 1)) : bArr[i7 + (-3)] == 0 && bArr[i7 + (-2)] == 0 && bArr[i9] == 1;
        zArr[1] = i8 <= 1 ? zArr[2] && bArr[i9] == 0 : bArr[i7 + (-2)] == 0 && bArr[i9] == 0;
        zArr[2] = bArr[i9] == 0;
        return i7;
    }

    private static int findNextUnescapeIndex(byte[] bArr, int i6, int i7) {
        while (i6 < i7 - 2) {
            if (bArr[i6] == 0 && bArr[i6 + 1] == 0 && bArr[i6 + 2] == 3) {
                return i6;
            }
            i6++;
        }
        return i7;
    }

    public static int getH265NalUnitType(byte[] bArr, int i6) {
        return (bArr[i6 + 3] & 126) >> 1;
    }

    public static int getNalUnitType(byte[] bArr, int i6) {
        return bArr[i6 + 3] & 31;
    }

    public static boolean isNalUnitSei(String str, byte b5) {
        return (MimeTypes.VIDEO_H264.equals(str) && (b5 & 31) == 6) || (MimeTypes.VIDEO_H265.equals(str) && ((b5 & 126) >> 1) == H265_NAL_UNIT_TYPE_PREFIX_SEI);
    }

    public static H265SpsData parseH265SpsNalUnit(byte[] bArr, int i6, int i7) {
        return parseH265SpsNalUnitPayload(bArr, i6 + 2, i7);
    }

    public static H265SpsData parseH265SpsNalUnitPayload(byte[] bArr, int i6, int i7) {
        int i8;
        int i9;
        int i10;
        int i11;
        int i12;
        int i13;
        int iIsoTransferCharacteristicsToColorTransfer;
        int i14;
        ParsableNalUnitBitArray parsableNalUnitBitArray = new ParsableNalUnitBitArray(bArr, i6, i7);
        parsableNalUnitBitArray.skipBits(4);
        int bits = parsableNalUnitBitArray.readBits(3);
        parsableNalUnitBitArray.skipBit();
        int bits2 = parsableNalUnitBitArray.readBits(2);
        boolean bit = parsableNalUnitBitArray.readBit();
        int bits3 = parsableNalUnitBitArray.readBits(5);
        int i15 = 0;
        for (int i16 = 0; i16 < 32; i16++) {
            if (parsableNalUnitBitArray.readBit()) {
                i15 |= 1 << i16;
            }
        }
        int[] iArr = new int[6];
        for (int i17 = 0; i17 < 6; i17++) {
            iArr[i17] = parsableNalUnitBitArray.readBits(8);
        }
        int bits4 = parsableNalUnitBitArray.readBits(8);
        int i18 = 0;
        for (int i19 = 0; i19 < bits; i19++) {
            if (parsableNalUnitBitArray.readBit()) {
                i18 += 89;
            }
            if (parsableNalUnitBitArray.readBit()) {
                i18 += 8;
            }
        }
        parsableNalUnitBitArray.skipBits(i18);
        if (bits > 0) {
            parsableNalUnitBitArray.skipBits((8 - bits) * 2);
        }
        int unsignedExpGolombCodedInt = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        int unsignedExpGolombCodedInt2 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        if (unsignedExpGolombCodedInt2 == 3) {
            parsableNalUnitBitArray.skipBit();
        }
        int unsignedExpGolombCodedInt3 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        int unsignedExpGolombCodedInt4 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        if (parsableNalUnitBitArray.readBit()) {
            int unsignedExpGolombCodedInt5 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            int unsignedExpGolombCodedInt6 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            int unsignedExpGolombCodedInt7 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            int unsignedExpGolombCodedInt8 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            unsignedExpGolombCodedInt3 -= (unsignedExpGolombCodedInt5 + unsignedExpGolombCodedInt6) * ((unsignedExpGolombCodedInt2 == 1 || unsignedExpGolombCodedInt2 == 2) ? 2 : 1);
            unsignedExpGolombCodedInt4 -= (unsignedExpGolombCodedInt7 + unsignedExpGolombCodedInt8) * (unsignedExpGolombCodedInt2 == 1 ? 2 : 1);
        }
        int unsignedExpGolombCodedInt9 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        int unsignedExpGolombCodedInt10 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        int unsignedExpGolombCodedInt11 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        int iIsoColorPrimariesToColorSpace = -1;
        int iMax = -1;
        for (int i20 = parsableNalUnitBitArray.readBit() ? 0 : bits; i20 <= bits; i20++) {
            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            iMax = Math.max(parsableNalUnitBitArray.readUnsignedExpGolombCodedInt(), iMax);
            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        }
        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        if (parsableNalUnitBitArray.readBit() && parsableNalUnitBitArray.readBit()) {
            skipH265ScalingList(parsableNalUnitBitArray);
        }
        parsableNalUnitBitArray.skipBits(2);
        if (parsableNalUnitBitArray.readBit()) {
            parsableNalUnitBitArray.skipBits(8);
            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            parsableNalUnitBitArray.skipBit();
        }
        skipShortTermReferencePictureSets(parsableNalUnitBitArray);
        if (parsableNalUnitBitArray.readBit()) {
            int unsignedExpGolombCodedInt12 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            for (int i21 = 0; i21 < unsignedExpGolombCodedInt12; i21++) {
                parsableNalUnitBitArray.skipBits(unsignedExpGolombCodedInt11 + 5);
            }
        }
        parsableNalUnitBitArray.skipBits(2);
        float f6 = 1.0f;
        if (parsableNalUnitBitArray.readBit()) {
            if (parsableNalUnitBitArray.readBit()) {
                int bits5 = parsableNalUnitBitArray.readBits(8);
                if (bits5 == 255) {
                    int bits6 = parsableNalUnitBitArray.readBits(16);
                    int bits7 = parsableNalUnitBitArray.readBits(16);
                    if (bits6 != 0 && bits7 != 0) {
                        f6 = bits6 / bits7;
                    }
                } else {
                    float[] fArr = ASPECT_RATIO_IDC_VALUES;
                    if (bits5 < fArr.length) {
                        f6 = fArr[bits5];
                    } else {
                        o.v(bits5, "Unexpected aspect_ratio_idc value: ", TAG);
                    }
                }
            }
            if (parsableNalUnitBitArray.readBit()) {
                parsableNalUnitBitArray.skipBit();
            }
            if (parsableNalUnitBitArray.readBit()) {
                parsableNalUnitBitArray.skipBits(3);
                i14 = parsableNalUnitBitArray.readBit() ? 1 : 2;
                if (parsableNalUnitBitArray.readBit()) {
                    int bits8 = parsableNalUnitBitArray.readBits(8);
                    int bits9 = parsableNalUnitBitArray.readBits(8);
                    parsableNalUnitBitArray.skipBits(8);
                    iIsoColorPrimariesToColorSpace = ColorInfo.isoColorPrimariesToColorSpace(bits8);
                    iIsoTransferCharacteristicsToColorTransfer = ColorInfo.isoTransferCharacteristicsToColorTransfer(bits9);
                } else {
                    iIsoTransferCharacteristicsToColorTransfer = -1;
                }
            } else {
                iIsoTransferCharacteristicsToColorTransfer = -1;
                i14 = -1;
            }
            if (parsableNalUnitBitArray.readBit()) {
                parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            }
            parsableNalUnitBitArray.skipBit();
            if (parsableNalUnitBitArray.readBit()) {
                unsignedExpGolombCodedInt4 *= 2;
            }
            i13 = iIsoTransferCharacteristicsToColorTransfer;
            i12 = i14;
            i8 = unsignedExpGolombCodedInt;
            i9 = unsignedExpGolombCodedInt3;
            i10 = unsignedExpGolombCodedInt4;
            i11 = iIsoColorPrimariesToColorSpace;
        } else {
            i8 = unsignedExpGolombCodedInt;
            i9 = unsignedExpGolombCodedInt3;
            i10 = unsignedExpGolombCodedInt4;
            i11 = -1;
            i12 = -1;
            i13 = -1;
        }
        return new H265SpsData(bits2, bit, bits3, i15, unsignedExpGolombCodedInt2, unsignedExpGolombCodedInt9, unsignedExpGolombCodedInt10, iArr, bits4, i8, i9, i10, f6, iMax, i11, i12, i13);
    }

    public static PpsData parsePpsNalUnit(byte[] bArr, int i6, int i7) {
        return parsePpsNalUnitPayload(bArr, i6 + 1, i7);
    }

    public static PpsData parsePpsNalUnitPayload(byte[] bArr, int i6, int i7) {
        ParsableNalUnitBitArray parsableNalUnitBitArray = new ParsableNalUnitBitArray(bArr, i6, i7);
        int unsignedExpGolombCodedInt = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        int unsignedExpGolombCodedInt2 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        parsableNalUnitBitArray.skipBit();
        return new PpsData(unsignedExpGolombCodedInt, unsignedExpGolombCodedInt2, parsableNalUnitBitArray.readBit());
    }

    public static SpsData parseSpsNalUnit(byte[] bArr, int i6, int i7) {
        return parseSpsNalUnitPayload(bArr, i6 + 1, i7);
    }

    /* JADX WARN: Removed duplicated region for block: B:113:0x01dd  */
    /* JADX WARN: Removed duplicated region for block: B:116:0x01e9  */
    /* JADX WARN: Removed duplicated region for block: B:119:0x01f4  */
    /* JADX WARN: Removed duplicated region for block: B:122:0x01fd  */
    /* JADX WARN: Removed duplicated region for block: B:125:0x0204  */
    /* JADX WARN: Removed duplicated region for block: B:128:0x0210  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static SpsData parseSpsNalUnitPayload(byte[] bArr, int i6, int i7) {
        int unsignedExpGolombCodedInt;
        boolean bit;
        int unsignedExpGolombCodedInt2;
        int i8;
        int i9;
        int i10;
        int i11;
        boolean z6;
        int unsignedExpGolombCodedInt3;
        int i12;
        int i13;
        int i14;
        float f6;
        int i15;
        int i16;
        int i17;
        boolean z7;
        int i18;
        int i19;
        int i20;
        boolean bit2;
        boolean bit3;
        int i21;
        int i22;
        ParsableNalUnitBitArray parsableNalUnitBitArray = new ParsableNalUnitBitArray(bArr, i6, i7);
        int bits = parsableNalUnitBitArray.readBits(8);
        int bits2 = parsableNalUnitBitArray.readBits(8);
        int bits3 = parsableNalUnitBitArray.readBits(8);
        int unsignedExpGolombCodedInt4 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        if (bits == 100 || bits == 110 || bits == 122 || bits == 244 || bits == 44 || bits == 83 || bits == 86 || bits == 118 || bits == 128 || bits == 138) {
            unsignedExpGolombCodedInt = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            bit = unsignedExpGolombCodedInt == 3 ? parsableNalUnitBitArray.readBit() : false;
            unsignedExpGolombCodedInt2 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            int unsignedExpGolombCodedInt5 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            parsableNalUnitBitArray.skipBit();
            if (parsableNalUnitBitArray.readBit()) {
                int i23 = unsignedExpGolombCodedInt != 3 ? 8 : 12;
                i8 = 16;
                int i24 = 0;
                while (i24 < i23) {
                    if (parsableNalUnitBitArray.readBit()) {
                        skipScalingList(parsableNalUnitBitArray, i24 < 6 ? 16 : 64);
                    }
                    i24++;
                }
            } else {
                i8 = 16;
            }
            i9 = unsignedExpGolombCodedInt5;
        } else {
            unsignedExpGolombCodedInt = 1;
            i8 = 16;
            i9 = 0;
            bit = false;
            unsignedExpGolombCodedInt2 = 0;
        }
        int unsignedExpGolombCodedInt6 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt() + 4;
        int unsignedExpGolombCodedInt7 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        if (unsignedExpGolombCodedInt7 == 0) {
            unsignedExpGolombCodedInt3 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt() + 4;
            i10 = bits;
            i11 = unsignedExpGolombCodedInt7;
            z6 = false;
        } else {
            if (unsignedExpGolombCodedInt7 == 1) {
                boolean bit4 = parsableNalUnitBitArray.readBit();
                parsableNalUnitBitArray.readSignedExpGolombCodedInt();
                parsableNalUnitBitArray.readSignedExpGolombCodedInt();
                i10 = bits;
                long unsignedExpGolombCodedInt8 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                i11 = unsignedExpGolombCodedInt7;
                for (int i25 = 0; i25 < unsignedExpGolombCodedInt8; i25++) {
                    parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                }
                z6 = bit4;
            } else {
                i10 = bits;
                i11 = unsignedExpGolombCodedInt7;
                z6 = false;
            }
            unsignedExpGolombCodedInt3 = 0;
        }
        int unsignedExpGolombCodedInt9 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        parsableNalUnitBitArray.skipBit();
        int unsignedExpGolombCodedInt10 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt() + 1;
        int unsignedExpGolombCodedInt11 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt() + 1;
        boolean bit5 = parsableNalUnitBitArray.readBit();
        int i26 = (2 - (bit5 ? 1 : 0)) * unsignedExpGolombCodedInt11;
        if (!bit5) {
            parsableNalUnitBitArray.skipBit();
        }
        parsableNalUnitBitArray.skipBit();
        int i27 = unsignedExpGolombCodedInt10 * 16;
        int i28 = i26 * 16;
        if (parsableNalUnitBitArray.readBit()) {
            int unsignedExpGolombCodedInt12 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            int unsignedExpGolombCodedInt13 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            int unsignedExpGolombCodedInt14 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            int unsignedExpGolombCodedInt15 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            if (unsignedExpGolombCodedInt == 0) {
                i22 = 2 - (bit5 ? 1 : 0);
                i21 = 1;
            } else {
                i21 = unsignedExpGolombCodedInt == 3 ? 1 : 2;
                i22 = (unsignedExpGolombCodedInt == 1 ? 2 : 1) * (2 - (bit5 ? 1 : 0));
            }
            i27 -= (unsignedExpGolombCodedInt12 + unsignedExpGolombCodedInt13) * i21;
            i28 -= (unsignedExpGolombCodedInt14 + unsignedExpGolombCodedInt15) * i22;
        }
        int i29 = i27;
        int i30 = i10;
        int unsignedExpGolombCodedInt16 = ((i30 == 44 || i30 == 86 || i30 == 100 || i30 == 110 || i30 == 122 || i30 == 244) && (bits2 & 16) != 0) ? 0 : i8;
        float f7 = 1.0f;
        if (parsableNalUnitBitArray.readBit()) {
            if (parsableNalUnitBitArray.readBit()) {
                int bits4 = parsableNalUnitBitArray.readBits(8);
                if (bits4 == 255) {
                    int i31 = i8;
                    int bits5 = parsableNalUnitBitArray.readBits(i31);
                    int bits6 = parsableNalUnitBitArray.readBits(i31);
                    if (bits5 != 0 && bits6 != 0) {
                        f7 = bits5 / bits6;
                    }
                } else {
                    float[] fArr = ASPECT_RATIO_IDC_VALUES;
                    if (bits4 < fArr.length) {
                        f7 = fArr[bits4];
                    } else {
                        o.v(bits4, "Unexpected aspect_ratio_idc value: ", TAG);
                    }
                }
            }
            if (parsableNalUnitBitArray.readBit()) {
                parsableNalUnitBitArray.skipBit();
            }
            if (parsableNalUnitBitArray.readBit()) {
                parsableNalUnitBitArray.skipBits(3);
                i19 = parsableNalUnitBitArray.readBit() ? 1 : 2;
                if (parsableNalUnitBitArray.readBit()) {
                    int bits7 = parsableNalUnitBitArray.readBits(8);
                    int bits8 = parsableNalUnitBitArray.readBits(8);
                    parsableNalUnitBitArray.skipBits(8);
                    int iIsoColorPrimariesToColorSpace = ColorInfo.isoColorPrimariesToColorSpace(bits7);
                    int iIsoTransferCharacteristicsToColorTransfer = ColorInfo.isoTransferCharacteristicsToColorTransfer(bits8);
                    i20 = iIsoColorPrimariesToColorSpace;
                    i18 = iIsoTransferCharacteristicsToColorTransfer;
                    if (parsableNalUnitBitArray.readBit()) {
                        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                    }
                    if (parsableNalUnitBitArray.readBit()) {
                        parsableNalUnitBitArray.skipBits(65);
                    }
                    bit2 = parsableNalUnitBitArray.readBit();
                    if (bit2) {
                        skipHrdParameters(parsableNalUnitBitArray);
                    }
                    bit3 = parsableNalUnitBitArray.readBit();
                    if (bit3) {
                        skipHrdParameters(parsableNalUnitBitArray);
                    }
                    if (!bit2 || bit3) {
                        parsableNalUnitBitArray.skipBit();
                    }
                    parsableNalUnitBitArray.skipBit();
                    if (parsableNalUnitBitArray.readBit()) {
                        parsableNalUnitBitArray.skipBit();
                        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                        unsignedExpGolombCodedInt16 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                    }
                    i17 = i18;
                    i16 = i19;
                    i12 = unsignedExpGolombCodedInt16;
                    i13 = unsignedExpGolombCodedInt2;
                    i14 = unsignedExpGolombCodedInt3;
                    f6 = f7;
                    z7 = z6;
                    i15 = i20;
                } else {
                    i18 = -1;
                }
            } else {
                i18 = -1;
                i19 = -1;
            }
            i20 = -1;
            if (parsableNalUnitBitArray.readBit()) {
            }
            if (parsableNalUnitBitArray.readBit()) {
            }
            bit2 = parsableNalUnitBitArray.readBit();
            if (bit2) {
            }
            bit3 = parsableNalUnitBitArray.readBit();
            if (bit3) {
            }
            if (!bit2) {
                parsableNalUnitBitArray.skipBit();
                parsableNalUnitBitArray.skipBit();
                if (parsableNalUnitBitArray.readBit()) {
                }
                i17 = i18;
                i16 = i19;
                i12 = unsignedExpGolombCodedInt16;
                i13 = unsignedExpGolombCodedInt2;
                i14 = unsignedExpGolombCodedInt3;
                f6 = f7;
                z7 = z6;
                i15 = i20;
            }
        } else {
            i12 = unsignedExpGolombCodedInt16;
            i13 = unsignedExpGolombCodedInt2;
            i14 = unsignedExpGolombCodedInt3;
            f6 = 1.0f;
            i15 = -1;
            i16 = -1;
            i17 = -1;
            z7 = z6;
        }
        return new SpsData(i30, bits2, bits3, unsignedExpGolombCodedInt4, unsignedExpGolombCodedInt9, i29, i28, f6, i13, i9, bit, bit5, unsignedExpGolombCodedInt6, i11, i14, z7, i15, i16, i17, i12);
    }

    private static void skipH265ScalingList(ParsableNalUnitBitArray parsableNalUnitBitArray) {
        for (int i6 = 0; i6 < 4; i6++) {
            int i7 = 0;
            while (i7 < 6) {
                int i8 = 1;
                if (parsableNalUnitBitArray.readBit()) {
                    int iMin = Math.min(64, 1 << ((i6 << 1) + 4));
                    if (i6 > 1) {
                        parsableNalUnitBitArray.readSignedExpGolombCodedInt();
                    }
                    for (int i9 = 0; i9 < iMin; i9++) {
                        parsableNalUnitBitArray.readSignedExpGolombCodedInt();
                    }
                } else {
                    parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                }
                if (i6 == 3) {
                    i8 = 3;
                }
                i7 += i8;
            }
        }
    }

    private static void skipHrdParameters(ParsableNalUnitBitArray parsableNalUnitBitArray) {
        int unsignedExpGolombCodedInt = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt() + 1;
        parsableNalUnitBitArray.skipBits(8);
        for (int i6 = 0; i6 < unsignedExpGolombCodedInt; i6++) {
            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
            parsableNalUnitBitArray.skipBit();
        }
        parsableNalUnitBitArray.skipBits(20);
    }

    private static void skipScalingList(ParsableNalUnitBitArray parsableNalUnitBitArray, int i6) {
        int signedExpGolombCodedInt = 8;
        int i7 = 8;
        for (int i8 = 0; i8 < i6; i8++) {
            if (signedExpGolombCodedInt != 0) {
                signedExpGolombCodedInt = ((parsableNalUnitBitArray.readSignedExpGolombCodedInt() + i7) + 256) % 256;
            }
            if (signedExpGolombCodedInt != 0) {
                i7 = signedExpGolombCodedInt;
            }
        }
    }

    private static void skipShortTermReferencePictureSets(ParsableNalUnitBitArray parsableNalUnitBitArray) {
        int unsignedExpGolombCodedInt = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
        int[] iArr = new int[0];
        int[] iArrCopyOf = new int[0];
        int i6 = -1;
        int i7 = -1;
        for (int i8 = 0; i8 < unsignedExpGolombCodedInt; i8++) {
            if (i8 == 0 || !parsableNalUnitBitArray.readBit()) {
                int unsignedExpGolombCodedInt2 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                int unsignedExpGolombCodedInt3 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
                int[] iArr2 = new int[unsignedExpGolombCodedInt2];
                int i9 = 0;
                while (i9 < unsignedExpGolombCodedInt2) {
                    iArr2[i9] = (i9 > 0 ? iArr2[i9 - 1] : 0) - (parsableNalUnitBitArray.readUnsignedExpGolombCodedInt() + 1);
                    parsableNalUnitBitArray.skipBit();
                    i9++;
                }
                int[] iArr3 = new int[unsignedExpGolombCodedInt3];
                int i10 = 0;
                while (i10 < unsignedExpGolombCodedInt3) {
                    iArr3[i10] = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt() + 1 + (i10 > 0 ? iArr3[i10 - 1] : 0);
                    parsableNalUnitBitArray.skipBit();
                    i10++;
                }
                i6 = unsignedExpGolombCodedInt2;
                iArr = iArr2;
                i7 = unsignedExpGolombCodedInt3;
                iArrCopyOf = iArr3;
            } else {
                int i11 = i6 + i7;
                int unsignedExpGolombCodedInt4 = (1 - ((parsableNalUnitBitArray.readBit() ? 1 : 0) * 2)) * (parsableNalUnitBitArray.readUnsignedExpGolombCodedInt() + 1);
                int i12 = i11 + 1;
                boolean[] zArr = new boolean[i12];
                for (int i13 = 0; i13 <= i11; i13++) {
                    if (parsableNalUnitBitArray.readBit()) {
                        zArr[i13] = true;
                    } else {
                        zArr[i13] = parsableNalUnitBitArray.readBit();
                    }
                }
                int[] iArr4 = new int[i12];
                int[] iArr5 = new int[i12];
                int i14 = 0;
                for (int i15 = i7 - 1; i15 >= 0; i15--) {
                    int i16 = iArrCopyOf[i15] + unsignedExpGolombCodedInt4;
                    if (i16 < 0 && zArr[i6 + i15]) {
                        iArr4[i14] = i16;
                        i14++;
                    }
                }
                if (unsignedExpGolombCodedInt4 < 0 && zArr[i11]) {
                    iArr4[i14] = unsignedExpGolombCodedInt4;
                    i14++;
                }
                for (int i17 = 0; i17 < i6; i17++) {
                    int i18 = iArr[i17] + unsignedExpGolombCodedInt4;
                    if (i18 < 0 && zArr[i17]) {
                        iArr4[i14] = i18;
                        i14++;
                    }
                }
                int[] iArrCopyOf2 = Arrays.copyOf(iArr4, i14);
                int i19 = 0;
                for (int i20 = i6 - 1; i20 >= 0; i20--) {
                    int i21 = iArr[i20] + unsignedExpGolombCodedInt4;
                    if (i21 > 0 && zArr[i20]) {
                        iArr5[i19] = i21;
                        i19++;
                    }
                }
                if (unsignedExpGolombCodedInt4 > 0 && zArr[i11]) {
                    iArr5[i19] = unsignedExpGolombCodedInt4;
                    i19++;
                }
                for (int i22 = 0; i22 < i7; i22++) {
                    int i23 = iArrCopyOf[i22] + unsignedExpGolombCodedInt4;
                    if (i23 > 0 && zArr[i6 + i22]) {
                        iArr5[i19] = i23;
                        i19++;
                    }
                }
                iArrCopyOf = Arrays.copyOf(iArr5, i19);
                iArr = iArrCopyOf2;
                i6 = i14;
                i7 = i19;
            }
        }
    }

    public static int unescapeStream(byte[] bArr, int i6) {
        int i7;
        synchronized (scratchEscapePositionsLock) {
            int iFindNextUnescapeIndex = 0;
            int i8 = 0;
            while (iFindNextUnescapeIndex < i6) {
                try {
                    iFindNextUnescapeIndex = findNextUnescapeIndex(bArr, iFindNextUnescapeIndex, i6);
                    if (iFindNextUnescapeIndex < i6) {
                        int[] iArr = scratchEscapePositions;
                        if (iArr.length <= i8) {
                            scratchEscapePositions = Arrays.copyOf(iArr, iArr.length * 2);
                        }
                        scratchEscapePositions[i8] = iFindNextUnescapeIndex;
                        iFindNextUnescapeIndex += 3;
                        i8++;
                    }
                } catch (Throwable th) {
                    throw th;
                }
            }
            i7 = i6 - i8;
            int i9 = 0;
            int i10 = 0;
            for (int i11 = 0; i11 < i8; i11++) {
                int i12 = scratchEscapePositions[i11] - i10;
                System.arraycopy(bArr, i10, bArr, i9, i12);
                int i13 = i9 + i12;
                int i14 = i13 + 1;
                bArr[i13] = 0;
                i9 = i13 + 2;
                bArr[i14] = 0;
                i10 += i12 + 3;
            }
            System.arraycopy(bArr, i10, bArr, i9, i7 - i9);
        }
        return i7;
    }
}