package androidx.media3.exoplayer.video.spherical;

import androidx.media3.common.util.ParsableBitArray;
import androidx.media3.common.util.ParsableByteArray;
import androidx.media3.common.util.Util;
import androidx.media3.exoplayer.video.spherical.Projection;
import java.util.ArrayList;
import java.util.zip.Inflater;

/* JADX INFO: loaded from: classes.dex */
final class ProjectionDecoder {
    private static final int MAX_COORDINATE_COUNT = 10000;
    private static final int MAX_TRIANGLE_INDICES = 128000;
    private static final int MAX_VERTEX_COUNT = 32000;
    private static final int TYPE_DFL8 = 1684433976;
    private static final int TYPE_MESH = 1835365224;
    private static final int TYPE_MSHP = 1836279920;
    private static final int TYPE_PROJ = 1886547818;
    private static final int TYPE_RAW = 1918990112;
    private static final int TYPE_YTMP = 2037673328;

    private ProjectionDecoder() {
    }

    public static Projection decode(byte[] bArr, int i6) {
        ArrayList<Projection.Mesh> proj;
        ParsableByteArray parsableByteArray = new ParsableByteArray(bArr);
        try {
            proj = isProj(parsableByteArray) ? parseProj(parsableByteArray) : parseMshp(parsableByteArray);
        } catch (ArrayIndexOutOfBoundsException unused) {
            proj = null;
        }
        if (proj == null) {
            return null;
        }
        int size = proj.size();
        if (size == 1) {
            return new Projection(proj.get(0), i6);
        }
        if (size != 2) {
            return null;
        }
        return new Projection(proj.get(0), proj.get(1), i6);
    }

    private static int decodeZigZag(int i6) {
        return (-(i6 & 1)) ^ (i6 >> 1);
    }

    private static boolean isProj(ParsableByteArray parsableByteArray) {
        parsableByteArray.skipBytes(4);
        int i6 = parsableByteArray.readInt();
        parsableByteArray.setPosition(0);
        return i6 == 1886547818;
    }

    private static Projection.Mesh parseMesh(ParsableByteArray parsableByteArray) {
        int i6 = parsableByteArray.readInt();
        Projection.Mesh mesh = null;
        if (i6 > 10000) {
            return null;
        }
        float[] fArr = new float[i6];
        for (int i7 = 0; i7 < i6; i7++) {
            fArr[i7] = parsableByteArray.readFloat();
        }
        int i8 = parsableByteArray.readInt();
        if (i8 > MAX_VERTEX_COUNT) {
            return null;
        }
        double d6 = 2.0d;
        double dLog = Math.log(2.0d);
        int iCeil = (int) Math.ceil(Math.log(((double) i6) * 2.0d) / dLog);
        ParsableBitArray parsableBitArray = new ParsableBitArray(parsableByteArray.getData());
        int i9 = 8;
        parsableBitArray.setPosition(parsableByteArray.getPosition() * 8);
        float[] fArr2 = new float[i8 * 5];
        int[] iArr = new int[5];
        int i10 = 0;
        int i11 = 0;
        while (i10 < i8) {
            Projection.Mesh mesh2 = mesh;
            int i12 = 0;
            while (i12 < 5) {
                int iDecodeZigZag = iArr[i12] + decodeZigZag(parsableBitArray.readBits(iCeil));
                if (iDecodeZigZag >= i6 || iDecodeZigZag < 0) {
                    return mesh2;
                }
                fArr2[i11] = fArr[iDecodeZigZag];
                iArr[i12] = iDecodeZigZag;
                i12++;
                i11++;
            }
            i10++;
            mesh = mesh2;
        }
        Projection.Mesh mesh3 = mesh;
        parsableBitArray.setPosition((parsableBitArray.getPosition() + 7) & (-8));
        int i13 = 32;
        int bits = parsableBitArray.readBits(32);
        Projection.SubMesh[] subMeshArr = new Projection.SubMesh[bits];
        int i14 = 0;
        while (i14 < bits) {
            int bits2 = parsableBitArray.readBits(i9);
            int bits3 = parsableBitArray.readBits(i9);
            int bits4 = parsableBitArray.readBits(i13);
            if (bits4 > MAX_TRIANGLE_INDICES) {
                return mesh3;
            }
            int i15 = bits;
            int iCeil2 = (int) Math.ceil(Math.log(((double) i8) * d6) / dLog);
            float[] fArr3 = new float[bits4 * 3];
            float[] fArr4 = new float[bits4 * 2];
            int i16 = 0;
            int i17 = 0;
            while (i16 < bits4) {
                int iDecodeZigZag2 = i17 + decodeZigZag(parsableBitArray.readBits(iCeil2));
                if (iDecodeZigZag2 < 0 || iDecodeZigZag2 >= i8) {
                    return mesh3;
                }
                int i18 = i16 * 3;
                int i19 = iDecodeZigZag2 * 5;
                fArr3[i18] = fArr2[i19];
                fArr3[i18 + 1] = fArr2[i19 + 1];
                fArr3[i18 + 2] = fArr2[i19 + 2];
                int i20 = i16 * 2;
                fArr4[i20] = fArr2[i19 + 3];
                fArr4[i20 + 1] = fArr2[i19 + 4];
                i16++;
                i17 = iDecodeZigZag2;
            }
            subMeshArr[i14] = new Projection.SubMesh(bits2, fArr3, fArr4, bits3);
            i14++;
            bits = i15;
            i13 = 32;
            d6 = 2.0d;
            i9 = 8;
        }
        return new Projection.Mesh(subMeshArr);
    }

