package androidx.media3.extractor.mkv;

import F3.O;
import F3.p0;
import android.util.Pair;
import android.util.SparseArray;
import androidx.media3.common.C;
import androidx.media3.common.ColorInfo;
import androidx.media3.common.DataReader;
import androidx.media3.common.DrmInitData;
import androidx.media3.common.Format;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.ParserException;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.LongArray;
import androidx.media3.common.util.ParsableByteArray;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.Util;
import androidx.media3.container.NalUnitUtil;
import androidx.media3.extractor.AacUtil;
import androidx.media3.extractor.AvcConfig;
import androidx.media3.extractor.ChunkIndex;
import androidx.media3.extractor.DolbyVisionConfig;
import androidx.media3.extractor.Extractor;
import androidx.media3.extractor.ExtractorInput;
import androidx.media3.extractor.ExtractorOutput;
import androidx.media3.extractor.ExtractorsFactory;
import androidx.media3.extractor.HevcConfig;
import androidx.media3.extractor.PositionHolder;
import androidx.media3.extractor.SeekMap;
import androidx.media3.extractor.TrackOutput;
import androidx.media3.extractor.TrueHdSampleRechunker;
import androidx.media3.extractor.text.SubtitleParser;
import androidx.media3.extractor.text.SubtitleTranscodingExtractorOutput;
import com.revenuecat.purchases.ui.revenuecatui.components.SensibleDefaults;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;
import q.AbstractC2761L;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public class MatroskaExtractor implements Extractor {
    private static final int BLOCK_ADDITIONAL_ID_VP9_ITU_T_35 = 4;
    private static final int BLOCK_ADD_ID_TYPE_DVCC = 1685480259;
    private static final int BLOCK_ADD_ID_TYPE_DVVC = 1685485123;
    private static final int BLOCK_STATE_DATA = 2;
    private static final int BLOCK_STATE_HEADER = 1;
    private static final int BLOCK_STATE_START = 0;
    private static final String CODEC_ID_AAC = "A_AAC";
    private static final String CODEC_ID_AC3 = "A_AC3";
    private static final String CODEC_ID_ACM = "A_MS/ACM";
    private static final String CODEC_ID_ASS = "S_TEXT/ASS";
    private static final String CODEC_ID_AV1 = "V_AV1";
    private static final String CODEC_ID_DTS = "A_DTS";
    private static final String CODEC_ID_DTS_EXPRESS = "A_DTS/EXPRESS";
    private static final String CODEC_ID_DTS_LOSSLESS = "A_DTS/LOSSLESS";
    private static final String CODEC_ID_DVBSUB = "S_DVBSUB";
    private static final String CODEC_ID_E_AC3 = "A_EAC3";
    private static final String CODEC_ID_FLAC = "A_FLAC";
    private static final String CODEC_ID_FOURCC = "V_MS/VFW/FOURCC";
    private static final String CODEC_ID_H264 = "V_MPEG4/ISO/AVC";
    private static final String CODEC_ID_H265 = "V_MPEGH/ISO/HEVC";
    private static final String CODEC_ID_MP2 = "A_MPEG/L2";
    private static final String CODEC_ID_MP3 = "A_MPEG/L3";
    private static final String CODEC_ID_MPEG2 = "V_MPEG2";
    private static final String CODEC_ID_MPEG4_AP = "V_MPEG4/ISO/AP";
    private static final String CODEC_ID_MPEG4_ASP = "V_MPEG4/ISO/ASP";
    private static final String CODEC_ID_MPEG4_SP = "V_MPEG4/ISO/SP";
    private static final String CODEC_ID_OPUS = "A_OPUS";
    private static final String CODEC_ID_PCM_FLOAT = "A_PCM/FLOAT/IEEE";
    private static final String CODEC_ID_PCM_INT_BIG = "A_PCM/INT/BIG";
    private static final String CODEC_ID_PCM_INT_LIT = "A_PCM/INT/LIT";
    private static final String CODEC_ID_PGS = "S_HDMV/PGS";
    private static final String CODEC_ID_SUBRIP = "S_TEXT/UTF8";
    private static final String CODEC_ID_THEORA = "V_THEORA";
    private static final String CODEC_ID_TRUEHD = "A_TRUEHD";
    private static final String CODEC_ID_VOBSUB = "S_VOBSUB";
    private static final String CODEC_ID_VORBIS = "A_VORBIS";
    private static final String CODEC_ID_VP8 = "V_VP8";
    private static final String CODEC_ID_VP9 = "V_VP9";
    private static final String CODEC_ID_VTT = "S_TEXT/WEBVTT";
    private static final String DOC_TYPE_MATROSKA = "matroska";
    private static final String DOC_TYPE_WEBM = "webm";
    private static final int ENCRYPTION_IV_SIZE = 8;
    public static final int FLAG_DISABLE_SEEK_FOR_CUES = 1;
    public static final int FLAG_EMIT_RAW_SUBTITLE_DATA = 2;
    private static final int FOURCC_COMPRESSION_DIVX = 1482049860;
    private static final int FOURCC_COMPRESSION_H263 = 859189832;
    private static final int FOURCC_COMPRESSION_VC1 = 826496599;
    private static final int ID_AUDIO = 225;
    private static final int ID_AUDIO_BIT_DEPTH = 25188;
    private static final int ID_BLOCK = 161;
    private static final int ID_BLOCK_ADDITIONAL = 165;
    private static final int ID_BLOCK_ADDITIONS = 30113;
    private static final int ID_BLOCK_ADDITION_MAPPING = 16868;
    private static final int ID_BLOCK_ADD_ID = 238;
    private static final int ID_BLOCK_ADD_ID_EXTRA_DATA = 16877;
    private static final int ID_BLOCK_ADD_ID_TYPE = 16871;
    private static final int ID_BLOCK_DURATION = 155;
    private static final int ID_BLOCK_GROUP = 160;
    private static final int ID_BLOCK_MORE = 166;
    private static final int ID_CHANNELS = 159;
    private static final int ID_CLUSTER = 524531317;
    private static final int ID_CODEC_DELAY = 22186;
    private static final int ID_CODEC_ID = 134;
    private static final int ID_CODEC_PRIVATE = 25506;
    private static final int ID_COLOUR = 21936;
    private static final int ID_COLOUR_BITS_PER_CHANNEL = 21938;
    private static final int ID_COLOUR_PRIMARIES = 21947;
    private static final int ID_COLOUR_RANGE = 21945;
    private static final int ID_COLOUR_TRANSFER = 21946;
    private static final int ID_CONTENT_COMPRESSION = 20532;
    private static final int ID_CONTENT_COMPRESSION_ALGORITHM = 16980;
    private static final int ID_CONTENT_COMPRESSION_SETTINGS = 16981;
    private static final int ID_CONTENT_ENCODING = 25152;
    private static final int ID_CONTENT_ENCODINGS = 28032;
    private static final int ID_CONTENT_ENCODING_ORDER = 20529;
    private static final int ID_CONTENT_ENCODING_SCOPE = 20530;
    private static final int ID_CONTENT_ENCRYPTION = 20533;
    private static final int ID_CONTENT_ENCRYPTION_AES_SETTINGS = 18407;
    private static final int ID_CONTENT_ENCRYPTION_AES_SETTINGS_CIPHER_MODE = 18408;
    private static final int ID_CONTENT_ENCRYPTION_ALGORITHM = 18401;
    private static final int ID_CONTENT_ENCRYPTION_KEY_ID = 18402;
    private static final int ID_CUES = 475249515;
    private static final int ID_CUE_CLUSTER_POSITION = 241;
    private static final int ID_CUE_POINT = 187;
    private static final int ID_CUE_TIME = 179;
    private static final int ID_CUE_TRACK_POSITIONS = 183;
    private static final int ID_DEFAULT_DURATION = 2352003;
    private static final int ID_DISCARD_PADDING = 30114;
    private static final int ID_DISPLAY_HEIGHT = 21690;
    private static final int ID_DISPLAY_UNIT = 21682;
    private static final int ID_DISPLAY_WIDTH = 21680;
    private static final int ID_DOC_TYPE = 17026;
    private static final int ID_DOC_TYPE_READ_VERSION = 17029;
    private static final int ID_DURATION = 17545;
    private static final int ID_EBML = 440786851;
    private static final int ID_EBML_READ_VERSION = 17143;
    private static final int ID_FLAG_DEFAULT = 136;
    private static final int ID_FLAG_FORCED = 21930;
    private static final int ID_INFO = 357149030;
    private static final int ID_LANGUAGE = 2274716;
    private static final int ID_LUMNINANCE_MAX = 21977;
    private static final int ID_LUMNINANCE_MIN = 21978;
    private static final int ID_MASTERING_METADATA = 21968;
    private static final int ID_MAX_BLOCK_ADDITION_ID = 21998;
    private static final int ID_MAX_CLL = 21948;
    private static final int ID_MAX_FALL = 21949;
    private static final int ID_NAME = 21358;
    private static final int ID_PIXEL_HEIGHT = 186;
    private static final int ID_PIXEL_WIDTH = 176;
    private static final int ID_PRIMARY_B_CHROMATICITY_X = 21973;
    private static final int ID_PRIMARY_B_CHROMATICITY_Y = 21974;
    private static final int ID_PRIMARY_G_CHROMATICITY_X = 21971;
    private static final int ID_PRIMARY_G_CHROMATICITY_Y = 21972;
    private static final int ID_PRIMARY_R_CHROMATICITY_X = 21969;
    private static final int ID_PRIMARY_R_CHROMATICITY_Y = 21970;
    private static final int ID_PROJECTION = 30320;
    private static final int ID_PROJECTION_POSE_PITCH = 30324;
    private static final int ID_PROJECTION_POSE_ROLL = 30325;
    private static final int ID_PROJECTION_POSE_YAW = 30323;
    private static final int ID_PROJECTION_PRIVATE = 30322;
    private static final int ID_PROJECTION_TYPE = 30321;
    private static final int ID_REFERENCE_BLOCK = 251;
    private static final int ID_SAMPLING_FREQUENCY = 181;
    private static final int ID_SEEK = 19899;
    private static final int ID_SEEK_HEAD = 290298740;
    private static final int ID_SEEK_ID = 21419;
    private static final int ID_SEEK_POSITION = 21420;
    private static final int ID_SEEK_PRE_ROLL = 22203;
    private static final int ID_SEGMENT = 408125543;
    private static final int ID_SEGMENT_INFO = 357149030;
    private static final int ID_SIMPLE_BLOCK = 163;
    private static final int ID_STEREO_MODE = 21432;
    private static final int ID_TIMECODE_SCALE = 2807729;
    private static final int ID_TIME_CODE = 231;
    private static final int ID_TRACKS = 374648427;
    private static final int ID_TRACK_ENTRY = 174;
    private static final int ID_TRACK_NUMBER = 215;
    private static final int ID_TRACK_TYPE = 131;
    private static final int ID_VIDEO = 224;
    private static final int ID_WHITE_POINT_CHROMATICITY_X = 21975;
    private static final int ID_WHITE_POINT_CHROMATICITY_Y = 21976;
    private static final int LACING_EBML = 3;
    private static final int LACING_FIXED_SIZE = 2;
    private static final int LACING_NONE = 0;
    private static final int LACING_XIPH = 1;
    private static final int OPUS_MAX_INPUT_SIZE = 5760;
    private static final int SSA_PREFIX_END_TIMECODE_OFFSET = 21;
    private static final String SSA_TIMECODE_FORMAT = "%01d:%02d:%02d:%02d";
    private static final long SSA_TIMECODE_LAST_VALUE_SCALING_FACTOR = 10000;
    private static final int SUBRIP_PREFIX_END_TIMECODE_OFFSET = 19;
    private static final String SUBRIP_TIMECODE_FORMAT = "%02d:%02d:%02d,%03d";
    private static final long SUBRIP_TIMECODE_LAST_VALUE_SCALING_FACTOR = 1000;
    private static final String TAG = "MatroskaExtractor";
    private static final Map<String, Integer> TRACK_NAME_TO_ROTATION_DEGREES;
    private static final int TRACK_TYPE_AUDIO = 2;
    private static final int UNSET_ENTRY_ID = -1;
    private static final int VORBIS_MAX_INPUT_SIZE = 8192;
    private static final int VTT_PREFIX_END_TIMECODE_OFFSET = 25;
    private static final String VTT_TIMECODE_FORMAT = "%02d:%02d:%02d.%03d";
    private static final long VTT_TIMECODE_LAST_VALUE_SCALING_FACTOR = 1000;
    private static final int WAVE_FORMAT_EXTENSIBLE = 65534;
    private static final int WAVE_FORMAT_PCM = 1;
    private static final int WAVE_FORMAT_SIZE = 18;
    private int blockAdditionalId;
    private long blockDurationUs;
    private int blockFlags;
    private long blockGroupDiscardPaddingNs;
    private boolean blockHasReferenceBlock;
    private int blockSampleCount;
    private int blockSampleIndex;
    private int[] blockSampleSizes;
    private int blockState;
    private long blockTimeUs;
    private int blockTrackNumber;
    private int blockTrackNumberLength;
    private long clusterTimecodeUs;
    private LongArray cueClusterPositions;
    private LongArray cueTimesUs;
    private long cuesContentPosition;
    private Track currentTrack;
    private long durationTimecode;
    private long durationUs;
    private final ParsableByteArray encryptionInitializationVector;
    private final ParsableByteArray encryptionSubsampleData;
    private ByteBuffer encryptionSubsampleDataBuffer;
    private ExtractorOutput extractorOutput;
    private boolean haveOutputSample;
    private final ParsableByteArray nalLength;
    private final ParsableByteArray nalStartCode;
    private final boolean parseSubtitlesDuringExtraction;
    private final EbmlReader reader;
    private int sampleBytesRead;
    private int sampleBytesWritten;
    private int sampleCurrentNalBytesRemaining;
    private boolean sampleEncodingHandled;
    private boolean sampleInitializationVectorRead;
    private int samplePartitionCount;
    private boolean samplePartitionCountRead;
    private byte sampleSignalByte;
    private boolean sampleSignalByteRead;
    private final ParsableByteArray sampleStrippedBytes;
    private final ParsableByteArray scratch;
    private int seekEntryId;
    private final ParsableByteArray seekEntryIdBytes;
    private long seekEntryPosition;
    private boolean seekForCues;
    private final boolean seekForCuesEnabled;
    private long seekPositionAfterBuildingCues;
    private boolean seenClusterPositionForCurrentCuePoint;
    private long segmentContentPosition;
    private long segmentContentSize;
    private boolean sentSeekMap;
    private final SubtitleParser.Factory subtitleParserFactory;
    private final ParsableByteArray subtitleSample;
    private final ParsableByteArray supplementalData;
    private long timecodeScale;
    private final SparseArray<Track> tracks;
    private final VarintReader varintReader;
    private final ParsableByteArray vorbisNumPageSamples;

    @Deprecated
    public static final ExtractorsFactory FACTORY = new androidx.media3.extractor.a(4);
    private static final byte[] SUBRIP_PREFIX = {49, 10, 48, 48, 58, 48, 48, 58, 48, 48, 44, 48, 48, 48, 32, 45, 45, 62, 32, 48, 48, 58, 48, 48, 58, 48, 48, 44, 48, 48, 48, 10};
    private static final byte[] SSA_DIALOGUE_FORMAT = Util.getUtf8Bytes("Format: Start, End, ReadOrder, Layer, Style, Name, MarginL, MarginR, MarginV, Effect, Text");
    private static final byte[] SSA_PREFIX = {68, 105, 97, 108, 111, 103, 117, 101, 58, 32, 48, 58, 48, 48, 58, 48, 48, 58, 48, 48, 44, 48, 58, 48, 48, 58, 48, 48, 58, 48, 48, 44};
    private static final byte[] VTT_PREFIX = {87, 69, 66, 86, 84, 84, 10, 10, 48, 48, 58, 48, 48, 58, 48, 48, 46, 48, 48, 48, 32, 45, 45, 62, 32, 48, 48, 58, 48, 48, 58, 48, 48, 46, 48, 48, 48, 10};
    private static final UUID WAVE_SUBFORMAT_PCM = new UUID(72057594037932032L, -9223371306706625679L);

    @Target({ElementType.TYPE_USE})
    @Documented
    @Retention(RetentionPolicy.SOURCE)
    public @interface Flags {
    }

    public final class InnerEbmlProcessor implements EbmlProcessor {
        private InnerEbmlProcessor() {
        }

        @Override // androidx.media3.extractor.mkv.EbmlProcessor
        public void binaryElement(int i6, int i7, ExtractorInput extractorInput) throws ParserException {
            MatroskaExtractor.this.binaryElement(i6, i7, extractorInput);
        }

        @Override // androidx.media3.extractor.mkv.EbmlProcessor
        public void endMasterElement(int i6) throws ParserException {
            MatroskaExtractor.this.endMasterElement(i6);
        }

        @Override // androidx.media3.extractor.mkv.EbmlProcessor
        public void floatElement(int i6, double d6) {
            MatroskaExtractor.this.floatElement(i6, d6);
        }

        @Override // androidx.media3.extractor.mkv.EbmlProcessor
        public int getElementType(int i6) {
            return MatroskaExtractor.this.getElementType(i6);
        }

        @Override // androidx.media3.extractor.mkv.EbmlProcessor
        public void integerElement(int i6, long j4) throws ParserException {
            MatroskaExtractor.this.integerElement(i6, j4);
        }

        @Override // androidx.media3.extractor.mkv.EbmlProcessor
        public boolean isLevel1Element(int i6) {
            return MatroskaExtractor.this.isLevel1Element(i6);
        }

        @Override // androidx.media3.extractor.mkv.EbmlProcessor
        public void startMasterElement(int i6, long j4, long j6) throws ParserException {
            MatroskaExtractor.this.startMasterElement(i6, j4, j6);
        }

        @Override // androidx.media3.extractor.mkv.EbmlProcessor
        public void stringElement(int i6, String str) throws ParserException {
            MatroskaExtractor.this.stringElement(i6, str);
        }
    }

    public static final class Track {
        private static final int DEFAULT_MAX_CLL = 1000;
        private static final int DEFAULT_MAX_FALL = 200;
        private static final int DISPLAY_UNIT_PIXELS = 0;
        private static final int MAX_CHROMATICITY = 50000;
        private int blockAddIdType;
        public String codecId;
        public byte[] codecPrivate;
        public TrackOutput.CryptoData cryptoData;
        public int defaultSampleDurationNs;
        public byte[] dolbyVisionConfigBytes;
        public DrmInitData drmInitData;
        public boolean flagForced;
        public boolean hasContentEncryption;
        public int maxBlockAdditionId;
        public int nalUnitLengthFieldLength;
        public String name;
        public int number;
        public TrackOutput output;
        public byte[] sampleStrippedBytes;
        public TrueHdSampleRechunker trueHdSampleRechunker;
        public int type;
        public int width = -1;
        public int height = -1;
        public int bitsPerChannel = -1;
        public int displayWidth = -1;
        public int displayHeight = -1;
        public int displayUnit = 0;
        public int projectionType = -1;
        public float projectionPoseYaw = 0.0f;
        public float projectionPosePitch = 0.0f;
        public float projectionPoseRoll = 0.0f;
        public byte[] projectionData = null;
        public int stereoMode = -1;
        public boolean hasColorInfo = false;
        public int colorSpace = -1;
        public int colorTransfer = -1;
        public int colorRange = -1;
        public int maxContentLuminance = 1000;
        public int maxFrameAverageLuminance = 200;
        public float primaryRChromaticityX = -1.0f;
        public float primaryRChromaticityY = -1.0f;
        public float primaryGChromaticityX = -1.0f;
        public float primaryGChromaticityY = -1.0f;
        public float primaryBChromaticityX = -1.0f;
        public float primaryBChromaticityY = -1.0f;
        public float whitePointChromaticityX = -1.0f;
        public float whitePointChromaticityY = -1.0f;
        public float maxMasteringLuminance = -1.0f;
        public float minMasteringLuminance = -1.0f;
        public int channelCount = 1;
        public int audioBitDepth = -1;
        public int sampleRate = 8000;
        public long codecDelayNs = 0;
        public long seekPreRollNs = 0;
        public boolean flagDefault = true;
        private String language = "eng";

        /* JADX INFO: Access modifiers changed from: private */
        public void assertOutputInitialized() {
            Assertions.checkNotNull(this.output);
        }

        private byte[] getCodecPrivate(String str) throws ParserException {
            byte[] bArr = this.codecPrivate;
            if (bArr != null) {
                return bArr;
            }
            throw ParserException.createForMalformedContainer("Missing CodecPrivate for codec " + str, null);
        }

        private byte[] getHdrStaticInfo() {
            if (this.primaryRChromaticityX == -1.0f || this.primaryRChromaticityY == -1.0f || this.primaryGChromaticityX == -1.0f || this.primaryGChromaticityY == -1.0f || this.primaryBChromaticityX == -1.0f || this.primaryBChromaticityY == -1.0f || this.whitePointChromaticityX == -1.0f || this.whitePointChromaticityY == -1.0f || this.maxMasteringLuminance == -1.0f || this.minMasteringLuminance == -1.0f) {
                return null;
            }
            byte[] bArr = new byte[25];
            ByteBuffer byteBufferOrder = ByteBuffer.wrap(bArr).order(ByteOrder.LITTLE_ENDIAN);
            byteBufferOrder.put((byte) 0);
            byteBufferOrder.putShort((short) ((this.primaryRChromaticityX * 50000.0f) + 0.5f));
            byteBufferOrder.putShort((short) ((this.primaryRChromaticityY * 50000.0f) + 0.5f));
            byteBufferOrder.putShort((short) ((this.primaryGChromaticityX * 50000.0f) + 0.5f));
            byteBufferOrder.putShort((short) ((this.primaryGChromaticityY * 50000.0f) + 0.5f));
            byteBufferOrder.putShort((short) ((this.primaryBChromaticityX * 50000.0f) + 0.5f));
            byteBufferOrder.putShort((short) ((this.primaryBChromaticityY * 50000.0f) + 0.5f));
            byteBufferOrder.putShort((short) ((this.whitePointChromaticityX * 50000.0f) + 0.5f));
            byteBufferOrder.putShort((short) ((this.whitePointChromaticityY * 50000.0f) + 0.5f));
            byteBufferOrder.putShort((short) (this.maxMasteringLuminance + 0.5f));
            byteBufferOrder.putShort((short) (this.minMasteringLuminance + 0.5f));
            byteBufferOrder.putShort((short) this.maxContentLuminance);
            byteBufferOrder.putShort((short) this.maxFrameAverageLuminance);
            return bArr;
        }

        private static Pair<String, List<byte[]>> parseFourCcPrivate(ParsableByteArray parsableByteArray) throws ParserException {
            try {
                parsableByteArray.skipBytes(16);
                long littleEndianUnsignedInt = parsableByteArray.readLittleEndianUnsignedInt();
                if (littleEndianUnsignedInt == 1482049860) {
                    return new Pair<>(MimeTypes.VIDEO_DIVX, null);
                }
                if (littleEndianUnsignedInt == 859189832) {
                    return new Pair<>(MimeTypes.VIDEO_H263, null);
                }
                if (littleEndianUnsignedInt != 826496599) {
                    Log.w(MatroskaExtractor.TAG, "Unknown FourCC. Setting mimeType to video/x-unknown");
                    return new Pair<>(MimeTypes.VIDEO_UNKNOWN, null);
                }
                byte[] data = parsableByteArray.getData();
                for (int position = parsableByteArray.getPosition() + 20; position < data.length - 4; position++) {
                    if (data[position] == 0 && data[position + 1] == 0 && data[position + 2] == 1 && data[position + 3] == 15) {
                        return new Pair<>(MimeTypes.VIDEO_VC1, Collections.singletonList(Arrays.copyOfRange(data, position, data.length)));
                    }
                }
                throw ParserException.createForMalformedContainer("Failed to find FourCC VC1 initialization data", null);
            } catch (ArrayIndexOutOfBoundsException unused) {
                throw ParserException.createForMalformedContainer("Error parsing FourCC private data", null);
            }
        }

        private static boolean parseMsAcmCodecPrivate(ParsableByteArray parsableByteArray) throws ParserException {
            try {
                int littleEndianUnsignedShort = parsableByteArray.readLittleEndianUnsignedShort();
                if (littleEndianUnsignedShort == 1) {
                    return true;
                }
                if (littleEndianUnsignedShort == 65534) {
                    parsableByteArray.setPosition(24);
                    if (parsableByteArray.readLong() == MatroskaExtractor.WAVE_SUBFORMAT_PCM.getMostSignificantBits()) {
                        if (parsableByteArray.readLong() == MatroskaExtractor.WAVE_SUBFORMAT_PCM.getLeastSignificantBits()) {
                            return true;
                        }
                    }
                }
                return false;
            } catch (ArrayIndexOutOfBoundsException unused) {
                throw ParserException.createForMalformedContainer("Error parsing MS/ACM codec private", null);
            }
        }

        private static List<byte[]> parseVorbisCodecPrivate(byte[] bArr) throws ParserException {
            int i6;
            int i7;
            try {
                if (bArr[0] != 2) {
                    throw ParserException.createForMalformedContainer("Error parsing vorbis codec private", null);
                }
                int i8 = 0;
                int i9 = 1;
                while (true) {
                    i6 = bArr[i9];
                    if ((i6 & 255) != 255) {
                        break;
                    }
                    i8 += 255;
                    i9++;
                }
                int i10 = i9 + 1;
                int i11 = i8 + (i6 & 255);
                int i12 = 0;
                while (true) {
                    i7 = bArr[i10];
                    if ((i7 & 255) != 255) {
                        break;
                    }
                    i12 += 255;
                    i10++;
                }
                int i13 = i10 + 1;
                int i14 = i12 + (i7 & 255);
                if (bArr[i13] != 1) {
                    throw ParserException.createForMalformedContainer("Error parsing vorbis codec private", null);
                }
                byte[] bArr2 = new byte[i11];
                System.arraycopy(bArr, i13, bArr2, 0, i11);
                int i15 = i13 + i11;
                if (bArr[i15] != 3) {
                    throw ParserException.createForMalformedContainer("Error parsing vorbis codec private", null);
                }
                int i16 = i15 + i14;
                if (bArr[i16] != 5) {
                    throw ParserException.createForMalformedContainer("Error parsing vorbis codec private", null);
                }
                byte[] bArr3 = new byte[bArr.length - i16];
                System.arraycopy(bArr, i16, bArr3, 0, bArr.length - i16);
                ArrayList arrayList = new ArrayList(2);
                arrayList.add(bArr2);
                arrayList.add(bArr3);
                return arrayList;
            } catch (ArrayIndexOutOfBoundsException unused) {
                throw ParserException.createForMalformedContainer("Error parsing vorbis codec private", null);
            }
        }

        /* JADX INFO: Access modifiers changed from: private */
        public boolean samplesHaveSupplementalData(boolean z6) {
            return MatroskaExtractor.CODEC_ID_OPUS.equals(this.codecId) ? z6 : this.maxBlockAdditionId > 0;
        }

        /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
        /* JADX WARN: Removed duplicated region for block: B:210:0x0408  */
        /* JADX WARN: Removed duplicated region for block: B:215:0x0421  */
        /* JADX WARN: Removed duplicated region for block: B:216:0x0423  */
        /* JADX WARN: Removed duplicated region for block: B:219:0x0430  */
        /* JADX WARN: Removed duplicated region for block: B:220:0x0442  */
        /* JADX WARN: Removed duplicated region for block: B:267:0x0516  */
        /* JADX WARN: Removed duplicated region for block: B:287:0x056d  */
        /* JADX WARN: Removed duplicated region for block: B:4:0x002a  */
        /*
            Code decompiled incorrectly, please refer to instructions dump.
        */
        public void initializeOutput(ExtractorOutput extractorOutput, int i6) throws ParserException {
            String str;
            int i7;
            List<byte[]> list;
            String str2;
            int i8;
            List<byte[]> list2;
            int i9;
            List<byte[]> list3;
            List<byte[]> list4;
            List<byte[]> list5;
            String str3;
            List<byte[]> list6;
            int pcmEncoding;
            List<byte[]> list7;
            List<byte[]> list8;
            String str4;
            Format.Builder builder;
            int i10;
            int iIntValue;
            int i11;
            DolbyVisionConfig dolbyVisionConfig;
            String str5 = this.codecId;
            str5.getClass();
            str = MimeTypes.AUDIO_RAW;
            switch (str5) {
                case "V_MPEG4/ISO/AP":
                case "V_MPEG4/ISO/SP":
                case "V_MPEG4/ISO/ASP":
                    i7 = 0;
                    byte[] bArr = this.codecPrivate;
                    List<byte[]> listSingletonList = bArr == null ? null : Collections.singletonList(bArr);
                    str = MimeTypes.VIDEO_MP4V;
                    list4 = listSingletonList;
                    str2 = null;
                    list = list4;
                    i8 = -1;
                    list2 = list;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null && (dolbyVisionConfig = DolbyVisionConfig.parse(new ParsableByteArray(this.dolbyVisionConfigBytes))) != null) {
                        str2 = dolbyVisionConfig.codecs;
                        str = MimeTypes.VIDEO_DOLBY_VISION;
                    }
                    str4 = str;
                    int i12 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                        builder.setChannelCount(this.channelCount).setSampleRate(this.sampleRate).setPcmEncoding(i8);
                        i10 = 1;
                    } else if (MimeTypes.isVideo(str4)) {
                        if (this.displayUnit == 0) {
                            int i13 = this.displayWidth;
                            iIntValue = -1;
                            if (i13 == -1) {
                                i13 = this.width;
                            }
                            this.displayWidth = i13;
                            int i14 = this.displayHeight;
                            if (i14 == -1) {
                                i14 = this.height;
                            }
                            this.displayHeight = i14;
                        } else {
                            iIntValue = -1;
                        }
                        float f6 = (this.displayWidth == iIntValue || (i11 = this.displayHeight) == iIntValue) ? -1.0f : (this.height * r4) / (this.width * i11);
                        ColorInfo colorInfoBuild = this.hasColorInfo ? new ColorInfo.Builder().setColorSpace(this.colorSpace).setColorRange(this.colorRange).setColorTransfer(this.colorTransfer).setHdrStaticInfo(getHdrStaticInfo()).setLumaBitdepth(this.bitsPerChannel).setChromaBitdepth(this.bitsPerChannel).build() : null;
                        if (this.name != null && MatroskaExtractor.TRACK_NAME_TO_ROTATION_DEGREES.containsKey(this.name)) {
                            iIntValue = ((Integer) MatroskaExtractor.TRACK_NAME_TO_ROTATION_DEGREES.get(this.name)).intValue();
                        }
                        if (this.projectionType == 0 && Float.compare(this.projectionPoseYaw, 0.0f) == 0 && Float.compare(this.projectionPosePitch, 0.0f) == 0) {
                            if (Float.compare(this.projectionPoseRoll, 0.0f) != 0) {
                                if (Float.compare(this.projectionPoseRoll, 90.0f) == 0) {
                                    i7 = 90;
                                } else if (Float.compare(this.projectionPoseRoll, -180.0f) == 0 || Float.compare(this.projectionPoseRoll, 180.0f) == 0) {
                                    i7 = SensibleDefaults.X_OFFSET;
                                } else if (Float.compare(this.projectionPoseRoll, -90.0f) == 0) {
                                    i7 = 270;
                                }
                            }
                            builder.setWidth(this.width).setHeight(this.height).setPixelWidthHeightRatio(f6).setRotationDegrees(i7).setProjectionData(this.projectionData).setStereoMode(this.stereoMode).setColorInfo(colorInfoBuild);
                            i10 = 2;
                        } else {
                            i7 = iIntValue;
                            builder.setWidth(this.width).setHeight(this.height).setPixelWidthHeightRatio(f6).setRotationDegrees(i7).setProjectionData(this.projectionData).setStereoMode(this.stereoMode).setColorInfo(colorInfoBuild);
                            i10 = 2;
                        }
                    } else {
                        if (!MimeTypes.APPLICATION_SUBRIP.equals(str4) && !MimeTypes.TEXT_SSA.equals(str4) && !MimeTypes.TEXT_VTT.equals(str4) && !MimeTypes.APPLICATION_VOBSUB.equals(str4) && !MimeTypes.APPLICATION_PGS.equals(str4) && !MimeTypes.APPLICATION_DVBSUBS.equals(str4)) {
                            throw ParserException.createForMalformedContainer("Unexpected MIME type.", null);
                        }
                        i10 = 3;
                    }
                    if (this.name != null && !MatroskaExtractor.TRACK_NAME_TO_ROTATION_DEGREES.containsKey(this.name)) {
                        builder.setLabel(this.name);
                    }
                    Format formatBuild = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack;
                    trackOutputTrack.format(formatBuild);
                    return;
                case "A_MS/ACM":
                    i7 = 0;
                    if (parseMsAcmCodecPrivate(new ParsableByteArray(getCodecPrivate(this.codecId)))) {
                        int pcmEncoding2 = Util.getPcmEncoding(this.audioBitDepth);
                        if (pcmEncoding2 != 0) {
                            i8 = pcmEncoding2;
                            list2 = null;
                            str2 = null;
                            i9 = -1;
                            list3 = list2;
                            if (this.dolbyVisionConfigBytes != null) {
                                str2 = dolbyVisionConfig.codecs;
                                str = MimeTypes.VIDEO_DOLBY_VISION;
                            }
                            str4 = str;
                            int i122 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                            builder = new Format.Builder();
                            if (MimeTypes.isAudio(str4)) {
                            }
                            if (this.name != null) {
                                builder.setLabel(this.name);
                            }
                            Format formatBuild2 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                            TrackOutput trackOutputTrack2 = extractorOutput.track(this.number, i10);
                            this.output = trackOutputTrack2;
                            trackOutputTrack2.format(formatBuild2);
                            return;
                        }
                        Log.w(MatroskaExtractor.TAG, "Unsupported PCM bit depth: " + this.audioBitDepth + ". Setting mimeType to audio/x-unknown");
                    } else {
                        Log.w(MatroskaExtractor.TAG, "Non-PCM MS/ACM is unsupported. Setting mimeType to audio/x-unknown");
                    }
                    list = null;
                    str2 = null;
                    str = MimeTypes.AUDIO_UNKNOWN;
                    i8 = -1;
                    list2 = list;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22;
                    trackOutputTrack22.format(formatBuild22);
                    return;
                case "A_TRUEHD":
                    i7 = 0;
                    this.trueHdSampleRechunker = new TrueHdSampleRechunker();
                    str = MimeTypes.AUDIO_TRUEHD;
                    list = null;
                    str2 = null;
                    i8 = -1;
                    list2 = list;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222;
                    trackOutputTrack222.format(formatBuild222);
                    return;
                case "A_VORBIS":
                    i7 = 0;
                    List<byte[]> vorbisCodecPrivate = parseVorbisCodecPrivate(getCodecPrivate(this.codecId));
                    str = MimeTypes.AUDIO_VORBIS;
                    i9 = 8192;
                    str2 = null;
                    i8 = -1;
                    list3 = vorbisCodecPrivate;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222;
                    trackOutputTrack2222.format(formatBuild2222);
                    return;
                case "A_MPEG/L2":
                    i7 = 0;
                    str = MimeTypes.AUDIO_MPEG_L2;
                    list3 = null;
                    str2 = null;
                    i8 = -1;
                    i9 = 4096;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22222;
                    trackOutputTrack22222.format(formatBuild22222);
                    return;
                case "A_MPEG/L3":
                    i7 = 0;
                    str = MimeTypes.AUDIO_MPEG;
                    list3 = null;
                    str2 = null;
                    i8 = -1;
                    i9 = 4096;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222;
                    trackOutputTrack222222.format(formatBuild222222);
                    return;
                case "V_MS/VFW/FOURCC":
                    i7 = 0;
                    Pair<String, List<byte[]>> fourCcPrivate = parseFourCcPrivate(new ParsableByteArray(getCodecPrivate(this.codecId)));
                    str = (String) fourCcPrivate.first;
                    list4 = (List) fourCcPrivate.second;
                    str2 = null;
                    list = list4;
                    i8 = -1;
                    list2 = list;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222222;
                    trackOutputTrack2222222.format(formatBuild2222222);
                    return;
                case "S_DVBSUB":
                    byte[] bArr2 = new byte[4];
                    i7 = 0;
                    System.arraycopy(getCodecPrivate(this.codecId), 0, bArr2, 0, 4);
                    p0 p0VarU = O.u(bArr2);
                    str = MimeTypes.APPLICATION_DVBSUBS;
                    list4 = p0VarU;
                    str2 = null;
                    list = list4;
                    i8 = -1;
                    list2 = list;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22222222;
                    trackOutputTrack22222222.format(formatBuild22222222);
                    return;
                case "V_MPEG4/ISO/AVC":
                    AvcConfig avcConfig = AvcConfig.parse(new ParsableByteArray(getCodecPrivate(this.codecId)));
                    list5 = avcConfig.initializationData;
                    this.nalUnitLengthFieldLength = avcConfig.nalUnitLengthFieldLength;
                    str3 = avcConfig.codecs;
                    str = MimeTypes.VIDEO_H264;
                    List<byte[]> list9 = list5;
                    str2 = str3;
                    list7 = list9;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222;
                    trackOutputTrack222222222.format(formatBuild222222222);
                    return;
                case "S_VOBSUB":
                    p0 p0VarU2 = O.u(getCodecPrivate(this.codecId));
                    str = MimeTypes.APPLICATION_VOBSUB;
                    list8 = p0VarU2;
                    str2 = null;
                    list7 = list8;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222222222;
                    trackOutputTrack2222222222.format(formatBuild2222222222);
                    return;
                case "A_DTS/LOSSLESS":
                    str = MimeTypes.AUDIO_DTS_HD;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22222222222;
                    trackOutputTrack22222222222.format(formatBuild22222222222);
                    return;
                case "A_AAC":
                    List<byte[]> listSingletonList2 = Collections.singletonList(getCodecPrivate(this.codecId));
                    AacUtil.Config audioSpecificConfig = AacUtil.parseAudioSpecificConfig(this.codecPrivate);
                    this.sampleRate = audioSpecificConfig.sampleRateHz;
                    this.channelCount = audioSpecificConfig.channelCount;
                    str2 = audioSpecificConfig.codecs;
                    str = MimeTypes.AUDIO_AAC;
                    list7 = listSingletonList2;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222222;
                    trackOutputTrack222222222222.format(formatBuild222222222222);
                    return;
                case "A_AC3":
                    str = MimeTypes.AUDIO_AC3;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222222222222;
                    trackOutputTrack2222222222222.format(formatBuild2222222222222);
                    return;
                case "A_DTS":
                case "A_DTS/EXPRESS":
                    str = MimeTypes.AUDIO_DTS;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22222222222222;
                    trackOutputTrack22222222222222.format(formatBuild22222222222222);
                    return;
                case "V_AV1":
                    str = MimeTypes.VIDEO_AV1;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222222222;
                    trackOutputTrack222222222222222.format(formatBuild222222222222222);
                    return;
                case "V_VP8":
                    str = MimeTypes.VIDEO_VP8;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222222222222222;
                    trackOutputTrack2222222222222222.format(formatBuild2222222222222222);
                    return;
                case "V_VP9":
                    str = MimeTypes.VIDEO_VP9;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22222222222222222;
                    trackOutputTrack22222222222222222.format(formatBuild22222222222222222);
                    return;
                case "S_HDMV/PGS":
                    str = MimeTypes.APPLICATION_PGS;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222222222222;
                    trackOutputTrack222222222222222222.format(formatBuild222222222222222222);
                    return;
                case "V_THEORA":
                    str = MimeTypes.VIDEO_UNKNOWN;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222222222222222222;
                    trackOutputTrack2222222222222222222.format(formatBuild2222222222222222222);
                    return;
                case "A_PCM/FLOAT/IEEE":
                    if (this.audioBitDepth == 32) {
                        list6 = null;
                        str2 = null;
                        i8 = 4;
                        i7 = 0;
                        list2 = list6;
                        i9 = -1;
                        list3 = list2;
                        if (this.dolbyVisionConfigBytes != null) {
                        }
                        str4 = str;
                        int i1222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                        builder = new Format.Builder();
                        if (MimeTypes.isAudio(str4)) {
                        }
                        if (this.name != null) {
                        }
                        Format formatBuild22222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                        TrackOutput trackOutputTrack22222222222222222222 = extractorOutput.track(this.number, i10);
                        this.output = trackOutputTrack22222222222222222222;
                        trackOutputTrack22222222222222222222.format(formatBuild22222222222222222222);
                        return;
                    }
                    Log.w(MatroskaExtractor.TAG, "Unsupported floating point PCM bit depth: " + this.audioBitDepth + ". Setting mimeType to audio/x-unknown");
                    list7 = null;
                    str2 = null;
                    str = MimeTypes.AUDIO_UNKNOWN;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222222222222222;
                    trackOutputTrack222222222222222222222.format(formatBuild222222222222222222222);
                    return;
                case "A_PCM/INT/BIG":
                    int i15 = this.audioBitDepth;
                    if (i15 == 8) {
                        i8 = 3;
                        list6 = null;
                        str2 = null;
                        i7 = 0;
                        list2 = list6;
                        i9 = -1;
                        list3 = list2;
                        if (this.dolbyVisionConfigBytes != null) {
                        }
                        str4 = str;
                        int i122222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                        builder = new Format.Builder();
                        if (MimeTypes.isAudio(str4)) {
                        }
                        if (this.name != null) {
                        }
                        Format formatBuild2222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                        TrackOutput trackOutputTrack2222222222222222222222 = extractorOutput.track(this.number, i10);
                        this.output = trackOutputTrack2222222222222222222222;
                        trackOutputTrack2222222222222222222222.format(formatBuild2222222222222222222222);
                        return;
                    }
                    if (i15 == 16) {
                        pcmEncoding = 268435456;
                    } else if (i15 == 24) {
                        pcmEncoding = C.ENCODING_PCM_24BIT_BIG_ENDIAN;
                    } else {
                        if (i15 != 32) {
                            Log.w(MatroskaExtractor.TAG, "Unsupported big endian PCM bit depth: " + this.audioBitDepth + ". Setting mimeType to audio/x-unknown");
                            list7 = null;
                            str2 = null;
                            str = MimeTypes.AUDIO_UNKNOWN;
                            i8 = -1;
                            list6 = list7;
                            i7 = 0;
                            list2 = list6;
                            i9 = -1;
                            list3 = list2;
                            if (this.dolbyVisionConfigBytes != null) {
                            }
                            str4 = str;
                            int i1222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                            builder = new Format.Builder();
                            if (MimeTypes.isAudio(str4)) {
                            }
                            if (this.name != null) {
                            }
                            Format formatBuild22222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                            TrackOutput trackOutputTrack22222222222222222222222 = extractorOutput.track(this.number, i10);
                            this.output = trackOutputTrack22222222222222222222222;
                            trackOutputTrack22222222222222222222222.format(formatBuild22222222222222222222222);
                            return;
                        }
                        pcmEncoding = C.ENCODING_PCM_32BIT_BIG_ENDIAN;
                    }
                    i8 = pcmEncoding;
                    list6 = null;
                    str2 = null;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222222222222222222;
                    trackOutputTrack222222222222222222222222.format(formatBuild222222222222222222222222);
                    return;
                case "A_PCM/INT/LIT":
                    pcmEncoding = Util.getPcmEncoding(this.audioBitDepth);
                    if (pcmEncoding == 0) {
                        Log.w(MatroskaExtractor.TAG, "Unsupported little endian PCM bit depth: " + this.audioBitDepth + ". Setting mimeType to audio/x-unknown");
                        list7 = null;
                        str2 = null;
                        str = MimeTypes.AUDIO_UNKNOWN;
                        i8 = -1;
                        list6 = list7;
                        i7 = 0;
                        list2 = list6;
                        i9 = -1;
                        list3 = list2;
                        if (this.dolbyVisionConfigBytes != null) {
                        }
                        str4 = str;
                        int i122222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                        builder = new Format.Builder();
                        if (MimeTypes.isAudio(str4)) {
                        }
                        if (this.name != null) {
                        }
                        Format formatBuild2222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                        TrackOutput trackOutputTrack2222222222222222222222222 = extractorOutput.track(this.number, i10);
                        this.output = trackOutputTrack2222222222222222222222222;
                        trackOutputTrack2222222222222222222222222.format(formatBuild2222222222222222222222222);
                        return;
                    }
                    i8 = pcmEncoding;
                    list6 = null;
                    str2 = null;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22222222222222222222222222;
                    trackOutputTrack22222222222222222222222222.format(formatBuild22222222222222222222222222);
                    return;
                case "S_TEXT/ASS":
                    p0 p0VarV = O.v(MatroskaExtractor.SSA_DIALOGUE_FORMAT, getCodecPrivate(this.codecId));
                    str = MimeTypes.TEXT_SSA;
                    list8 = p0VarV;
                    str2 = null;
                    list7 = list8;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222222222222222222222;
                    trackOutputTrack222222222222222222222222222.format(formatBuild222222222222222222222222222);
                    return;
                case "V_MPEGH/ISO/HEVC":
                    HevcConfig hevcConfig = HevcConfig.parse(new ParsableByteArray(getCodecPrivate(this.codecId)));
                    list5 = hevcConfig.initializationData;
                    this.nalUnitLengthFieldLength = hevcConfig.nalUnitLengthFieldLength;
                    str3 = hevcConfig.codecs;
                    str = MimeTypes.VIDEO_H265;
                    List<byte[]> list92 = list5;
                    str2 = str3;
                    list7 = list92;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222222222222222222222222222;
                    trackOutputTrack2222222222222222222222222222.format(formatBuild2222222222222222222222222222);
                    return;
                case "S_TEXT/WEBVTT":
                    str = MimeTypes.TEXT_VTT;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22222222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22222222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22222222222222222222222222222;
                    trackOutputTrack22222222222222222222222222222.format(formatBuild22222222222222222222222222222);
                    return;
                case "S_TEXT/UTF8":
                    str = MimeTypes.APPLICATION_SUBRIP;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222222222222222222222222;
                    trackOutputTrack222222222222222222222222222222.format(formatBuild222222222222222222222222222222);
                    return;
                case "V_MPEG2":
                    str = MimeTypes.VIDEO_MPEG2;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222222222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222222222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222222222222222222222222222222;
                    trackOutputTrack2222222222222222222222222222222.format(formatBuild2222222222222222222222222222222);
                    return;
                case "A_EAC3":
                    str = MimeTypes.AUDIO_E_AC3;
                    list7 = null;
                    str2 = null;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i1222222222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild22222222222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i1222222222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack22222222222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack22222222222222222222222222222222;
                    trackOutputTrack22222222222222222222222222222222.format(formatBuild22222222222222222222222222222222);
                    return;
                case "A_FLAC":
                    List<byte[]> listSingletonList3 = Collections.singletonList(getCodecPrivate(this.codecId));
                    str = MimeTypes.AUDIO_FLAC;
                    list8 = listSingletonList3;
                    str2 = null;
                    list7 = list8;
                    i8 = -1;
                    list6 = list7;
                    i7 = 0;
                    list2 = list6;
                    i9 = -1;
                    list3 = list2;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i12222222222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild222222222222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i12222222222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack222222222222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack222222222222222222222222222222222;
                    trackOutputTrack222222222222222222222222222222222.format(formatBuild222222222222222222222222222222222);
                    return;
                case "A_OPUS":
                    ArrayList arrayList = new ArrayList(3);
                    arrayList.add(getCodecPrivate(this.codecId));
                    ByteBuffer byteBufferAllocate = ByteBuffer.allocate(8);
                    ByteOrder byteOrder = ByteOrder.LITTLE_ENDIAN;
                    arrayList.add(byteBufferAllocate.order(byteOrder).putLong(this.codecDelayNs).array());
                    arrayList.add(ByteBuffer.allocate(8).order(byteOrder).putLong(this.seekPreRollNs).array());
                    str = MimeTypes.AUDIO_OPUS;
                    i9 = MatroskaExtractor.OPUS_MAX_INPUT_SIZE;
                    str2 = null;
                    i8 = -1;
                    i7 = 0;
                    list3 = arrayList;
                    if (this.dolbyVisionConfigBytes != null) {
                    }
                    str4 = str;
                    int i122222222222222222222222222222222222 = (this.flagForced ? 2 : i7) | (this.flagDefault ? 1 : 0);
                    builder = new Format.Builder();
                    if (MimeTypes.isAudio(str4)) {
                    }
                    if (this.name != null) {
                    }
                    Format formatBuild2222222222222222222222222222222222 = builder.setId(i6).setSampleMimeType(str4).setMaxInputSize(i9).setLanguage(this.language).setSelectionFlags(i122222222222222222222222222222222222).setInitializationData(list3).setCodecs(str2).setDrmInitData(this.drmInitData).build();
                    TrackOutput trackOutputTrack2222222222222222222222222222222222 = extractorOutput.track(this.number, i10);
                    this.output = trackOutputTrack2222222222222222222222222222222222;
                    trackOutputTrack2222222222222222222222222222222222.format(formatBuild2222222222222222222222222222222222);
                    return;
                default:
                    throw ParserException.createForMalformedContainer("Unrecognized codec identifier.", null);
            }
        }

        public void outputPendingSampleMetadata() {
            TrueHdSampleRechunker trueHdSampleRechunker = this.trueHdSampleRechunker;
            if (trueHdSampleRechunker != null) {
                trueHdSampleRechunker.outputPendingSampleMetadata(this.output, this.cryptoData);
            }
        }

        public void reset() {
            TrueHdSampleRechunker trueHdSampleRechunker = this.trueHdSampleRechunker;
            if (trueHdSampleRechunker != null) {
                trueHdSampleRechunker.reset();
            }
        }
    }

    static {
        HashMap map = new HashMap();
        AbstractC2761L.m(0, map, "htc_video_rotA-000", 90, "htc_video_rotA-090");
        AbstractC2761L.m(SensibleDefaults.X_OFFSET, map, "htc_video_rotA-180", 270, "htc_video_rotA-270");
        TRACK_NAME_TO_ROTATION_DEGREES = Collections.unmodifiableMap(map);
    }

    @Deprecated
    public MatroskaExtractor() {
        this(new DefaultEbmlReader(), 2, SubtitleParser.Factory.UNSUPPORTED);
    }

    private void assertInCues(int i6) throws ParserException {
        if (this.cueTimesUs == null || this.cueClusterPositions == null) {
            throw ParserException.createForMalformedContainer("Element " + i6 + " must be in a Cues", null);
        }
    }

    private void assertInTrackEntry(int i6) throws ParserException {
        if (this.currentTrack != null) {
            return;
        }
        throw ParserException.createForMalformedContainer("Element " + i6 + " must be in a TrackEntry", null);
    }

    private void assertInitialized() {
        Assertions.checkStateNotNull(this.extractorOutput);
    }

    private SeekMap buildSeekMap(LongArray longArray, LongArray longArray2) {
        int i6;
        if (this.segmentContentPosition == -1 || this.durationUs == C.TIME_UNSET || longArray == null || longArray.size() == 0 || longArray2 == null || longArray2.size() != longArray.size()) {
            return new SeekMap.Unseekable(this.durationUs);
        }
        int size = longArray.size();
        int[] iArrCopyOf = new int[size];
        long[] jArrCopyOf = new long[size];
        long[] jArrCopyOf2 = new long[size];
        long[] jArrCopyOf3 = new long[size];
        int i7 = 0;
        for (int i8 = 0; i8 < size; i8++) {
            jArrCopyOf3[i8] = longArray.get(i8);
            jArrCopyOf[i8] = longArray2.get(i8) + this.segmentContentPosition;
        }
        while (true) {
            i6 = size - 1;
            if (i7 >= i6) {
                break;
            }
            int i9 = i7 + 1;
            iArrCopyOf[i7] = (int) (jArrCopyOf[i9] - jArrCopyOf[i7]);
            jArrCopyOf2[i7] = jArrCopyOf3[i9] - jArrCopyOf3[i7];
            i7 = i9;
        }
        iArrCopyOf[i6] = (int) ((this.segmentContentPosition + this.segmentContentSize) - jArrCopyOf[i6]);
        long j4 = this.durationUs - jArrCopyOf3[i6];
        jArrCopyOf2[i6] = j4;
        if (j4 <= 0) {
            Log.w(TAG, "Discarding last cue point with unexpected duration: " + j4);
            iArrCopyOf = Arrays.copyOf(iArrCopyOf, i6);
            jArrCopyOf = Arrays.copyOf(jArrCopyOf, i6);
            jArrCopyOf2 = Arrays.copyOf(jArrCopyOf2, i6);
            jArrCopyOf3 = Arrays.copyOf(jArrCopyOf3, i6);
        }
        return new ChunkIndex(iArrCopyOf, jArrCopyOf, jArrCopyOf2, jArrCopyOf3);
    }

    /* JADX WARN: Removed duplicated region for block: B:28:0x009e  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private void commitSampleToOutput(Track track, long j4, int i6, int i7, int i8) {
        int iLimit;
        TrueHdSampleRechunker trueHdSampleRechunker = track.trueHdSampleRechunker;
        if (trueHdSampleRechunker != null) {
            trueHdSampleRechunker.sampleMetadata(track.output, j4, i6, i7, i8, track.cryptoData);
        } else if (CODEC_ID_SUBRIP.equals(track.codecId) || CODEC_ID_ASS.equals(track.codecId) || CODEC_ID_VTT.equals(track.codecId)) {
            if (this.blockSampleCount > 1) {
                Log.w(TAG, "Skipping subtitle sample in laced block.");
            } else {
                long j6 = this.blockDurationUs;
                if (j6 == C.TIME_UNSET) {
                    Log.w(TAG, "Skipping subtitle sample with no duration.");
                } else {
                    setSubtitleEndTime(track.codecId, j6, this.subtitleSample.getData());
                    int position = this.subtitleSample.getPosition();
                    while (true) {
                        if (position >= this.subtitleSample.limit()) {
                            break;
                        }
                        if (this.subtitleSample.getData()[position] == 0) {
                            this.subtitleSample.setLimit(position);
                            break;
                        }
                        position++;
                    }
                    TrackOutput trackOutput = track.output;
                    ParsableByteArray parsableByteArray = this.subtitleSample;
                    trackOutput.sampleData(parsableByteArray, parsableByteArray.limit());
                    iLimit = this.subtitleSample.limit() + i7;
                    if ((i6 & 268435456) != 0) {
                        if (this.blockSampleCount > 1) {
                            this.supplementalData.reset(0);
                        } else {
                            int iLimit2 = this.supplementalData.limit();
                            track.output.sampleData(this.supplementalData, iLimit2, 2);
                            iLimit += iLimit2;
                        }
                    }
                    track.output.sampleMetadata(j4, i6, iLimit, i8, track.cryptoData);
                }
            }
            iLimit = i7;
            if ((i6 & 268435456) != 0) {
            }
            track.output.sampleMetadata(j4, i6, iLimit, i8, track.cryptoData);
        } else {
            iLimit = i7;
            if ((i6 & 268435456) != 0) {
            }
            track.output.sampleMetadata(j4, i6, iLimit, i8, track.cryptoData);
        }
        this.haveOutputSample = true;
    }

    private static int[] ensureArrayCapacity(int[] iArr, int i6) {
        return iArr == null ? new int[i6] : iArr.length >= i6 ? iArr : new int[Math.max(iArr.length * 2, i6)];
    }

    private int finishWriteSampleData() {
        int i6 = this.sampleBytesWritten;
        resetWriteSampleData();
        return i6;
    }

    private static byte[] formatSubtitleTimecode(long j4, String str, long j6) {
        Assertions.checkArgument(j4 != C.TIME_UNSET);
        int i6 = (int) (j4 / 3600000000L);
        long j7 = j4 - (((long) i6) * 3600000000L);
        int i7 = (int) (j7 / 60000000);
        long j8 = j7 - (((long) i7) * 60000000);
        int i8 = (int) (j8 / 1000000);
        return Util.getUtf8Bytes(String.format(Locale.US, str, Integer.valueOf(i6), Integer.valueOf(i7), Integer.valueOf(i8), Integer.valueOf((int) ((j8 - (((long) i8) * 1000000)) / j6))));
    }

    private static boolean isCodecSupported(String str) {
        str.getClass();
        switch (str) {
            case "V_MPEG4/ISO/AP":
            case "V_MPEG4/ISO/SP":
            case "A_MS/ACM":
            case "A_TRUEHD":
            case "A_VORBIS":
            case "A_MPEG/L2":
            case "A_MPEG/L3":
            case "V_MS/VFW/FOURCC":
            case "S_DVBSUB":
            case "V_MPEG4/ISO/ASP":
            case "V_MPEG4/ISO/AVC":
            case "S_VOBSUB":
            case "A_DTS/LOSSLESS":
            case "A_AAC":
            case "A_AC3":
            case "A_DTS":
            case "V_AV1":
            case "V_VP8":
            case "V_VP9":
            case "S_HDMV/PGS":
            case "V_THEORA":
            case "A_DTS/EXPRESS":
            case "A_PCM/FLOAT/IEEE":
            case "A_PCM/INT/BIG":
            case "A_PCM/INT/LIT":
            case "S_TEXT/ASS":
            case "V_MPEGH/ISO/HEVC":
            case "S_TEXT/WEBVTT":
            case "S_TEXT/UTF8":
            case "V_MPEG2":
            case "A_EAC3":
            case "A_FLAC":
            case "A_OPUS":
                return true;
            default:
                return false;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Extractor[] lambda$newFactory$0(SubtitleParser.Factory factory) {
        return new Extractor[]{new MatroskaExtractor(factory)};
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Extractor[] lambda$static$1() {
        return new Extractor[]{new MatroskaExtractor(SubtitleParser.Factory.UNSUPPORTED, 2)};
    }

    private boolean maybeSeekForCues(PositionHolder positionHolder, long j4) {
        if (this.seekForCues) {
            this.seekPositionAfterBuildingCues = j4;
            positionHolder.position = this.cuesContentPosition;
            this.seekForCues = false;
            return true;
        }
        if (this.sentSeekMap) {
            long j6 = this.seekPositionAfterBuildingCues;
            if (j6 != -1) {
                positionHolder.position = j6;
                this.seekPositionAfterBuildingCues = -1L;
                return true;
            }
        }
        return false;
    }

    public static ExtractorsFactory newFactory(SubtitleParser.Factory factory) {
        return new a(factory, 0);
    }

    private void readScratch(ExtractorInput extractorInput, int i6) {
        if (this.scratch.limit() >= i6) {
            return;
        }
        if (this.scratch.capacity() < i6) {
            ParsableByteArray parsableByteArray = this.scratch;
            parsableByteArray.ensureCapacity(Math.max(parsableByteArray.capacity() * 2, i6));
        }
        extractorInput.readFully(this.scratch.getData(), this.scratch.limit(), i6 - this.scratch.limit());
        this.scratch.setLimit(i6);
    }

    private void resetWriteSampleData() {
        this.sampleBytesRead = 0;
        this.sampleBytesWritten = 0;
        this.sampleCurrentNalBytesRemaining = 0;
        this.sampleEncodingHandled = false;
        this.sampleSignalByteRead = false;
        this.samplePartitionCountRead = false;
        this.samplePartitionCount = 0;
        this.sampleSignalByte = (byte) 0;
        this.sampleInitializationVectorRead = false;
        this.sampleStrippedBytes.reset(0);
    }

    private long scaleTimecodeToUs(long j4) throws ParserException {
        long j6 = this.timecodeScale;
        if (j6 != C.TIME_UNSET) {
            return Util.scaleLargeTimestamp(j4, j6, 1000L);
        }
        throw ParserException.createForMalformedContainer("Can't scale timecode prior to timecodeScale being set.", null);
    }

    private static void setSubtitleEndTime(String str, long j4, byte[] bArr) {
        byte[] subtitleTimecode;
        int i6;
        str.getClass();
        switch (str) {
            case "S_TEXT/ASS":
                subtitleTimecode = formatSubtitleTimecode(j4, SSA_TIMECODE_FORMAT, 10000L);
                i6 = 21;
                break;
            case "S_TEXT/WEBVTT":
                subtitleTimecode = formatSubtitleTimecode(j4, VTT_TIMECODE_FORMAT, 1000L);
                i6 = 25;
                break;
            case "S_TEXT/UTF8":
                subtitleTimecode = formatSubtitleTimecode(j4, SUBRIP_TIMECODE_FORMAT, 1000L);
                i6 = 19;
                break;
            default:
                throw new IllegalArgumentException();
        }
        System.arraycopy(subtitleTimecode, 0, bArr, i6, subtitleTimecode.length);
    }

    private int writeSampleData(ExtractorInput extractorInput, Track track, int i6, boolean z6) throws ParserException {
        int i7;
        if (CODEC_ID_SUBRIP.equals(track.codecId)) {
            writeSubtitleSampleData(extractorInput, SUBRIP_PREFIX, i6);
            return finishWriteSampleData();
        }
        if (CODEC_ID_ASS.equals(track.codecId)) {
            writeSubtitleSampleData(extractorInput, SSA_PREFIX, i6);
            return finishWriteSampleData();
        }
        if (CODEC_ID_VTT.equals(track.codecId)) {
            writeSubtitleSampleData(extractorInput, VTT_PREFIX, i6);
            return finishWriteSampleData();
        }
        TrackOutput trackOutput = track.output;
        if (!this.sampleEncodingHandled) {
            if (track.hasContentEncryption) {
                this.blockFlags &= -1073741825;
                if (!this.sampleSignalByteRead) {
                    extractorInput.readFully(this.scratch.getData(), 0, 1);
                    this.sampleBytesRead++;
                    if ((this.scratch.getData()[0] & 128) == 128) {
                        throw ParserException.createForMalformedContainer("Extension bit is set in signal byte", null);
                    }
                    this.sampleSignalByte = this.scratch.getData()[0];
                    this.sampleSignalByteRead = true;
                }
                byte b5 = this.sampleSignalByte;
                if ((b5 & 1) == 1) {
                    boolean z7 = (b5 & 2) == 2;
                    this.blockFlags |= 1073741824;
                    if (!this.sampleInitializationVectorRead) {
                        extractorInput.readFully(this.encryptionInitializationVector.getData(), 0, 8);
                        this.sampleBytesRead += 8;
                        this.sampleInitializationVectorRead = true;
                        this.scratch.getData()[0] = (byte) ((z7 ? 128 : 0) | 8);
                        this.scratch.setPosition(0);
                        trackOutput.sampleData(this.scratch, 1, 1);
                        this.sampleBytesWritten++;
                        this.encryptionInitializationVector.setPosition(0);
                        trackOutput.sampleData(this.encryptionInitializationVector, 8, 1);
                        this.sampleBytesWritten += 8;
                    }
                    if (z7) {
                        if (!this.samplePartitionCountRead) {
                            extractorInput.readFully(this.scratch.getData(), 0, 1);
                            this.sampleBytesRead++;
                            this.scratch.setPosition(0);
                            this.samplePartitionCount = this.scratch.readUnsignedByte();
                            this.samplePartitionCountRead = true;
                        }
                        int i8 = this.samplePartitionCount * 4;
                        this.scratch.reset(i8);
                        extractorInput.readFully(this.scratch.getData(), 0, i8);
                        this.sampleBytesRead += i8;
                        short s6 = (short) ((this.samplePartitionCount / 2) + 1);
                        int i9 = (s6 * 6) + 2;
                        ByteBuffer byteBuffer = this.encryptionSubsampleDataBuffer;
                        if (byteBuffer == null || byteBuffer.capacity() < i9) {
                            this.encryptionSubsampleDataBuffer = ByteBuffer.allocate(i9);
                        }
                        this.encryptionSubsampleDataBuffer.position(0);
                        this.encryptionSubsampleDataBuffer.putShort(s6);
                        int i10 = 0;
                        int i11 = 0;
                        while (true) {
                            i7 = this.samplePartitionCount;
                            if (i10 >= i7) {
                                break;
                            }
                            int unsignedIntToInt = this.scratch.readUnsignedIntToInt();
                            if (i10 % 2 == 0) {
                                this.encryptionSubsampleDataBuffer.putShort((short) (unsignedIntToInt - i11));
                            } else {
                                this.encryptionSubsampleDataBuffer.putInt(unsignedIntToInt - i11);
                            }
                            i10++;
                            i11 = unsignedIntToInt;
                        }
                        int i12 = (i6 - this.sampleBytesRead) - i11;
                        if (i7 % 2 == 1) {
                            this.encryptionSubsampleDataBuffer.putInt(i12);
                        } else {
                            this.encryptionSubsampleDataBuffer.putShort((short) i12);
                            this.encryptionSubsampleDataBuffer.putInt(0);
                        }
                        this.encryptionSubsampleData.reset(this.encryptionSubsampleDataBuffer.array(), i9);
                        trackOutput.sampleData(this.encryptionSubsampleData, i9, 1);
                        this.sampleBytesWritten += i9;
                    }
                }
            } else {
                byte[] bArr = track.sampleStrippedBytes;
                if (bArr != null) {
                    this.sampleStrippedBytes.reset(bArr, bArr.length);
                }
            }
            if (track.samplesHaveSupplementalData(z6)) {
                this.blockFlags |= 268435456;
                this.supplementalData.reset(0);
                int iLimit = (this.sampleStrippedBytes.limit() + i6) - this.sampleBytesRead;
                this.scratch.reset(4);
                this.scratch.getData()[0] = (byte) ((iLimit >> 24) & 255);
                this.scratch.getData()[1] = (byte) ((iLimit >> 16) & 255);
                this.scratch.getData()[2] = (byte) ((iLimit >> 8) & 255);
                this.scratch.getData()[3] = (byte) (iLimit & 255);
                trackOutput.sampleData(this.scratch, 4, 2);
                this.sampleBytesWritten += 4;
            }
            this.sampleEncodingHandled = true;
        }
        int iLimit2 = this.sampleStrippedBytes.limit() + i6;
        if (!CODEC_ID_H264.equals(track.codecId) && !CODEC_ID_H265.equals(track.codecId)) {
            if (track.trueHdSampleRechunker != null) {
                Assertions.checkState(this.sampleStrippedBytes.limit() == 0);
                track.trueHdSampleRechunker.startSample(extractorInput);
            }
            while (true) {
                int i13 = this.sampleBytesRead;
                if (i13 >= iLimit2) {
                    break;
                }
                int iWriteToOutput = writeToOutput(extractorInput, trackOutput, iLimit2 - i13);
                this.sampleBytesRead += iWriteToOutput;
                this.sampleBytesWritten += iWriteToOutput;
            }
        } else {
            byte[] data = this.nalLength.getData();
            data[0] = 0;
            data[1] = 0;
            data[2] = 0;
            int i14 = track.nalUnitLengthFieldLength;
            int i15 = 4 - i14;
            while (this.sampleBytesRead < iLimit2) {
                int i16 = this.sampleCurrentNalBytesRemaining;
                if (i16 == 0) {
                    writeToTarget(extractorInput, data, i15, i14);
                    this.sampleBytesRead += i14;
                    this.nalLength.setPosition(0);
                    this.sampleCurrentNalBytesRemaining = this.nalLength.readUnsignedIntToInt();
                    this.nalStartCode.setPosition(0);
                    trackOutput.sampleData(this.nalStartCode, 4);
                    this.sampleBytesWritten += 4;
                } else {
                    int iWriteToOutput2 = writeToOutput(extractorInput, trackOutput, i16);
                    this.sampleBytesRead += iWriteToOutput2;
                    this.sampleBytesWritten += iWriteToOutput2;
                    this.sampleCurrentNalBytesRemaining -= iWriteToOutput2;
                }
            }
        }
        if (CODEC_ID_VORBIS.equals(track.codecId)) {
            this.vorbisNumPageSamples.setPosition(0);
            trackOutput.sampleData(this.vorbisNumPageSamples, 4);
            this.sampleBytesWritten += 4;
        }
        return finishWriteSampleData();
    }

    private void writeSubtitleSampleData(ExtractorInput extractorInput, byte[] bArr, int i6) {
        int length = bArr.length + i6;
        if (this.subtitleSample.capacity() < length) {
            this.subtitleSample.reset(Arrays.copyOf(bArr, length + i6));
        } else {
            System.arraycopy(bArr, 0, this.subtitleSample.getData(), 0, bArr.length);
        }
        extractorInput.readFully(this.subtitleSample.getData(), bArr.length, i6);
        this.subtitleSample.setPosition(0);
        this.subtitleSample.setLimit(length);
    }

    private int writeToOutput(ExtractorInput extractorInput, TrackOutput trackOutput, int i6) {
        int iBytesLeft = this.sampleStrippedBytes.bytesLeft();
        if (iBytesLeft <= 0) {
            return trackOutput.sampleData((DataReader) extractorInput, i6, false);
        }
        int iMin = Math.min(i6, iBytesLeft);
        trackOutput.sampleData(this.sampleStrippedBytes, iMin);
        return iMin;
    }

    private void writeToTarget(ExtractorInput extractorInput, byte[] bArr, int i6, int i7) {
        int iMin = Math.min(i7, this.sampleStrippedBytes.bytesLeft());
        extractorInput.readFully(bArr, i6 + iMin, i7 - iMin);
        if (iMin > 0) {
            this.sampleStrippedBytes.readBytes(bArr, i6, iMin);
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    public void binaryElement(int i6, int i7, ExtractorInput extractorInput) throws ParserException {
        int i8;
        int i9;
        int i10;
        int i11;
        int i12;
        long j4;
        int i13;
        int i14;
        int i15;
        ExtractorInput extractorInput2 = extractorInput;
        int i16 = 0;
        int i17 = 1;
        if (i6 != ID_BLOCK && i6 != ID_SIMPLE_BLOCK) {
            if (i6 == ID_BLOCK_ADDITIONAL) {
                if (this.blockState != 2) {
                    return;
                }
                handleBlockAdditionalData(this.tracks.get(this.blockTrackNumber), this.blockAdditionalId, extractorInput2, i7);
                return;
            }
            if (i6 == ID_BLOCK_ADD_ID_EXTRA_DATA) {
                handleBlockAddIDExtraData(getCurrentTrack(i6), extractorInput2, i7);
                return;
            }
            if (i6 == ID_CONTENT_COMPRESSION_SETTINGS) {
                assertInTrackEntry(i6);
                byte[] bArr = new byte[i7];
                this.currentTrack.sampleStrippedBytes = bArr;
                extractorInput2.readFully(bArr, 0, i7);
                return;
            }
            if (i6 == ID_CONTENT_ENCRYPTION_KEY_ID) {
                byte[] bArr2 = new byte[i7];
                extractorInput2.readFully(bArr2, 0, i7);
                getCurrentTrack(i6).cryptoData = new TrackOutput.CryptoData(1, bArr2, 0, 0);
                return;
            }
            if (i6 == ID_SEEK_ID) {
                Arrays.fill(this.seekEntryIdBytes.getData(), (byte) 0);
                extractorInput2.readFully(this.seekEntryIdBytes.getData(), 4 - i7, i7);
                this.seekEntryIdBytes.setPosition(0);
                this.seekEntryId = (int) this.seekEntryIdBytes.readUnsignedInt();
                return;
            }
            if (i6 == ID_CODEC_PRIVATE) {
                assertInTrackEntry(i6);
                byte[] bArr3 = new byte[i7];
                this.currentTrack.codecPrivate = bArr3;
                extractorInput2.readFully(bArr3, 0, i7);
                return;
            }
            if (i6 != ID_PROJECTION_PRIVATE) {
                throw ParserException.createForMalformedContainer("Unexpected id: " + i6, null);
            }
            assertInTrackEntry(i6);
            byte[] bArr4 = new byte[i7];
            this.currentTrack.projectionData = bArr4;
            extractorInput2.readFully(bArr4, 0, i7);
            return;
        }
        int i18 = 8;
        if (this.blockState == 0) {
            this.blockTrackNumber = (int) this.varintReader.readUnsignedVarint(extractorInput2, false, true, 8);
            this.blockTrackNumberLength = this.varintReader.getLastLength();
            this.blockDurationUs = C.TIME_UNSET;
            this.blockState = 1;
            this.scratch.reset(0);
        }
        Track track = this.tracks.get(this.blockTrackNumber);
        if (track == null) {
            extractorInput2.skipFully(i7 - this.blockTrackNumberLength);
            this.blockState = 0;
            return;
        }
        track.assertOutputInitialized();
        if (this.blockState == 1) {
            readScratch(extractorInput2, 3);
            int i19 = (this.scratch.getData()[2] & 6) >> 1;
            if (i19 == 0) {
                this.blockSampleCount = 1;
                int[] iArrEnsureArrayCapacity = ensureArrayCapacity(this.blockSampleSizes, 1);
                this.blockSampleSizes = iArrEnsureArrayCapacity;
                iArrEnsureArrayCapacity[0] = (i7 - this.blockTrackNumberLength) - 3;
            } else {
                readScratch(extractorInput2, 4);
                int i20 = (this.scratch.getData()[3] & 255) + 1;
                this.blockSampleCount = i20;
                int[] iArrEnsureArrayCapacity2 = ensureArrayCapacity(this.blockSampleSizes, i20);
                this.blockSampleSizes = iArrEnsureArrayCapacity2;
                if (i19 == 2) {
                    int i21 = (i7 - this.blockTrackNumberLength) - 4;
                    int i22 = this.blockSampleCount;
                    Arrays.fill(iArrEnsureArrayCapacity2, 0, i22, i21 / i22);
                } else {
                    if (i19 != 1) {
                        if (i19 != 3) {
                            throw ParserException.createForMalformedContainer("Unexpected lacing value: " + i19, null);
                        }
                        int i23 = 0;
                        int i24 = 0;
                        int i25 = 4;
                        while (true) {
                            int i26 = this.blockSampleCount;
                            i8 = i17;
                            if (i23 >= i26 - 1) {
                                i9 = i16;
                                this.blockSampleSizes[i26 - 1] = ((i7 - this.blockTrackNumberLength) - i25) - i24;
                                break;
                            }
                            this.blockSampleSizes[i23] = i16;
                            int i27 = i25 + 1;
                            readScratch(extractorInput2, i27);
                            if (this.scratch.getData()[i25] == 0) {
                                throw ParserException.createForMalformedContainer("No valid varint length mask found", null);
                            }
                            int i28 = i16;
                            while (true) {
                                if (i28 >= i18) {
                                    i10 = i16;
                                    i11 = i18;
                                    i12 = i23;
                                    j4 = 0;
                                    break;
                                }
                                i11 = i18;
                                int i29 = i8 << (7 - i28);
                                i10 = i16;
                                if ((this.scratch.getData()[i25] & i29) != 0) {
                                    i27 += i28;
                                    readScratch(extractorInput2, i27);
                                    int i30 = i25 + 1;
                                    j4 = this.scratch.getData()[i25] & 255 & (~i29);
                                    while (true) {
                                        int i31 = i30;
                                        if (i31 >= i27) {
                                            break;
                                        }
                                        i30 = i31 + 1;
                                        j4 = (j4 << i11) | ((long) (this.scratch.getData()[i31] & 255));
                                        i23 = i23;
                                    }
                                    i12 = i23;
                                    if (i12 > 0) {
                                        j4 -= (1 << ((i28 * 7) + 6)) - 1;
                                    }
                                } else {
                                    i28++;
                                    extractorInput2 = extractorInput;
                                    i16 = i10;
                                    i18 = i11;
                                }
                            }
                            i25 = i27;
                            if (j4 < -2147483648L || j4 > 2147483647L) {
                                break;
                            }
                            int i32 = (int) j4;
                            int[] iArr = this.blockSampleSizes;
                            if (i12 != 0) {
                                i32 += iArr[i12 - 1];
                            }
                            iArr[i12] = i32;
                            i24 += i32;
                            i23 = i12 + 1;
                            extractorInput2 = extractorInput;
                            i17 = i8;
                            i16 = i10;
                            i18 = i11;
                        }
                        throw ParserException.createForMalformedContainer("EBML lacing sample size out of range.", null);
                    }
                    int i33 = 0;
                    int i34 = 0;
                    int i35 = 4;
                    while (true) {
                        i13 = this.blockSampleCount;
                        if (i33 >= i13 - 1) {
                            break;
                        }
                        this.blockSampleSizes[i33] = 0;
                        while (true) {
                            i14 = i35 + 1;
                            readScratch(extractorInput2, i14);
                            int i36 = this.scratch.getData()[i35] & 255;
                            int[] iArr2 = this.blockSampleSizes;
                            i15 = iArr2[i33] + i36;
                            iArr2[i33] = i15;
                            if (i36 != 255) {
                                break;
                            } else {
                                i35 = i14;
                            }
                        }
                        i34 += i15;
                        i33++;
                        i35 = i14;
                    }
                    this.blockSampleSizes[i13 - 1] = ((i7 - this.blockTrackNumberLength) - i35) - i34;
                }
            }
            i9 = 0;
            i8 = 1;
            this.blockTimeUs = this.clusterTimecodeUs + scaleTimecodeToUs((this.scratch.getData()[i9] << 8) | (this.scratch.getData()[i8] & 255));
            this.blockFlags = (track.type == 2 || (i6 == ID_SIMPLE_BLOCK && (this.scratch.getData()[2] & 128) == 128)) ? i8 : i9;
            this.blockState = 2;
            this.blockSampleIndex = i9;
        } else {
            i8 = 1;
        }
        if (i6 == ID_SIMPLE_BLOCK) {
            while (true) {
                int i37 = this.blockSampleIndex;
                if (i37 >= this.blockSampleCount) {
                    this.blockState = 0;
                    return;
                }
                int iWriteSampleData = writeSampleData(extractorInput, track, this.blockSampleSizes[i37], false);
                Track track2 = track;
                commitSampleToOutput(track2, this.blockTimeUs + ((long) ((this.blockSampleIndex * track.defaultSampleDurationNs) / 1000)), this.blockFlags, iWriteSampleData, 0);
                this.blockSampleIndex++;
                track = track2;
            }
        } else {
            while (true) {
                int i38 = this.blockSampleIndex;
                if (i38 >= this.blockSampleCount) {
                    return;
                }
                int[] iArr3 = this.blockSampleSizes;
                boolean z6 = i8;
                iArr3[i38] = writeSampleData(extractorInput, track, iArr3[i38], z6);
                this.blockSampleIndex += z6 ? 1 : 0;
            }
        }
    }

    public void endMasterElement(int i6) throws ParserException {
        assertInitialized();
        if (i6 == ID_BLOCK_GROUP) {
            if (this.blockState != 2) {
                return;
            }
            Track track = this.tracks.get(this.blockTrackNumber);
            track.assertOutputInitialized();
            if (this.blockGroupDiscardPaddingNs > 0 && CODEC_ID_OPUS.equals(track.codecId)) {
                this.supplementalData.reset(ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(this.blockGroupDiscardPaddingNs).array());
            }
            int i7 = 0;
            for (int i8 = 0; i8 < this.blockSampleCount; i8++) {
                i7 += this.blockSampleSizes[i8];
            }
            int i9 = 0;
            while (i9 < this.blockSampleCount) {
                long j4 = this.blockTimeUs + ((long) ((track.defaultSampleDurationNs * i9) / 1000));
                int i10 = this.blockFlags;
                if (i9 == 0 && !this.blockHasReferenceBlock) {
                    i10 |= 1;
                }
                int i11 = this.blockSampleSizes[i9];
                int i12 = i7 - i11;
                commitSampleToOutput(track, j4, i10, i11, i12);
                i9++;
                i7 = i12;
            }
            this.blockState = 0;
            return;
        }
        if (i6 == ID_TRACK_ENTRY) {
            Track track2 = (Track) Assertions.checkStateNotNull(this.currentTrack);
            String str = track2.codecId;
            if (str == null) {
                throw ParserException.createForMalformedContainer("CodecId is missing in TrackEntry element", null);
            }
            if (isCodecSupported(str)) {
                track2.initializeOutput(this.extractorOutput, track2.number);
                this.tracks.put(track2.number, track2);
            }
            this.currentTrack = null;
            return;
        }
        if (i6 == ID_SEEK) {
            int i13 = this.seekEntryId;
            if (i13 != -1) {
                long j6 = this.seekEntryPosition;
                if (j6 != -1) {
                    if (i13 == ID_CUES) {
                        this.cuesContentPosition = j6;
                        return;
                    }
                    return;
                }
            }
            throw ParserException.createForMalformedContainer("Mandatory element SeekID or SeekPosition not found", null);
        }
        if (i6 == ID_CONTENT_ENCODING) {
            assertInTrackEntry(i6);
            Track track3 = this.currentTrack;
            if (track3.hasContentEncryption) {
                if (track3.cryptoData == null) {
                    throw ParserException.createForMalformedContainer("Encrypted Track found but ContentEncKeyID was not found", null);
                }
                track3.drmInitData = new DrmInitData(new DrmInitData.SchemeData(C.UUID_NIL, MimeTypes.VIDEO_WEBM, this.currentTrack.cryptoData.encryptionKey));
                return;
            }
            return;
        }
        if (i6 == ID_CONTENT_ENCODINGS) {
            assertInTrackEntry(i6);
            Track track4 = this.currentTrack;
            if (track4.hasContentEncryption && track4.sampleStrippedBytes != null) {
                throw ParserException.createForMalformedContainer("Combining encryption and compression is not supported", null);
            }
            return;
        }
        if (i6 == 357149030) {
            if (this.timecodeScale == C.TIME_UNSET) {
                this.timecodeScale = 1000000L;
            }
            long j7 = this.durationTimecode;
            if (j7 != C.TIME_UNSET) {
                this.durationUs = scaleTimecodeToUs(j7);
                return;
            }
            return;
        }
        if (i6 == ID_TRACKS) {
            if (this.tracks.size() == 0) {
                throw ParserException.createForMalformedContainer("No valid tracks were found", null);
            }
            this.extractorOutput.endTracks();
        } else {
            if (i6 != ID_CUES) {
                return;
            }
            if (!this.sentSeekMap) {
                this.extractorOutput.seekMap(buildSeekMap(this.cueTimesUs, this.cueClusterPositions));
                this.sentSeekMap = true;
            }
            this.cueTimesUs = null;
            this.cueClusterPositions = null;
        }
    }

    public void floatElement(int i6, double d6) {
        if (i6 == ID_SAMPLING_FREQUENCY) {
            getCurrentTrack(i6).sampleRate = (int) d6;
            return;
        }
        if (i6 == ID_DURATION) {
            this.durationTimecode = (long) d6;
            return;
        }
        switch (i6) {
            case ID_PRIMARY_R_CHROMATICITY_X /* 21969 */:
                getCurrentTrack(i6).primaryRChromaticityX = (float) d6;
                break;
            case ID_PRIMARY_R_CHROMATICITY_Y /* 21970 */:
                getCurrentTrack(i6).primaryRChromaticityY = (float) d6;
                break;
            case ID_PRIMARY_G_CHROMATICITY_X /* 21971 */:
                getCurrentTrack(i6).primaryGChromaticityX = (float) d6;
                break;
            case ID_PRIMARY_G_CHROMATICITY_Y /* 21972 */:
                getCurrentTrack(i6).primaryGChromaticityY = (float) d6;
                break;
            case ID_PRIMARY_B_CHROMATICITY_X /* 21973 */:
                getCurrentTrack(i6).primaryBChromaticityX = (float) d6;
                break;
            case ID_PRIMARY_B_CHROMATICITY_Y /* 21974 */:
                getCurrentTrack(i6).primaryBChromaticityY = (float) d6;
                break;
            case ID_WHITE_POINT_CHROMATICITY_X /* 21975 */:
                getCurrentTrack(i6).whitePointChromaticityX = (float) d6;
                break;
            case ID_WHITE_POINT_CHROMATICITY_Y /* 21976 */:
                getCurrentTrack(i6).whitePointChromaticityY = (float) d6;
                break;
            case ID_LUMNINANCE_MAX /* 21977 */:
                getCurrentTrack(i6).maxMasteringLuminance = (float) d6;
                break;
            case ID_LUMNINANCE_MIN /* 21978 */:
                getCurrentTrack(i6).minMasteringLuminance = (float) d6;
                break;
            default:
                switch (i6) {
                    case ID_PROJECTION_POSE_YAW /* 30323 */:
                        getCurrentTrack(i6).projectionPoseYaw = (float) d6;
                        break;
                    case ID_PROJECTION_POSE_PITCH /* 30324 */:
                        getCurrentTrack(i6).projectionPosePitch = (float) d6;
                        break;
                    case ID_PROJECTION_POSE_ROLL /* 30325 */:
                        getCurrentTrack(i6).projectionPoseRoll = (float) d6;
                        break;
                }
                break;
        }
    }

    public Track getCurrentTrack(int i6) throws ParserException {
        assertInTrackEntry(i6);
        return this.currentTrack;
    }

    public int getElementType(int i6) {
        switch (i6) {
            case ID_TRACK_TYPE /* 131 */:
            case 136:
            case ID_BLOCK_DURATION /* 155 */:
            case ID_CHANNELS /* 159 */:
            case ID_PIXEL_WIDTH /* 176 */:
            case ID_CUE_TIME /* 179 */:
            case ID_PIXEL_HEIGHT /* 186 */:
            case ID_TRACK_NUMBER /* 215 */:
            case ID_TIME_CODE /* 231 */:
            case ID_BLOCK_ADD_ID /* 238 */:
            case ID_CUE_CLUSTER_POSITION /* 241 */:
            case ID_REFERENCE_BLOCK /* 251 */:
            case ID_BLOCK_ADD_ID_TYPE /* 16871 */:
            case ID_CONTENT_COMPRESSION_ALGORITHM /* 16980 */:
            case ID_DOC_TYPE_READ_VERSION /* 17029 */:
            case ID_EBML_READ_VERSION /* 17143 */:
            case ID_CONTENT_ENCRYPTION_ALGORITHM /* 18401 */:
            case ID_CONTENT_ENCRYPTION_AES_SETTINGS_CIPHER_MODE /* 18408 */:
            case ID_CONTENT_ENCODING_ORDER /* 20529 */:
            case ID_CONTENT_ENCODING_SCOPE /* 20530 */:
            case ID_SEEK_POSITION /* 21420 */:
            case ID_STEREO_MODE /* 21432 */:
            case ID_DISPLAY_WIDTH /* 21680 */:
            case ID_DISPLAY_UNIT /* 21682 */:
            case ID_DISPLAY_HEIGHT /* 21690 */:
            case ID_FLAG_FORCED /* 21930 */:
            case ID_COLOUR_BITS_PER_CHANNEL /* 21938 */:
            case ID_COLOUR_RANGE /* 21945 */:
            case ID_COLOUR_TRANSFER /* 21946 */:
            case ID_COLOUR_PRIMARIES /* 21947 */:
            case ID_MAX_CLL /* 21948 */:
            case ID_MAX_FALL /* 21949 */:
            case ID_MAX_BLOCK_ADDITION_ID /* 21998 */:
            case ID_CODEC_DELAY /* 22186 */:
            case ID_SEEK_PRE_ROLL /* 22203 */:
            case ID_AUDIO_BIT_DEPTH /* 25188 */:
            case ID_DISCARD_PADDING /* 30114 */:
            case ID_PROJECTION_TYPE /* 30321 */:
            case ID_DEFAULT_DURATION /* 2352003 */:
            case ID_TIMECODE_SCALE /* 2807729 */:
                return 2;
            case 134:
            case 17026:
            case ID_NAME /* 21358 */:
            case ID_LANGUAGE /* 2274716 */:
                return 3;
            case ID_BLOCK_GROUP /* 160 */:
            case ID_BLOCK_MORE /* 166 */:
            case ID_TRACK_ENTRY /* 174 */:
            case ID_CUE_TRACK_POSITIONS /* 183 */:
            case ID_CUE_POINT /* 187 */:
            case 224:
            case ID_AUDIO /* 225 */:
            case ID_BLOCK_ADDITION_MAPPING /* 16868 */:
            case ID_CONTENT_ENCRYPTION_AES_SETTINGS /* 18407 */:
            case ID_SEEK /* 19899 */:
            case ID_CONTENT_COMPRESSION /* 20532 */:
            case ID_CONTENT_ENCRYPTION /* 20533 */:
            case ID_COLOUR /* 21936 */:
            case ID_MASTERING_METADATA /* 21968 */:
            case ID_CONTENT_ENCODING /* 25152 */:
            case ID_CONTENT_ENCODINGS /* 28032 */:
            case ID_BLOCK_ADDITIONS /* 30113 */:
            case ID_PROJECTION /* 30320 */:
            case ID_SEEK_HEAD /* 290298740 */:
            case 357149030:
            case ID_TRACKS /* 374648427 */:
            case ID_SEGMENT /* 408125543 */:
            case ID_EBML /* 440786851 */:
            case ID_CUES /* 475249515 */:
            case ID_CLUSTER /* 524531317 */:
                return 1;
            case ID_BLOCK /* 161 */:
            case ID_SIMPLE_BLOCK /* 163 */:
            case ID_BLOCK_ADDITIONAL /* 165 */:
            case ID_BLOCK_ADD_ID_EXTRA_DATA /* 16877 */:
            case ID_CONTENT_COMPRESSION_SETTINGS /* 16981 */:
            case ID_CONTENT_ENCRYPTION_KEY_ID /* 18402 */:
            case ID_SEEK_ID /* 21419 */:
            case ID_CODEC_PRIVATE /* 25506 */:
            case ID_PROJECTION_PRIVATE /* 30322 */:
                return 4;
            case ID_SAMPLING_FREQUENCY /* 181 */:
            case ID_DURATION /* 17545 */:
            case ID_PRIMARY_R_CHROMATICITY_X /* 21969 */:
            case ID_PRIMARY_R_CHROMATICITY_Y /* 21970 */:
            case ID_PRIMARY_G_CHROMATICITY_X /* 21971 */:
            case ID_PRIMARY_G_CHROMATICITY_Y /* 21972 */:
            case ID_PRIMARY_B_CHROMATICITY_X /* 21973 */:
            case ID_PRIMARY_B_CHROMATICITY_Y /* 21974 */:
            case ID_WHITE_POINT_CHROMATICITY_X /* 21975 */:
            case ID_WHITE_POINT_CHROMATICITY_Y /* 21976 */:
            case ID_LUMNINANCE_MAX /* 21977 */:
            case ID_LUMNINANCE_MIN /* 21978 */:
            case ID_PROJECTION_POSE_YAW /* 30323 */:
            case ID_PROJECTION_POSE_PITCH /* 30324 */:
            case ID_PROJECTION_POSE_ROLL /* 30325 */:
                return 5;
            default:
                return 0;
        }
    }

    public void handleBlockAddIDExtraData(Track track, ExtractorInput extractorInput, int i6) {
        if (track.blockAddIdType != 1685485123 && track.blockAddIdType != 1685480259) {
            extractorInput.skipFully(i6);
            return;
        }
        byte[] bArr = new byte[i6];
        track.dolbyVisionConfigBytes = bArr;
        extractorInput.readFully(bArr, 0, i6);
    }

    public void handleBlockAdditionalData(Track track, int i6, ExtractorInput extractorInput, int i7) {
        if (i6 != 4 || !CODEC_ID_VP9.equals(track.codecId)) {
            extractorInput.skipFully(i7);
        } else {
            this.supplementalData.reset(i7);
            extractorInput.readFully(this.supplementalData.getData(), 0, i7);
        }
    }

    @Override // androidx.media3.extractor.Extractor
    public final void init(ExtractorOutput extractorOutput) {
        this.extractorOutput = extractorOutput;
        if (this.parseSubtitlesDuringExtraction) {
            extractorOutput = new SubtitleTranscodingExtractorOutput(extractorOutput, this.subtitleParserFactory);
        }
        this.extractorOutput = extractorOutput;
    }

    public void integerElement(int i6, long j4) throws ParserException {
        if (i6 == ID_CONTENT_ENCODING_ORDER) {
            if (j4 == 0) {
                return;
            }
            throw ParserException.createForMalformedContainer("ContentEncodingOrder " + j4 + " not supported", null);
        }
        if (i6 == ID_CONTENT_ENCODING_SCOPE) {
            if (j4 == 1) {
                return;
            }
            throw ParserException.createForMalformedContainer("ContentEncodingScope " + j4 + " not supported", null);
        }
        switch (i6) {
            case ID_TRACK_TYPE /* 131 */:
                getCurrentTrack(i6).type = (int) j4;
                return;
            case 136:
                getCurrentTrack(i6).flagDefault = j4 == 1;
                return;
            case ID_BLOCK_DURATION /* 155 */:
                this.blockDurationUs = scaleTimecodeToUs(j4);
                return;
            case ID_CHANNELS /* 159 */:
                getCurrentTrack(i6).channelCount = (int) j4;
                return;
            case ID_PIXEL_WIDTH /* 176 */:
                getCurrentTrack(i6).width = (int) j4;
                return;
            case ID_CUE_TIME /* 179 */:
                assertInCues(i6);
                this.cueTimesUs.add(scaleTimecodeToUs(j4));
                return;
            case ID_PIXEL_HEIGHT /* 186 */:
                getCurrentTrack(i6).height = (int) j4;
                return;
            case ID_TRACK_NUMBER /* 215 */:
                getCurrentTrack(i6).number = (int) j4;
                return;
            case ID_TIME_CODE /* 231 */:
                this.clusterTimecodeUs = scaleTimecodeToUs(j4);
                return;
            case ID_BLOCK_ADD_ID /* 238 */:
                this.blockAdditionalId = (int) j4;
                return;
            case ID_CUE_CLUSTER_POSITION /* 241 */:
                if (this.seenClusterPositionForCurrentCuePoint) {
                    return;
                }
                assertInCues(i6);
                this.cueClusterPositions.add(j4);
                this.seenClusterPositionForCurrentCuePoint = true;
                return;
            case ID_REFERENCE_BLOCK /* 251 */:
                this.blockHasReferenceBlock = true;
                return;
            case ID_BLOCK_ADD_ID_TYPE /* 16871 */:
                getCurrentTrack(i6).blockAddIdType = (int) j4;
                return;
            case ID_CONTENT_COMPRESSION_ALGORITHM /* 16980 */:
                if (j4 == 3) {
                    return;
                }
                throw ParserException.createForMalformedContainer("ContentCompAlgo " + j4 + " not supported", null);
            case ID_DOC_TYPE_READ_VERSION /* 17029 */:
                if (j4 < 1 || j4 > 2) {
                    throw ParserException.createForMalformedContainer("DocTypeReadVersion " + j4 + " not supported", null);
                }
                return;
            case ID_EBML_READ_VERSION /* 17143 */:
                if (j4 == 1) {
                    return;
                }
                throw ParserException.createForMalformedContainer("EBMLReadVersion " + j4 + " not supported", null);
            case ID_CONTENT_ENCRYPTION_ALGORITHM /* 18401 */:
                if (j4 == 5) {
                    return;
                }
                throw ParserException.createForMalformedContainer("ContentEncAlgo " + j4 + " not supported", null);
            case ID_CONTENT_ENCRYPTION_AES_SETTINGS_CIPHER_MODE /* 18408 */:
                if (j4 == 1) {
                    return;
                }
                throw ParserException.createForMalformedContainer("AESSettingsCipherMode " + j4 + " not supported", null);
            case ID_SEEK_POSITION /* 21420 */:
                this.seekEntryPosition = j4 + this.segmentContentPosition;
                return;
            case ID_STEREO_MODE /* 21432 */:
                int i7 = (int) j4;
                assertInTrackEntry(i6);
                if (i7 == 0) {
                    this.currentTrack.stereoMode = 0;
                    return;
                }
                if (i7 == 1) {
                    this.currentTrack.stereoMode = 2;
                    return;
                } else if (i7 == 3) {
                    this.currentTrack.stereoMode = 1;
                    return;
                } else {
                    if (i7 != 15) {
                        return;
                    }
                    this.currentTrack.stereoMode = 3;
                    return;
                }
            case ID_DISPLAY_WIDTH /* 21680 */:
                getCurrentTrack(i6).displayWidth = (int) j4;
                return;
            case ID_DISPLAY_UNIT /* 21682 */:
                getCurrentTrack(i6).displayUnit = (int) j4;
                return;
            case ID_DISPLAY_HEIGHT /* 21690 */:
                getCurrentTrack(i6).displayHeight = (int) j4;
                return;
            case ID_FLAG_FORCED /* 21930 */:
                getCurrentTrack(i6).flagForced = j4 == 1;
                return;
            case ID_COLOUR_BITS_PER_CHANNEL /* 21938 */:
                assertInTrackEntry(i6);
                Track track = this.currentTrack;
                track.hasColorInfo = true;
                track.bitsPerChannel = (int) j4;
                return;
            case ID_MAX_BLOCK_ADDITION_ID /* 21998 */:
                getCurrentTrack(i6).maxBlockAdditionId = (int) j4;
                return;
            case ID_CODEC_DELAY /* 22186 */:
                getCurrentTrack(i6).codecDelayNs = j4;
                return;
            case ID_SEEK_PRE_ROLL /* 22203 */:
                getCurrentTrack(i6).seekPreRollNs = j4;
                return;
            case ID_AUDIO_BIT_DEPTH /* 25188 */:
                getCurrentTrack(i6).audioBitDepth = (int) j4;
                return;
            case ID_DISCARD_PADDING /* 30114 */:
                this.blockGroupDiscardPaddingNs = j4;
                return;
            case ID_PROJECTION_TYPE /* 30321 */:
                assertInTrackEntry(i6);
                int i8 = (int) j4;
                if (i8 == 0) {
                    this.currentTrack.projectionType = 0;
                    return;
                }
                if (i8 == 1) {
                    this.currentTrack.projectionType = 1;
                    return;
                } else if (i8 == 2) {
                    this.currentTrack.projectionType = 2;
                    return;
                } else {
                    if (i8 != 3) {
                        return;
                    }
                    this.currentTrack.projectionType = 3;
                    return;
                }
            case ID_DEFAULT_DURATION /* 2352003 */:
                getCurrentTrack(i6).defaultSampleDurationNs = (int) j4;
                return;
            case ID_TIMECODE_SCALE /* 2807729 */:
                this.timecodeScale = j4;
                return;
            default:
                switch (i6) {
                    case ID_COLOUR_RANGE /* 21945 */:
                        assertInTrackEntry(i6);
                        int i9 = (int) j4;
                        if (i9 == 1) {
                            this.currentTrack.colorRange = 2;
                            return;
                        } else {
                            if (i9 != 2) {
                                return;
                            }
                            this.currentTrack.colorRange = 1;
                            return;
                        }
                    case ID_COLOUR_TRANSFER /* 21946 */:
                        assertInTrackEntry(i6);
                        int iIsoTransferCharacteristicsToColorTransfer = ColorInfo.isoTransferCharacteristicsToColorTransfer((int) j4);
                        if (iIsoTransferCharacteristicsToColorTransfer != -1) {
                            this.currentTrack.colorTransfer = iIsoTransferCharacteristicsToColorTransfer;
                            return;
                        }
                        return;
                    case ID_COLOUR_PRIMARIES /* 21947 */:
                        assertInTrackEntry(i6);
                        this.currentTrack.hasColorInfo = true;
                        int iIsoColorPrimariesToColorSpace = ColorInfo.isoColorPrimariesToColorSpace((int) j4);
                        if (iIsoColorPrimariesToColorSpace != -1) {
                            this.currentTrack.colorSpace = iIsoColorPrimariesToColorSpace;
                            return;
                        }
                        return;
                    case ID_MAX_CLL /* 21948 */:
                        getCurrentTrack(i6).maxContentLuminance = (int) j4;
                        return;
                    case ID_MAX_FALL /* 21949 */:
                        getCurrentTrack(i6).maxFrameAverageLuminance = (int) j4;
                        return;
                    default:
                        return;
                }
        }
    }

    public boolean isLevel1Element(int i6) {
        return i6 == 357149030 || i6 == ID_CLUSTER || i6 == ID_CUES || i6 == ID_TRACKS;
    }

    @Override // androidx.media3.extractor.Extractor
    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) {
        this.haveOutputSample = false;
        boolean z6 = true;
        while (z6 && !this.haveOutputSample) {
            z6 = this.reader.read(extractorInput);
            if (z6 && maybeSeekForCues(positionHolder, extractorInput.getPosition())) {
                return 1;
            }
        }
        if (z6) {
            return 0;
        }
        for (int i6 = 0; i6 < this.tracks.size(); i6++) {
            Track trackValueAt = this.tracks.valueAt(i6);
            trackValueAt.assertOutputInitialized();
            trackValueAt.outputPendingSampleMetadata();
        }
        return -1;
    }

    @Override // androidx.media3.extractor.Extractor
    public final void release() {
    }

    @Override // androidx.media3.extractor.Extractor
    public void seek(long j4, long j6) {
        this.clusterTimecodeUs = C.TIME_UNSET;
        this.blockState = 0;
        this.reader.reset();
        this.varintReader.reset();
        resetWriteSampleData();
        for (int i6 = 0; i6 < this.tracks.size(); i6++) {
            this.tracks.valueAt(i6).reset();
        }
    }

    @Override // androidx.media3.extractor.Extractor
    public final boolean sniff(ExtractorInput extractorInput) {
        return new Sniffer().sniff(extractorInput);
    }

    public void startMasterElement(int i6, long j4, long j6) throws ParserException {
        assertInitialized();
        if (i6 == ID_BLOCK_GROUP) {
            this.blockHasReferenceBlock = false;
            this.blockGroupDiscardPaddingNs = 0L;
            return;
        }
        if (i6 == ID_TRACK_ENTRY) {
            this.currentTrack = new Track();
            return;
        }
        if (i6 == ID_CUE_POINT) {
            this.seenClusterPositionForCurrentCuePoint = false;
            return;
        }
        if (i6 == ID_SEEK) {
            this.seekEntryId = -1;
            this.seekEntryPosition = -1L;
            return;
        }
        if (i6 == ID_CONTENT_ENCRYPTION) {
            getCurrentTrack(i6).hasContentEncryption = true;
            return;
        }
        if (i6 == ID_MASTERING_METADATA) {
            getCurrentTrack(i6).hasColorInfo = true;
            return;
        }
        if (i6 == ID_SEGMENT) {
            long j7 = this.segmentContentPosition;
            if (j7 != -1 && j7 != j4) {
                throw ParserException.createForMalformedContainer("Multiple Segment elements not supported", null);
            }
            this.segmentContentPosition = j4;
            this.segmentContentSize = j6;
            return;
        }
        if (i6 == ID_CUES) {
            this.cueTimesUs = new LongArray();
            this.cueClusterPositions = new LongArray();
        } else if (i6 == ID_CLUSTER && !this.sentSeekMap) {
            if (this.seekForCuesEnabled && this.cuesContentPosition != -1) {
                this.seekForCues = true;
            } else {
                this.extractorOutput.seekMap(new SeekMap.Unseekable(this.durationUs));
                this.sentSeekMap = true;
            }
        }
    }

    public void stringElement(int i6, String str) throws ParserException {
        if (i6 == 134) {
            getCurrentTrack(i6).codecId = str;
            return;
        }
        if (i6 != 17026) {
            if (i6 == ID_NAME) {
                getCurrentTrack(i6).name = str;
                return;
            } else {
                if (i6 != ID_LANGUAGE) {
                    return;
                }
                getCurrentTrack(i6).language = str;
                return;
            }
        }
        if (DOC_TYPE_WEBM.equals(str) || DOC_TYPE_MATROSKA.equals(str)) {
            return;
        }
        throw ParserException.createForMalformedContainer("DocType " + str + " not supported", null);
    }

    @Deprecated
    public MatroskaExtractor(int i6) {
        this(new DefaultEbmlReader(), i6 | 2, SubtitleParser.Factory.UNSUPPORTED);
    }

    public MatroskaExtractor(SubtitleParser.Factory factory) {
        this(new DefaultEbmlReader(), 0, factory);
    }

    public MatroskaExtractor(SubtitleParser.Factory factory, int i6) {
        this(new DefaultEbmlReader(), i6, factory);
    }

    public MatroskaExtractor(EbmlReader ebmlReader, int i6, SubtitleParser.Factory factory) {
        this.segmentContentPosition = -1L;
        this.timecodeScale = C.TIME_UNSET;
        this.durationTimecode = C.TIME_UNSET;
        this.durationUs = C.TIME_UNSET;
        this.cuesContentPosition = -1L;
        this.seekPositionAfterBuildingCues = -1L;
        this.clusterTimecodeUs = C.TIME_UNSET;
        this.reader = ebmlReader;
        ebmlReader.init(new InnerEbmlProcessor());
        this.subtitleParserFactory = factory;
        this.seekForCuesEnabled = (i6 & 1) == 0;
        this.parseSubtitlesDuringExtraction = (i6 & 2) == 0;
        this.varintReader = new VarintReader();
        this.tracks = new SparseArray<>();
        this.scratch = new ParsableByteArray(4);
        this.vorbisNumPageSamples = new ParsableByteArray(ByteBuffer.allocate(4).putInt(-1).array());
        this.seekEntryIdBytes = new ParsableByteArray(4);
        this.nalStartCode = new ParsableByteArray(NalUnitUtil.NAL_START_CODE);
        this.nalLength = new ParsableByteArray(4);
        this.sampleStrippedBytes = new ParsableByteArray();
        this.subtitleSample = new ParsableByteArray();
        this.encryptionInitializationVector = new ParsableByteArray(8);
        this.encryptionSubsampleData = new ParsableByteArray();
        this.supplementalData = new ParsableByteArray();
        this.blockSampleSizes = new int[1];
    }
}
