package androidx.media3.decoder.midi;

import androidx.annotation.Nullable;
import androidx.media3.common.Format;
import androidx.media3.common.ParserException;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.ParsableByteArray;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.Util;
import androidx.media3.decoder.midi.TrackChunk;
import androidx.media3.extractor.Extractor;
import androidx.media3.extractor.ExtractorInput;
import androidx.media3.extractor.ExtractorOutput;
import androidx.media3.extractor.ForwardingTrackOutput;
import androidx.media3.extractor.PositionHolder;
import androidx.media3.extractor.SeekMap;
import androidx.media3.extractor.SeekPoint;
import androidx.media3.extractor.TrackOutput;
import com.google.common.primitives.Ints;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.PriorityQueue;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class MidiExtractor implements Extractor, SeekMap {
    private static final int FOURCC_MThd = 1297377380;
    private static final int FOURCC_MTrk = 1297379947;
    private static final int HEADER_LEN_BYTES = 14;
    private static final long MAX_SAMPLE_DURATION_US = 100000;
    private static final int STATE_INITIALIZED = 0;
    private static final int STATE_LOADING = 1;
    private static final int STATE_PARSING_SAMPLES = 3;
    private static final int STATE_PREPARING_CHUNKS = 2;
    private static final int STATE_RELEASED = 4;
    private int bytesRead;
    private long currentTimestampUs;
    private long startTimeUs;
    private int ticksPerQuarterNote;
    private SingleKeyFrameTrackOutput trackOutput;
    private int state = 0;
    private final ArrayList<TrackChunk> trackChunkList = new ArrayList<>();
    private final PriorityQueue<TrackChunk> trackPriorityQueue = new PriorityQueue<>();
    private final ParsableByteArray midiFileData = new ParsableByteArray(512);

    private static final class SingleKeyFrameTrackOutput extends ForwardingTrackOutput {
        private int outputSampleCount;

        public void reset() {
            this.outputSampleCount = 0;
        }

        public void sampleMetadata(long j2, int i2, int i3, int i4, @Nullable TrackOutput.CryptoData cryptoData) {
            Assertions.checkState((i2 & 1) == 0);
            if (this.outputSampleCount == 0) {
                i2 |= 1;
            }
            super.sampleMetadata(j2, i2, i3, i4, cryptoData);
            this.outputSampleCount++;
        }

        private SingleKeyFrameTrackOutput(TrackOutput trackOutput) {
            super(trackOutput);
        }
    }

    private static boolean isMidiHeaderIdentifier(ParsableByteArray parsableByteArray) {
        return parsableByteArray.readInt() == FOURCC_MThd;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onTempoChanged(int i2, long j2) {
        Iterator<TrackChunk> it = this.trackChunkList.iterator();
        while (it.hasNext()) {
            it.next().addTempoChange(i2, j2);
        }
    }

    private void outputEmptySample() {
        ((SingleKeyFrameTrackOutput) Assertions.checkStateNotNull(this.trackOutput)).sampleMetadata(this.currentTimestampUs, 0, 0, 0, null);
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.ParserException */
    private int parseTrackChunkHeader() throws ParserException {
        if (this.midiFileData.bytesLeft() < 8) {
            throw ParserException.createForMalformedContainer((String) null, (Throwable) null);
        }
        if (this.midiFileData.readInt() != FOURCC_MTrk) {
            throw ParserException.createForMalformedContainer((String) null, (Throwable) null);
        }
        int i2 = this.midiFileData.readInt();
        if (i2 > 0) {
            return i2;
        }
        throw ParserException.createForMalformedContainer((String) null, (Throwable) null);
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.ParserException */
    private void parseTracks() throws ParserException {
        if (this.midiFileData.bytesLeft() < 14) {
            throw ParserException.createForMalformedContainer((String) null, (Throwable) null);
        }
        if (!isMidiHeaderIdentifier(this.midiFileData)) {
            throw ParserException.createForMalformedContainer((String) null, (Throwable) null);
        }
        this.midiFileData.skipBytes(4);
        short s2 = this.midiFileData.readShort();
        short s3 = this.midiFileData.readShort();
        if (s3 <= 0) {
            throw ParserException.createForMalformedContainer((String) null, (Throwable) null);
        }
        this.ticksPerQuarterNote = this.midiFileData.readShort();
        for (int i2 = 0; i2 < s3; i2++) {
            int trackChunkHeader = parseTrackChunkHeader();
            byte[] bArr = new byte[trackChunkHeader];
            if (this.midiFileData.bytesLeft() < trackChunkHeader) {
                throw ParserException.createForMalformedContainer((String) null, (Throwable) null);
            }
            this.midiFileData.readBytes(bArr, 0, trackChunkHeader);
            this.trackChunkList.add(new TrackChunk(s2, this.ticksPerQuarterNote, new ParsableByteArray(bArr), new TrackChunk.TempoChangedListener() { // from class: androidx.media3.decoder.midi.b
                @Override // androidx.media3.decoder.midi.TrackChunk.TempoChangedListener
                public final void onTempoChanged(int i3, long j2) {
                    this.f2241a.onTempoChanged(i3, j2);
                }
            }));
        }
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.ParserException */
    private void seekChunksTo(long j2) throws ParserException {
        while (!this.trackPriorityQueue.isEmpty()) {
            TrackChunk trackChunk = (TrackChunk) Assertions.checkNotNull(this.trackPriorityQueue.poll());
            long jPeekNextTimestampUs = trackChunk.peekNextTimestampUs();
            if (jPeekNextTimestampUs != -9223372036854775807L && jPeekNextTimestampUs < j2) {
                trackChunk.outputFrontSample((TrackOutput) Assertions.checkStateNotNull(this.trackOutput), true);
                trackChunk.populateFrontTrackEvent();
                this.trackPriorityQueue.add(trackChunk);
            }
        }
        this.trackPriorityQueue.addAll(this.trackChunkList);
    }

    public long getDurationUs() {
        return -9223372036854775807L;
    }

    public SeekMap.SeekPoints getSeekPoints(long j2) {
        int i2 = this.state;
        return (i2 == 2 || i2 == 3) ? new SeekMap.SeekPoints(new SeekPoint(j2, 14L)) : new SeekMap.SeekPoints(SeekPoint.START);
    }

    public void init(ExtractorOutput extractorOutput) {
        if (this.state != 0) {
            throw new IllegalStateException();
        }
        SingleKeyFrameTrackOutput singleKeyFrameTrackOutput = new SingleKeyFrameTrackOutput(extractorOutput.track(0, 1));
        this.trackOutput = singleKeyFrameTrackOutput;
        singleKeyFrameTrackOutput.format(new Format.Builder().setCodecs("audio/midi").setContainerMimeType("audio/midi").setSampleMimeType("audio/x-exoplayer-midi").build());
        extractorOutput.endTracks();
        extractorOutput.seekMap(this);
        this.state = 1;
    }

    public boolean isSeekable() {
        return true;
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.ParserException */
    public int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws ParserException, IOException {
        int i2 = this.state;
        int i3 = -1;
        if (i2 == 1) {
            int iCheckedCast = Ints.checkedCast(extractorInput.getLength());
            int length = this.midiFileData.getData().length;
            if (this.bytesRead == length) {
                ParsableByteArray parsableByteArray = this.midiFileData;
                if (iCheckedCast != -1) {
                    length = iCheckedCast;
                }
                parsableByteArray.ensureCapacity((length * 3) / 2);
            }
            int i4 = extractorInput.read(this.midiFileData.getData(), this.bytesRead, this.midiFileData.capacity() - this.bytesRead);
            if (i4 != -1) {
                int i5 = this.bytesRead + i4;
                this.bytesRead = i5;
                if (iCheckedCast == -1 || i5 != iCheckedCast) {
                    return 0;
                }
            }
            this.midiFileData.setLimit(this.bytesRead);
            parseTracks();
            this.state = 2;
            return 0;
        }
        if (i2 == 2) {
            this.trackPriorityQueue.clear();
            for (TrackChunk trackChunk : this.trackChunkList) {
                trackChunk.reset();
                trackChunk.populateFrontTrackEvent();
            }
            this.trackPriorityQueue.addAll(this.trackChunkList);
            seekChunksTo(this.startTimeUs);
            this.currentTimestampUs = this.startTimeUs;
            if (((TrackChunk) Assertions.checkNotNull(this.trackPriorityQueue.peek())).peekNextTimestampUs() > this.currentTimestampUs) {
                outputEmptySample();
            }
            this.state = 3;
            return 0;
        }
        if (i2 != 3) {
            throw new IllegalStateException();
        }
        TrackChunk trackChunk2 = (TrackChunk) Assertions.checkNotNull(this.trackPriorityQueue.poll());
        long jPeekNextTimestampUs = trackChunk2.peekNextTimestampUs();
        if (jPeekNextTimestampUs != -9223372036854775807L) {
            long j2 = this.currentTimestampUs;
            if (j2 + MAX_SAMPLE_DURATION_US < jPeekNextTimestampUs) {
                this.currentTimestampUs = j2 + MAX_SAMPLE_DURATION_US;
                outputEmptySample();
            } else {
                this.currentTimestampUs = jPeekNextTimestampUs;
                trackChunk2.outputFrontSample((TrackOutput) Assertions.checkStateNotNull(this.trackOutput), false);
                trackChunk2.populateFrontTrackEvent();
            }
            i3 = 0;
        }
        this.trackPriorityQueue.add(trackChunk2);
        return i3;
    }

    public void release() {
        this.trackChunkList.clear();
        this.trackPriorityQueue.clear();
        this.midiFileData.reset(Util.EMPTY_BYTE_ARRAY);
        this.state = 4;
    }

    public void seek(long j2, long j3) {
        Assertions.checkState(this.state != 4);
        this.startTimeUs = j3;
        SingleKeyFrameTrackOutput singleKeyFrameTrackOutput = this.trackOutput;
        if (singleKeyFrameTrackOutput != null) {
            singleKeyFrameTrackOutput.reset();
        }
        if (this.state != 1) {
            this.state = 2;
        } else {
            this.midiFileData.setPosition(0);
            this.bytesRead = 0;
        }
    }

    public boolean sniff(ExtractorInput extractorInput) throws IOException {
        ParsableByteArray parsableByteArray = new ParsableByteArray(4);
        extractorInput.peekFully(parsableByteArray.getData(), 0, 4);
        return isMidiHeaderIdentifier(parsableByteArray);
    }
}