    private static ArrayList<Projection.Mesh> parseMshp(ParsableByteArray parsableByteArray) {
        if (parsableByteArray.readUnsignedByte() != 0) {
            return null;
        }
        parsableByteArray.skipBytes(7);
        int i6 = parsableByteArray.readInt();
        if (i6 == TYPE_DFL8) {
            ParsableByteArray parsableByteArray2 = new ParsableByteArray();
            Inflater inflater = new Inflater(true);
            try {
                if (!Util.inflate(parsableByteArray, parsableByteArray2, inflater)) {
                    return null;
                }
                inflater.end();
                parsableByteArray = parsableByteArray2;
            } finally {
                inflater.end();
            }
        } else if (i6 != TYPE_RAW) {
            return null;
        }
        return parseRawMshpData(parsableByteArray);
    }

    private static ArrayList<Projection.Mesh> parseProj(ParsableByteArray parsableByteArray) {
        int i6;
        parsableByteArray.skipBytes(8);
        int position = parsableByteArray.getPosition();
        int iLimit = parsableByteArray.limit();
        while (position < iLimit && (i6 = parsableByteArray.readInt() + position) > position && i6 <= iLimit) {
            int i7 = parsableByteArray.readInt();
            if (i7 == TYPE_YTMP || i7 == TYPE_MSHP) {
                parsableByteArray.setLimit(i6);
                return parseMshp(parsableByteArray);
            }
            parsableByteArray.setPosition(i6);
            position = i6;
        }
        return null;
    }

    private static ArrayList<Projection.Mesh> parseRawMshpData(ParsableByteArray parsableByteArray) {
        ArrayList<Projection.Mesh> arrayList = new ArrayList<>();
        int position = parsableByteArray.getPosition();
        int iLimit = parsableByteArray.limit();
        while (position < iLimit) {
            int i6 = parsableByteArray.readInt() + position;
            if (i6 <= position || i6 > iLimit) {
                return null;
            }
            if (parsableByteArray.readInt() == TYPE_MESH) {
                Projection.Mesh mesh = parseMesh(parsableByteArray);
                if (mesh == null) {
                    return null;
                }
                arrayList.add(mesh);
            }
            parsableByteArray.setPosition(i6);
            position = i6;
        }
        return arrayList;
    }
}