package androidx.media3.extractor.wav;

import android.util.Pair;
import androidx.media3.common.DataReader;
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.ParsableByteArray;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.Util;
import androidx.media3.extractor.Extractor;
import androidx.media3.extractor.ExtractorInput;
import androidx.media3.extractor.ExtractorOutput;
import androidx.media3.extractor.ExtractorsFactory;
import androidx.media3.extractor.PositionHolder;
import androidx.media3.extractor.TrackOutput;
import androidx.media3.extractor.WavUtil;
import androidx.media3.extractor.a;
import androidx.media3.extractor.ts.TsExtractor;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class WavExtractor implements Extractor {
    public static final ExtractorsFactory FACTORY = new a(14);
    private static final int STATE_READING_FILE_TYPE = 0;
    private static final int STATE_READING_FORMAT = 2;
    private static final int STATE_READING_RF64_SAMPLE_DATA_SIZE = 1;
    private static final int STATE_READING_SAMPLE_DATA = 4;
    private static final int STATE_SKIPPING_TO_SAMPLE_DATA = 3;
    private static final String TAG = "WavExtractor";
    private static final int TARGET_SAMPLES_PER_SECOND = 10;
    private ExtractorOutput extractorOutput;
    private OutputWriter outputWriter;
    private TrackOutput trackOutput;
    private int state = 0;
    private long rf64SampleDataSize = -1;
    private int dataStartPosition = -1;
    private long dataEndPosition = -1;

    public static final class ImaAdPcmOutputWriter implements OutputWriter {
        private static final int[] INDEX_TABLE = {-1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8};
        private static final int[] STEP_TABLE = {7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, TsExtractor.TS_STREAM_TYPE_HDMV_DTS, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767};
        private final ParsableByteArray decodedData;
        private final ExtractorOutput extractorOutput;
        private final Format format;
        private final int framesPerBlock;
        private final byte[] inputData;
        private long outputFrameCount;
        private int pendingInputBytes;
        private int pendingOutputBytes;
        private long startTimeUs;
        private final int targetSampleSizeFrames;
        private final TrackOutput trackOutput;
        private final WavFormat wavFormat;

        public ImaAdPcmOutputWriter(ExtractorOutput extractorOutput, TrackOutput trackOutput, WavFormat wavFormat) throws ParserException {
            this.extractorOutput = extractorOutput;
            this.trackOutput = trackOutput;
            this.wavFormat = wavFormat;
            int iMax = Math.max(1, wavFormat.frameRateHz / 10);
            this.targetSampleSizeFrames = iMax;
            ParsableByteArray parsableByteArray = new ParsableByteArray(wavFormat.extraData);
            parsableByteArray.readLittleEndianUnsignedShort();
            int littleEndianUnsignedShort = parsableByteArray.readLittleEndianUnsignedShort();
            this.framesPerBlock = littleEndianUnsignedShort;
            int i6 = wavFormat.numChannels;
            int i7 = (((wavFormat.blockSize - (i6 * 4)) * 8) / (wavFormat.bitsPerSample * i6)) + 1;
            if (littleEndianUnsignedShort != i7) {
                throw ParserException.createForMalformedContainer("Expected frames per block: " + i7 + "; got: " + littleEndianUnsignedShort, null);
            }
            int iCeilDivide = Util.ceilDivide(iMax, littleEndianUnsignedShort);
            this.inputData = new byte[wavFormat.blockSize * iCeilDivide];
            this.decodedData = new ParsableByteArray(iCeilDivide * numOutputFramesToBytes(littleEndianUnsignedShort, i6));
            int i8 = ((wavFormat.frameRateHz * wavFormat.blockSize) * 8) / littleEndianUnsignedShort;
            this.format = new Format.Builder().setSampleMimeType(MimeTypes.AUDIO_RAW).setAverageBitrate(i8).setPeakBitrate(i8).setMaxInputSize(numOutputFramesToBytes(iMax, i6)).setChannelCount(wavFormat.numChannels).setSampleRate(wavFormat.frameRateHz).setPcmEncoding(2).build();
        }

        private void decode(byte[] bArr, int i6, ParsableByteArray parsableByteArray) {
            for (int i7 = 0; i7 < i6; i7++) {
                for (int i8 = 0; i8 < this.wavFormat.numChannels; i8++) {
                    decodeBlockForChannel(bArr, i7, i8, parsableByteArray.getData());
                }
            }
            int iNumOutputFramesToBytes = numOutputFramesToBytes(this.framesPerBlock * i6);
            parsableByteArray.setPosition(0);
            parsableByteArray.setLimit(iNumOutputFramesToBytes);
        }

        private void decodeBlockForChannel(byte[] bArr, int i6, int i7, byte[] bArr2) {
            WavFormat wavFormat = this.wavFormat;
            int i8 = wavFormat.blockSize;
            int i9 = wavFormat.numChannels;
            int i10 = (i7 * 4) + (i6 * i8);
            int i11 = (i9 * 4) + i10;
            int i12 = (i8 / i9) - 4;
            int iConstrainValue = (short) (((bArr[i10 + 1] & 255) << 8) | (bArr[i10] & 255));
            int iMin = Math.min(bArr[i10 + 2] & 255, 88);
            int i13 = STEP_TABLE[iMin];
            int i14 = ((i6 * this.framesPerBlock * i9) + i7) * 2;
            bArr2[i14] = (byte) (iConstrainValue & 255);
            bArr2[i14 + 1] = (byte) (iConstrainValue >> 8);
            for (int i15 = 0; i15 < i12 * 2; i15++) {
                byte b5 = bArr[((i15 / 8) * i9 * 4) + i11 + ((i15 / 2) % 4)];
                int i16 = i15 % 2 == 0 ? b5 & 15 : (b5 & 255) >> 4;
                int i17 = ((((i16 & 7) * 2) + 1) * i13) >> 3;
                if ((i16 & 8) != 0) {
                    i17 = -i17;
                }
                iConstrainValue = Util.constrainValue(iConstrainValue + i17, -32768, 32767);
                i14 += i9 * 2;
                bArr2[i14] = (byte) (iConstrainValue & 255);
                bArr2[i14 + 1] = (byte) (iConstrainValue >> 8);
                int i18 = iMin + INDEX_TABLE[i16];
                int[] iArr = STEP_TABLE;
                iMin = Util.constrainValue(i18, 0, iArr.length - 1);
                i13 = iArr[iMin];
            }
        }

        private int numOutputBytesToFrames(int i6) {
            return i6 / (this.wavFormat.numChannels * 2);
        }

        private static int numOutputFramesToBytes(int i6, int i7) {
            return i6 * 2 * i7;
        }

        private void writeSampleMetadata(int i6) {
            long jScaleLargeTimestamp = this.startTimeUs + Util.scaleLargeTimestamp(this.outputFrameCount, 1000000L, this.wavFormat.frameRateHz);
            int iNumOutputFramesToBytes = numOutputFramesToBytes(i6);
            this.trackOutput.sampleMetadata(jScaleLargeTimestamp, 1, iNumOutputFramesToBytes, this.pendingOutputBytes - iNumOutputFramesToBytes, null);
            this.outputFrameCount += (long) i6;
            this.pendingOutputBytes -= iNumOutputFramesToBytes;
        }

        @Override // androidx.media3.extractor.wav.WavExtractor.OutputWriter
        public void init(int i6, long j4) {
            this.extractorOutput.seekMap(new WavSeekMap(this.wavFormat, this.framesPerBlock, i6, j4));
            this.trackOutput.format(this.format);
        }

        @Override // androidx.media3.extractor.wav.WavExtractor.OutputWriter
        public void reset(long j4) {
            this.pendingInputBytes = 0;
            this.startTimeUs = j4;
            this.pendingOutputBytes = 0;
            this.outputFrameCount = 0L;
        }

        /* JADX WARN: Removed duplicated region for block: B:7:0x0020  */
        /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:10:0x0035 -> B:4:0x001b). Please report as a decompilation issue!!! */
        @Override // androidx.media3.extractor.wav.WavExtractor.OutputWriter
        /*
            Code decompiled incorrectly, please refer to instructions dump.
        */
        public boolean sampleData(ExtractorInput extractorInput, long j4) {
            int iNumOutputBytesToFrames;
            int iCeilDivide = Util.ceilDivide(this.targetSampleSizeFrames - numOutputBytesToFrames(this.pendingOutputBytes), this.framesPerBlock) * this.wavFormat.blockSize;
            boolean z6 = j4 == 0;
            while (!z6) {
                if (this.pendingInputBytes >= iCeilDivide) {
                    break;
                }
                int i6 = extractorInput.read(this.inputData, this.pendingInputBytes, (int) Math.min(iCeilDivide - r3, j4));
                if (i6 == -1) {
                    while (!z6) {
                    }
                } else {
                    this.pendingInputBytes += i6;
                }
            }
            int i7 = this.pendingInputBytes / this.wavFormat.blockSize;
            if (i7 > 0) {
                decode(this.inputData, i7, this.decodedData);
                this.pendingInputBytes -= i7 * this.wavFormat.blockSize;
                int iLimit = this.decodedData.limit();
                this.trackOutput.sampleData(this.decodedData, iLimit);
                int i8 = this.pendingOutputBytes + iLimit;
                this.pendingOutputBytes = i8;
                int iNumOutputBytesToFrames2 = numOutputBytesToFrames(i8);
                int i9 = this.targetSampleSizeFrames;
                if (iNumOutputBytesToFrames2 >= i9) {
                    writeSampleMetadata(i9);
                }
            }
            if (z6 && (iNumOutputBytesToFrames = numOutputBytesToFrames(this.pendingOutputBytes)) > 0) {
                writeSampleMetadata(iNumOutputBytesToFrames);
            }
            return z6;
        }

        private int numOutputFramesToBytes(int i6) {
            return numOutputFramesToBytes(i6, this.wavFormat.numChannels);
        }
    }

    public interface OutputWriter {
        void init(int i6, long j4);

        void reset(long j4);

        boolean sampleData(ExtractorInput extractorInput, long j4);
    }

    public static final class PassthroughOutputWriter implements OutputWriter {
        private final ExtractorOutput extractorOutput;
        private final Format format;
        private long outputFrameCount;
        private int pendingOutputBytes;
        private long startTimeUs;
        private final int targetSampleSizeBytes;
        private final TrackOutput trackOutput;
        private final WavFormat wavFormat;

        public PassthroughOutputWriter(ExtractorOutput extractorOutput, TrackOutput trackOutput, WavFormat wavFormat, String str, int i6) throws ParserException {
            this.extractorOutput = extractorOutput;
            this.trackOutput = trackOutput;
            this.wavFormat = wavFormat;
            int i7 = (wavFormat.numChannels * wavFormat.bitsPerSample) / 8;
            if (wavFormat.blockSize != i7) {
                StringBuilder sbR = com.google.android.recaptcha.internal.a.r(i7, "Expected block size: ", "; got: ");
                sbR.append(wavFormat.blockSize);
                throw ParserException.createForMalformedContainer(sbR.toString(), null);
            }
            int i8 = wavFormat.frameRateHz;
            int i9 = i8 * i7 * 8;
            int iMax = Math.max(i7, (i8 * i7) / 10);
            this.targetSampleSizeBytes = iMax;
            this.format = new Format.Builder().setSampleMimeType(str).setAverageBitrate(i9).setPeakBitrate(i9).setMaxInputSize(iMax).setChannelCount(wavFormat.numChannels).setSampleRate(wavFormat.frameRateHz).setPcmEncoding(i6).build();
        }

        @Override // androidx.media3.extractor.wav.WavExtractor.OutputWriter
        public void init(int i6, long j4) {
            this.extractorOutput.seekMap(new WavSeekMap(this.wavFormat, 1, i6, j4));
            this.trackOutput.format(this.format);
        }

        @Override // androidx.media3.extractor.wav.WavExtractor.OutputWriter
        public void reset(long j4) {
            this.startTimeUs = j4;
            this.pendingOutputBytes = 0;
            this.outputFrameCount = 0L;
        }

        @Override // androidx.media3.extractor.wav.WavExtractor.OutputWriter
        public boolean sampleData(ExtractorInput extractorInput, long j4) {
            int i6;
            int i7;
            long j6 = j4;
            while (j6 > 0 && (i6 = this.pendingOutputBytes) < (i7 = this.targetSampleSizeBytes)) {
                int iSampleData = this.trackOutput.sampleData((DataReader) extractorInput, (int) Math.min(i7 - i6, j6), true);
                if (iSampleData == -1) {
                    j6 = 0;
                } else {
                    this.pendingOutputBytes += iSampleData;
                    j6 -= (long) iSampleData;
                }
            }
            int i8 = this.wavFormat.blockSize;
            int i9 = this.pendingOutputBytes / i8;
            if (i9 > 0) {
                long jScaleLargeTimestamp = this.startTimeUs + Util.scaleLargeTimestamp(this.outputFrameCount, 1000000L, r1.frameRateHz);
                int i10 = i9 * i8;
                int i11 = this.pendingOutputBytes - i10;
                this.trackOutput.sampleMetadata(jScaleLargeTimestamp, 1, i10, i11, null);
                this.outputFrameCount += (long) i9;
                this.pendingOutputBytes = i11;
            }
            return j6 <= 0;
        }
    }

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

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Extractor[] lambda$static$0() {
        return new Extractor[]{new WavExtractor()};
    }

    private void readFileType(ExtractorInput extractorInput) throws ParserException {
        Assertions.checkState(extractorInput.getPosition() == 0);
        int i6 = this.dataStartPosition;
        if (i6 != -1) {
            extractorInput.skipFully(i6);
            this.state = 4;
        } else {
            if (!WavHeaderReader.checkFileType(extractorInput)) {
                throw ParserException.createForMalformedContainer("Unsupported or unrecognized wav file type.", null);
            }
            extractorInput.skipFully((int) (extractorInput.getPeekPosition() - extractorInput.getPosition()));
            this.state = 1;
        }
    }

    private void readFormat(ExtractorInput extractorInput) throws ParserException {
        WavFormat format = WavHeaderReader.readFormat(extractorInput);
        int i6 = format.formatType;
        if (i6 == 17) {
            this.outputWriter = new ImaAdPcmOutputWriter(this.extractorOutput, this.trackOutput, format);
        } else if (i6 == 6) {
            this.outputWriter = new PassthroughOutputWriter(this.extractorOutput, this.trackOutput, format, MimeTypes.AUDIO_ALAW, -1);
        } else if (i6 == 7) {
            this.outputWriter = new PassthroughOutputWriter(this.extractorOutput, this.trackOutput, format, MimeTypes.AUDIO_MLAW, -1);
        } else {
            int pcmEncodingForType = WavUtil.getPcmEncodingForType(i6, format.bitsPerSample);
            if (pcmEncodingForType == 0) {
                throw ParserException.createForUnsupportedContainerFeature("Unsupported WAV format type: " + format.formatType);
            }
            this.outputWriter = new PassthroughOutputWriter(this.extractorOutput, this.trackOutput, format, MimeTypes.AUDIO_RAW, pcmEncodingForType);
        }
        this.state = 3;
    }

    private void readRf64SampleDataSize(ExtractorInput extractorInput) {
        this.rf64SampleDataSize = WavHeaderReader.readRf64SampleDataSize(extractorInput);
        this.state = 2;
    }

    private int readSampleData(ExtractorInput extractorInput) {
        Assertions.checkState(this.dataEndPosition != -1);
        return ((OutputWriter) Assertions.checkNotNull(this.outputWriter)).sampleData(extractorInput, this.dataEndPosition - extractorInput.getPosition()) ? -1 : 0;
    }

    private void skipToSampleData(ExtractorInput extractorInput) {
        Pair<Long, Long> pairSkipToSampleData = WavHeaderReader.skipToSampleData(extractorInput);
        this.dataStartPosition = ((Long) pairSkipToSampleData.first).intValue();
        long jLongValue = ((Long) pairSkipToSampleData.second).longValue();
        long j4 = this.rf64SampleDataSize;
        if (j4 != -1 && jLongValue == 4294967295L) {
            jLongValue = j4;
        }
        this.dataEndPosition = ((long) this.dataStartPosition) + jLongValue;
        long length = extractorInput.getLength();
        if (length != -1 && this.dataEndPosition > length) {
            Log.w(TAG, "Data exceeds input length: " + this.dataEndPosition + ", " + length);
            this.dataEndPosition = length;
        }
        ((OutputWriter) Assertions.checkNotNull(this.outputWriter)).init(this.dataStartPosition, this.dataEndPosition);
        this.state = 4;
    }

    @Override // androidx.media3.extractor.Extractor
    public void init(ExtractorOutput extractorOutput) {
        this.extractorOutput = extractorOutput;
        this.trackOutput = extractorOutput.track(0, 1);
        extractorOutput.endTracks();
    }

    @Override // androidx.media3.extractor.Extractor
    public int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws ParserException {
        assertInitialized();
        int i6 = this.state;
        if (i6 == 0) {
            readFileType(extractorInput);
            return 0;
        }
        if (i6 == 1) {
            readRf64SampleDataSize(extractorInput);
            return 0;
        }
        if (i6 == 2) {
            readFormat(extractorInput);
            return 0;
        }
        if (i6 == 3) {
            skipToSampleData(extractorInput);
            return 0;
        }
        if (i6 == 4) {
            return readSampleData(extractorInput);
        }
        throw new IllegalStateException();
    }

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

    @Override // androidx.media3.extractor.Extractor
    public void seek(long j4, long j6) {
        this.state = j4 == 0 ? 0 : 4;
        OutputWriter outputWriter = this.outputWriter;
        if (outputWriter != null) {
            outputWriter.reset(j6);
        }
    }

    @Override // androidx.media3.extractor.Extractor
    public boolean sniff(ExtractorInput extractorInput) {
        return WavHeaderReader.checkFileType(extractorInput);
    }
}