Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ChunkIndex.java

@@ -0,0 +1,58 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class ChunkIndex implements SeekMap {
+    private final long durationUs;
+    public final long[] durationsUs;
+    public final int length;
+    public final long[] offsets;
+    public final int[] sizes;
+    public final long[] timesUs;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final long getDurationUs() {
+        return this.durationUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final boolean isSeekable() {
+        return true;
+    }
+
+    public ChunkIndex(int[] iArr, long[] jArr, long[] jArr2, long[] jArr3) {
+        this.sizes = iArr;
+        this.offsets = jArr;
+        this.durationsUs = jArr2;
+        this.timesUs = jArr3;
+        int length = iArr.length;
+        this.length = length;
+        if (length > 0) {
+            this.durationUs = jArr2[length - 1] + jArr3[length - 1];
+        } else {
+            this.durationUs = 0L;
+        }
+    }
+
+    public final int getChunkIndex(long j) {
+        return Util.binarySearchFloor(this.timesUs, j, true, true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final SeekMap.SeekPoints getSeekPoints(long j) {
+        int chunkIndex = getChunkIndex(j);
+        SeekPoint seekPoint = new SeekPoint(this.timesUs[chunkIndex], this.offsets[chunkIndex]);
+        if (seekPoint.timeUs >= j || chunkIndex == this.length - 1) {
+            return new SeekMap.SeekPoints(seekPoint);
+        }
+        int i = chunkIndex + 1;
+        return new SeekMap.SeekPoints(seekPoint, new SeekPoint(this.timesUs[i], this.offsets[i]));
+    }
+
+    public final String toString() {
+        return "ChunkIndex(length=" + this.length + ", sizes=" + Arrays.toString(this.sizes) + ", offsets=" + Arrays.toString(this.offsets) + ", timeUs=" + Arrays.toString(this.timesUs) + ", durationsUs=" + Arrays.toString(this.durationsUs) + ")";
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/DefaultExtractorInput.java

@@ -0,0 +1,196 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class DefaultExtractorInput implements ExtractorInput {
+    private static final int PEEK_MAX_FREE_SPACE = 524288;
+    private static final int PEEK_MIN_FREE_SPACE_AFTER_RESIZE = 65536;
+    private static final int SCRATCH_SPACE_SIZE = 4096;
+    private final DataSource dataSource;
+    private int peekBufferLength;
+    private int peekBufferPosition;
+    private long position;
+    private final long streamLength;
+    private byte[] peekBuffer = new byte[65536];
+    private final byte[] scratchSpace = new byte[4096];
+
+    private void commitBytesRead(int i) {
+        if (i != -1) {
+            this.position += i;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final long getLength() {
+        return this.streamLength;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final long getPeekPosition() {
+        return this.position + this.peekBufferPosition;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final long getPosition() {
+        return this.position;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void resetPeekPosition() {
+        this.peekBufferPosition = 0;
+    }
+
+    public DefaultExtractorInput(DataSource dataSource, long j, long j2) {
+        this.dataSource = dataSource;
+        this.position = j;
+        this.streamLength = j2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final int read(byte[] bArr, int i, int i2) throws IOException, InterruptedException {
+        int readFromPeekBuffer = readFromPeekBuffer(bArr, i, i2);
+        if (readFromPeekBuffer == 0) {
+            readFromPeekBuffer = readFromDataSource(bArr, i, i2, 0, true);
+        }
+        commitBytesRead(readFromPeekBuffer);
+        return readFromPeekBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final boolean readFully(byte[] bArr, int i, int i2, boolean z) throws IOException, InterruptedException {
+        int readFromPeekBuffer = readFromPeekBuffer(bArr, i, i2);
+        while (readFromPeekBuffer < i2 && readFromPeekBuffer != -1) {
+            readFromPeekBuffer = readFromDataSource(bArr, i, i2, readFromPeekBuffer, z);
+        }
+        commitBytesRead(readFromPeekBuffer);
+        return readFromPeekBuffer != -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void readFully(byte[] bArr, int i, int i2) throws IOException, InterruptedException {
+        readFully(bArr, i, i2, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final int skip(int i) throws IOException, InterruptedException {
+        int skipFromPeekBuffer = skipFromPeekBuffer(i);
+        if (skipFromPeekBuffer == 0) {
+            byte[] bArr = this.scratchSpace;
+            skipFromPeekBuffer = readFromDataSource(bArr, 0, Math.min(i, bArr.length), 0, true);
+        }
+        commitBytesRead(skipFromPeekBuffer);
+        return skipFromPeekBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final boolean skipFully(int i, boolean z) throws IOException, InterruptedException {
+        int skipFromPeekBuffer = skipFromPeekBuffer(i);
+        while (skipFromPeekBuffer < i && skipFromPeekBuffer != -1) {
+            skipFromPeekBuffer = readFromDataSource(this.scratchSpace, -skipFromPeekBuffer, Math.min(i, this.scratchSpace.length + skipFromPeekBuffer), skipFromPeekBuffer, z);
+        }
+        commitBytesRead(skipFromPeekBuffer);
+        return skipFromPeekBuffer != -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void skipFully(int i) throws IOException, InterruptedException {
+        skipFully(i, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final boolean peekFully(byte[] bArr, int i, int i2, boolean z) throws IOException, InterruptedException {
+        if (!advancePeekPosition(i2, z)) {
+            return false;
+        }
+        System.arraycopy(this.peekBuffer, this.peekBufferPosition - i2, bArr, i, i2);
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void peekFully(byte[] bArr, int i, int i2) throws IOException, InterruptedException {
+        peekFully(bArr, i, i2, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final boolean advancePeekPosition(int i, boolean z) throws IOException, InterruptedException {
+        ensureSpaceForPeek(i);
+        int min = Math.min(this.peekBufferLength - this.peekBufferPosition, i);
+        while (min < i) {
+            min = readFromDataSource(this.peekBuffer, this.peekBufferPosition, i, min, z);
+            if (min == -1) {
+                return false;
+            }
+        }
+        int i2 = this.peekBufferPosition + i;
+        this.peekBufferPosition = i2;
+        this.peekBufferLength = Math.max(this.peekBufferLength, i2);
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void advancePeekPosition(int i) throws IOException, InterruptedException {
+        advancePeekPosition(i, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final <E extends Throwable> void setRetryPosition(long j, E e) throws Throwable {
+        Assertions.checkArgument(j >= 0);
+        this.position = j;
+        throw e;
+    }
+
+    private void ensureSpaceForPeek(int i) {
+        int i2 = this.peekBufferPosition + i;
+        byte[] bArr = this.peekBuffer;
+        if (i2 > bArr.length) {
+            this.peekBuffer = Arrays.copyOf(this.peekBuffer, Util.constrainValue(bArr.length * 2, 65536 + i2, i2 + 524288));
+        }
+    }
+
+    private int skipFromPeekBuffer(int i) {
+        int min = Math.min(this.peekBufferLength, i);
+        updatePeekBuffer(min);
+        return min;
+    }
+
+    private int readFromPeekBuffer(byte[] bArr, int i, int i2) {
+        int i3 = this.peekBufferLength;
+        if (i3 == 0) {
+            return 0;
+        }
+        int min = Math.min(i3, i2);
+        System.arraycopy(this.peekBuffer, 0, bArr, i, min);
+        updatePeekBuffer(min);
+        return min;
+    }
+
+    private void updatePeekBuffer(int i) {
+        int i2 = this.peekBufferLength - i;
+        this.peekBufferLength = i2;
+        this.peekBufferPosition = 0;
+        byte[] bArr = this.peekBuffer;
+        byte[] bArr2 = i2 < bArr.length - 524288 ? new byte[65536 + i2] : bArr;
+        System.arraycopy(bArr, i, bArr2, 0, i2);
+        this.peekBuffer = bArr2;
+    }
+
+    private int readFromDataSource(byte[] bArr, int i, int i2, int i3, boolean z) throws InterruptedException, IOException {
+        if (Thread.interrupted()) {
+            throw new InterruptedException();
+        }
+        int read = this.dataSource.read(bArr, i + i3, i2 - i3);
+        if (read != -1) {
+            return i3 + read;
+        }
+        if (i3 == 0 && z) {
+            return -1;
+        }
+        throw new EOFException();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/DefaultExtractorsFactory.java

@@ -0,0 +1,95 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.amr.AmrExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.FlvExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv.MatroskaExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.FragmentedMp4Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Mp4Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.Ac3Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.AdtsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.wav.WavExtractor;
+import java.lang.reflect.Constructor;
+
+/* loaded from: classes4.dex */
+public final class DefaultExtractorsFactory implements ExtractorsFactory {
+    private static final Constructor<? extends Extractor> FLAC_EXTRACTOR_CONSTRUCTOR;
+    private int fragmentedMp4Flags;
+    private int matroskaFlags;
+    private int mp3Flags;
+    private int mp4Flags;
+    private int tsFlags;
+    private int tsMode = 1;
+
+    static {
+        Constructor<? extends Extractor> constructor;
+        try {
+            constructor = Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.flac.FlacExtractor").asSubclass(Extractor.class).getConstructor(new Class[0]);
+        } catch (ClassNotFoundException unused) {
+            constructor = null;
+        } catch (Exception e) {
+            throw new RuntimeException("Error instantiating FLAC extension", e);
+        }
+        FLAC_EXTRACTOR_CONSTRUCTOR = constructor;
+    }
+
+    public final synchronized DefaultExtractorsFactory setMatroskaExtractorFlags(int i) {
+        this.matroskaFlags = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setMp4ExtractorFlags(int i) {
+        this.mp4Flags = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setFragmentedMp4ExtractorFlags(int i) {
+        this.fragmentedMp4Flags = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setMp3ExtractorFlags(int i) {
+        this.mp3Flags = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setTsExtractorMode(int i) {
+        this.tsMode = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setTsExtractorFlags(int i) {
+        this.tsFlags = i;
+        return this;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+    public final synchronized Extractor[] createExtractors() {
+        Extractor[] extractorArr;
+        Constructor<? extends Extractor> constructor = FLAC_EXTRACTOR_CONSTRUCTOR;
+        extractorArr = new Extractor[constructor == null ? 12 : 13];
+        extractorArr[0] = new MatroskaExtractor(this.matroskaFlags);
+        extractorArr[1] = new FragmentedMp4Extractor(this.fragmentedMp4Flags);
+        extractorArr[2] = new Mp4Extractor(this.mp4Flags);
+        extractorArr[3] = new Mp3Extractor(this.mp3Flags);
+        extractorArr[4] = new AdtsExtractor();
+        extractorArr[5] = new Ac3Extractor();
+        extractorArr[6] = new TsExtractor(this.tsMode, this.tsFlags);
+        extractorArr[7] = new FlvExtractor();
+        extractorArr[8] = new OggExtractor();
+        extractorArr[9] = new PsExtractor();
+        extractorArr[10] = new WavExtractor();
+        extractorArr[11] = new AmrExtractor();
+        if (constructor != null) {
+            try {
+                extractorArr[12] = constructor.newInstance(new Object[0]);
+            } catch (Exception e) {
+                throw new IllegalStateException("Unexpected error creating FLAC extractor", e);
+            }
+        }
+        return extractorArr;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/DummyTrackOutput.java

@@ -0,0 +1,35 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.EOFException;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class DummyTrackOutput implements TrackOutput {
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+    public final void format(Format format) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+    public final void sampleMetadata(long j, int i, int i2, int i3, TrackOutput.CryptoData cryptoData) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+    public final int sampleData(ExtractorInput extractorInput, int i, boolean z) throws IOException, InterruptedException {
+        int skip = extractorInput.skip(i);
+        if (skip != -1) {
+            return skip;
+        }
+        if (z) {
+            return -1;
+        }
+        throw new EOFException();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+    public final void sampleData(ParsableByteArray parsableByteArray, int i) {
+        parsableByteArray.skipBytes(i);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/Extractor.java

@@ -0,0 +1,20 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface Extractor {
+    public static final int RESULT_CONTINUE = 0;
+    public static final int RESULT_END_OF_INPUT = -1;
+    public static final int RESULT_SEEK = 1;
+
+    void init(ExtractorOutput extractorOutput);
+
+    int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException;
+
+    void release();
+
+    void seek(long j, long j2);
+
+    boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ExtractorInput.java

@@ -0,0 +1,36 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface ExtractorInput {
+    void advancePeekPosition(int i) throws IOException, InterruptedException;
+
+    boolean advancePeekPosition(int i, boolean z) throws IOException, InterruptedException;
+
+    long getLength();
+
+    long getPeekPosition();
+
+    long getPosition();
+
+    void peekFully(byte[] bArr, int i, int i2) throws IOException, InterruptedException;
+
+    boolean peekFully(byte[] bArr, int i, int i2, boolean z) throws IOException, InterruptedException;
+
+    int read(byte[] bArr, int i, int i2) throws IOException, InterruptedException;
+
+    void readFully(byte[] bArr, int i, int i2) throws IOException, InterruptedException;
+
+    boolean readFully(byte[] bArr, int i, int i2, boolean z) throws IOException, InterruptedException;
+
+    void resetPeekPosition();
+
+    <E extends Throwable> void setRetryPosition(long j, E e) throws Throwable;
+
+    int skip(int i) throws IOException, InterruptedException;
+
+    void skipFully(int i) throws IOException, InterruptedException;
+
+    boolean skipFully(int i, boolean z) throws IOException, InterruptedException;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ExtractorOutput.java

@@ -0,0 +1,10 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+/* loaded from: classes4.dex */
+public interface ExtractorOutput {
+    void endTracks();
+
+    void seekMap(SeekMap seekMap);
+
+    TrackOutput track(int i, int i2);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ExtractorsFactory.java

@@ -0,0 +1,6 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+/* loaded from: classes4.dex */
+public interface ExtractorsFactory {
+    Extractor[] createExtractors();
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/GaplessInfoHolder.java

@@ -0,0 +1,77 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.CommentFrame;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.Id3Decoder;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.InternalFrame;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes4.dex */
+public final class GaplessInfoHolder {
+    private static final String GAPLESS_DESCRIPTION = "iTunSMPB";
+    private static final String GAPLESS_DOMAIN = "com.apple.iTunes";
+    public int encoderDelay = -1;
+    public int encoderPadding = -1;
+    public static final Id3Decoder.FramePredicate GAPLESS_INFO_ID3_FRAME_PREDICATE = new Id3Decoder.FramePredicate() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.GaplessInfoHolder.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.Id3Decoder.FramePredicate
+        public boolean evaluate(int i, int i2, int i3, int i4, int i5) {
+            return i2 == 67 && i3 == 79 && i4 == 77 && (i5 == 77 || i == 2);
+        }
+    };
+    private static final Pattern GAPLESS_COMMENT_PATTERN = Pattern.compile("^ [0-9a-fA-F]{8} ([0-9a-fA-F]{8}) ([0-9a-fA-F]{8})");
+
+    public final boolean hasGaplessInfo() {
+        return (this.encoderDelay == -1 || this.encoderPadding == -1) ? false : true;
+    }
+
+    public final boolean setFromXingHeaderValue(int i) {
+        int i2 = i >> 12;
+        int i3 = i & 4095;
+        if (i2 <= 0 && i3 <= 0) {
+            return false;
+        }
+        this.encoderDelay = i2;
+        this.encoderPadding = i3;
+        return true;
+    }
+
+    public final boolean setFromMetadata(Metadata metadata) {
+        for (int i = 0; i < metadata.length(); i++) {
+            Metadata.Entry entry = metadata.get(i);
+            if (entry instanceof CommentFrame) {
+                CommentFrame commentFrame = (CommentFrame) entry;
+                if (GAPLESS_DESCRIPTION.equals(commentFrame.description) && setFromComment(commentFrame.text)) {
+                    return true;
+                }
+            } else if (entry instanceof InternalFrame) {
+                InternalFrame internalFrame = (InternalFrame) entry;
+                if (GAPLESS_DOMAIN.equals(internalFrame.domain) && GAPLESS_DESCRIPTION.equals(internalFrame.description) && setFromComment(internalFrame.text)) {
+                    return true;
+                }
+            } else {
+                continue;
+            }
+        }
+        return false;
+    }
+
+    private boolean setFromComment(String str) {
+        Matcher matcher = GAPLESS_COMMENT_PATTERN.matcher(str);
+        if (!matcher.find()) {
+            return false;
+        }
+        try {
+            int parseInt = Integer.parseInt(matcher.group(1), 16);
+            int parseInt2 = Integer.parseInt(matcher.group(2), 16);
+            if (parseInt <= 0 && parseInt2 <= 0) {
+                return false;
+            }
+            this.encoderDelay = parseInt;
+            this.encoderPadding = parseInt2;
+            return true;
+        } catch (NumberFormatException unused) {
+            return false;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/Id3Peeker.java

@@ -0,0 +1,44 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.Id3Decoder;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.EOFException;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class Id3Peeker {
+    private final ParsableByteArray scratch = new ParsableByteArray(10);
+
+    @Nullable
+    public final Metadata peekId3Data(ExtractorInput extractorInput, @Nullable Id3Decoder.FramePredicate framePredicate) throws IOException, InterruptedException {
+        Metadata metadata = null;
+        int i = 0;
+        while (true) {
+            try {
+                extractorInput.peekFully(this.scratch.data, 0, 10);
+                this.scratch.setPosition(0);
+                if (this.scratch.readUnsignedInt24() != Id3Decoder.ID3_TAG) {
+                    break;
+                }
+                this.scratch.skipBytes(3);
+                int readSynchSafeInt = this.scratch.readSynchSafeInt();
+                int i2 = readSynchSafeInt + 10;
+                if (metadata == null) {
+                    byte[] bArr = new byte[i2];
+                    System.arraycopy(this.scratch.data, 0, bArr, 0, 10);
+                    extractorInput.peekFully(bArr, 10, readSynchSafeInt);
+                    metadata = new Id3Decoder(framePredicate).decode(bArr, i2);
+                } else {
+                    extractorInput.advancePeekPosition(readSynchSafeInt);
+                }
+                i += i2;
+            } catch (EOFException unused) {
+            }
+        }
+        extractorInput.resetPeekPosition();
+        extractorInput.advancePeekPosition(i);
+        return metadata;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/MpegAudioHeader.java

@@ -0,0 +1,110 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.DefaultOggSeeker;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.vungle.ads.internal.protos.Sdk;
+import org.apache.http.HttpStatus;
+
+/* loaded from: classes4.dex */
+public final class MpegAudioHeader {
+    public static final int MAX_FRAME_SIZE_BYTES = 4096;
+    public int bitrate;
+    public int channels;
+    public int frameSize;
+    public String mimeType;
+    public int sampleRate;
+    public int samplesPerFrame;
+    public int version;
+    private static final String[] MIME_TYPE_BY_LAYER = {MimeTypes.AUDIO_MPEG_L1, MimeTypes.AUDIO_MPEG_L2, MimeTypes.AUDIO_MPEG};
+    private static final int[] SAMPLING_RATE_V1 = {44100, 48000, 32000};
+    private static final int[] BITRATE_V1_L1 = {32, 64, 96, 128, 160, PsExtractor.AUDIO_STREAM, 224, 256, 288, Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE, 352, 384, HttpStatus.SC_REQUESTED_RANGE_NOT_SATISFIABLE, 448};
+    private static final int[] BITRATE_V2_L1 = {32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, PsExtractor.AUDIO_STREAM, 224, 256};
+    private static final int[] BITRATE_V1_L2 = {32, 48, 56, 64, 80, 96, 112, 128, 160, PsExtractor.AUDIO_STREAM, 224, 256, Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE, 384};
+    private static final int[] BITRATE_V1_L3 = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, PsExtractor.AUDIO_STREAM, 224, 256, Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE};
+    private static final int[] BITRATE_V2 = {8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160};
+
+    private void setValues(int i, String str, int i2, int i3, int i4, int i5, int i6) {
+        this.version = i;
+        this.mimeType = str;
+        this.frameSize = i2;
+        this.sampleRate = i3;
+        this.channels = i4;
+        this.bitrate = i5;
+        this.samplesPerFrame = i6;
+    }
+
+    public static int getFrameSize(int i) {
+        int i2;
+        int i3;
+        int i4;
+        int i5;
+        int i6;
+        if ((i & (-2097152)) != -2097152 || (i2 = (i >>> 19) & 3) == 1 || (i3 = (i >>> 17) & 3) == 0 || (i4 = (i >>> 12) & 15) == 0 || i4 == 15 || (i5 = (i >>> 10) & 3) == 3) {
+            return -1;
+        }
+        int i7 = SAMPLING_RATE_V1[i5];
+        if (i2 == 2) {
+            i7 /= 2;
+        } else if (i2 == 0) {
+            i7 /= 4;
+        }
+        int i8 = (i >>> 9) & 1;
+        if (i3 == 3) {
+            return ((((i2 == 3 ? BITRATE_V1_L1[i4 - 1] : BITRATE_V2_L1[i4 - 1]) * 12000) / i7) + i8) * 4;
+        }
+        if (i2 == 3) {
+            i6 = i3 == 2 ? BITRATE_V1_L2[i4 - 1] : BITRATE_V1_L3[i4 - 1];
+        } else {
+            i6 = BITRATE_V2[i4 - 1];
+        }
+        if (i2 == 3) {
+            return ((i6 * 144000) / i7) + i8;
+        }
+        return (((i3 == 1 ? DefaultOggSeeker.MATCH_RANGE : 144000) * i6) / i7) + i8;
+    }
+
+    public static boolean populateHeader(int i, MpegAudioHeader mpegAudioHeader) {
+        int i2;
+        int i3;
+        int i4;
+        int i5;
+        int i6;
+        int i7;
+        int i8;
+        int i9;
+        if ((i & (-2097152)) != -2097152 || (i2 = (i >>> 19) & 3) == 1 || (i3 = (i >>> 17) & 3) == 0 || (i4 = (i >>> 12) & 15) == 0 || i4 == 15 || (i5 = (i >>> 10) & 3) == 3) {
+            return false;
+        }
+        int i10 = SAMPLING_RATE_V1[i5];
+        if (i2 == 2) {
+            i10 /= 2;
+        } else if (i2 == 0) {
+            i10 /= 4;
+        }
+        int i11 = i10;
+        int i12 = (i >>> 9) & 1;
+        if (i3 == 3) {
+            i6 = i2 == 3 ? BITRATE_V1_L1[i4 - 1] : BITRATE_V2_L1[i4 - 1];
+            i9 = (((i6 * 12000) / i11) + i12) * 4;
+            i8 = 384;
+        } else {
+            if (i2 == 3) {
+                i6 = i3 == 2 ? BITRATE_V1_L2[i4 - 1] : BITRATE_V1_L3[i4 - 1];
+            } else {
+                i6 = BITRATE_V2[i4 - 1];
+                r8 = i3 == 1 ? 576 : 1152;
+                if (i3 == 1) {
+                    i7 = DefaultOggSeeker.MATCH_RANGE;
+                    i8 = r8;
+                    i9 = ((i7 * i6) / i11) + i12;
+                }
+            }
+            i7 = 144000;
+            i8 = r8;
+            i9 = ((i7 * i6) / i11) + i12;
+        }
+        mpegAudioHeader.setValues(i2, MIME_TYPE_BY_LAYER[3 - i3], i9, i11, ((i >> 6) & 3) == 3 ? 1 : 2, i6 * 1000, i8);
+        return true;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/PositionHolder.java

@@ -0,0 +1,6 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+/* loaded from: classes4.dex */
+public final class PositionHolder {
+    public long position;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/SeekMap.java

@@ -0,0 +1,87 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public interface SeekMap {
+    long getDurationUs();
+
+    SeekPoints getSeekPoints(long j);
+
+    boolean isSeekable();
+
+    public static final class Unseekable implements SeekMap {
+        private final long durationUs;
+        private final SeekPoints startSeekPoints;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public final long getDurationUs() {
+            return this.durationUs;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public final SeekPoints getSeekPoints(long j) {
+            return this.startSeekPoints;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public final boolean isSeekable() {
+            return false;
+        }
+
+        public Unseekable(long j) {
+            this(j, 0L);
+        }
+
+        public Unseekable(long j, long j2) {
+            this.durationUs = j;
+            this.startSeekPoints = new SeekPoints(j2 == 0 ? SeekPoint.START : new SeekPoint(0L, j2));
+        }
+    }
+
+    public static final class SeekPoints {
+        public final SeekPoint first;
+        public final SeekPoint second;
+
+        public SeekPoints(SeekPoint seekPoint) {
+            this(seekPoint, seekPoint);
+        }
+
+        public SeekPoints(SeekPoint seekPoint, SeekPoint seekPoint2) {
+            this.first = (SeekPoint) Assertions.checkNotNull(seekPoint);
+            this.second = (SeekPoint) Assertions.checkNotNull(seekPoint2);
+        }
+
+        public final String toString() {
+            String str;
+            StringBuilder sb = new StringBuilder();
+            sb.append(v8.i.d);
+            sb.append(this.first);
+            if (this.first.equals(this.second)) {
+                str = "";
+            } else {
+                str = ", " + this.second;
+            }
+            sb.append(str);
+            sb.append(v8.i.e);
+            return sb.toString();
+        }
+
+        public final boolean equals(@Nullable Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || SeekPoints.class != obj.getClass()) {
+                return false;
+            }
+            SeekPoints seekPoints = (SeekPoints) obj;
+            return this.first.equals(seekPoints.first) && this.second.equals(seekPoints.second);
+        }
+
+        public final int hashCode() {
+            return (this.first.hashCode() * 31) + this.second.hashCode();
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/SeekPoint.java

@@ -0,0 +1,35 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+
+/* loaded from: classes4.dex */
+public final class SeekPoint {
+    public static final SeekPoint START = new SeekPoint(0, 0);
+    public final long position;
+    public final long timeUs;
+
+    public final int hashCode() {
+        return (((int) this.timeUs) * 31) + ((int) this.position);
+    }
+
+    public SeekPoint(long j, long j2) {
+        this.timeUs = j;
+        this.position = j2;
+    }
+
+    public final String toString() {
+        return "[timeUs=" + this.timeUs + ", position=" + this.position + v8.i.e;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || SeekPoint.class != obj.getClass()) {
+            return false;
+        }
+        SeekPoint seekPoint = (SeekPoint) obj;
+        return this.timeUs == seekPoint.timeUs && this.position == seekPoint.position;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/TrackOutput.java

@@ -0,0 +1,47 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.IOException;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public interface TrackOutput {
+    void format(Format format);
+
+    int sampleData(ExtractorInput extractorInput, int i, boolean z) throws IOException, InterruptedException;
+
+    void sampleData(ParsableByteArray parsableByteArray, int i);
+
+    void sampleMetadata(long j, int i, int i2, int i3, CryptoData cryptoData);
+
+    public static final class CryptoData {
+        public final int clearBlocks;
+        public final int cryptoMode;
+        public final int encryptedBlocks;
+        public final byte[] encryptionKey;
+
+        public CryptoData(int i, byte[] bArr, int i2, int i3) {
+            this.cryptoMode = i;
+            this.encryptionKey = bArr;
+            this.encryptedBlocks = i2;
+            this.clearBlocks = i3;
+        }
+
+        public final boolean equals(@Nullable Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || CryptoData.class != obj.getClass()) {
+                return false;
+            }
+            CryptoData cryptoData = (CryptoData) obj;
+            return this.cryptoMode == cryptoData.cryptoMode && this.encryptedBlocks == cryptoData.encryptedBlocks && this.clearBlocks == cryptoData.clearBlocks && Arrays.equals(this.encryptionKey, cryptoData.encryptionKey);
+        }
+
+        public final int hashCode() {
+            return (((((this.cryptoMode * 31) + Arrays.hashCode(this.encryptionKey)) * 31) + this.encryptedBlocks) * 31) + this.clearBlocks;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/amr/AmrExtractor.java

@@ -0,0 +1,188 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.amr;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class AmrExtractor implements Extractor {
+    private static final int MAX_FRAME_SIZE_BYTES;
+    private static final int SAMPLE_RATE_NB = 8000;
+    private static final int SAMPLE_RATE_WB = 16000;
+    private static final int SAMPLE_TIME_PER_FRAME_US = 20000;
+    private static final int[] frameSizeBytesByTypeWb;
+    private int currentSampleBytesRemaining;
+    private long currentSampleTimeUs;
+    private int currentSampleTotalBytes;
+    private boolean hasOutputFormat;
+    private boolean isWideBand;
+    private final byte[] scratch = new byte[1];
+    private TrackOutput trackOutput;
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.amr.AmrExtractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new AmrExtractor()};
+        }
+    };
+    private static final int[] frameSizeBytesByTypeNb = {13, 14, 16, 18, 20, 21, 27, 32, 6, 7, 6, 6, 1, 1, 1, 1};
+    private static final byte[] amrSignatureNb = Util.getUtf8Bytes("#!AMR\n");
+    private static final byte[] amrSignatureWb = Util.getUtf8Bytes("#!AMR-WB\n");
+
+    private boolean isNarrowBandValidFrameType(int i) {
+        return !this.isWideBand && (i < 12 || i > 14);
+    }
+
+    private boolean isWideBandValidFrameType(int i) {
+        return this.isWideBand && (i < 10 || i > 13);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.currentSampleTimeUs = 0L;
+        this.currentSampleTotalBytes = 0;
+        this.currentSampleBytesRemaining = 0;
+    }
+
+    static {
+        int[] iArr = {18, 24, 33, 37, 41, 47, 51, 59, 61, 6, 1, 1, 1, 1, 1, 1};
+        frameSizeBytesByTypeWb = iArr;
+        MAX_FRAME_SIZE_BYTES = iArr[8];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        return readAmrHeader(extractorInput);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        extractorOutput.seekMap(new SeekMap.Unseekable(C.TIME_UNSET));
+        this.trackOutput = extractorOutput.track(0, 1);
+        extractorOutput.endTracks();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        if (extractorInput.getPosition() == 0 && !readAmrHeader(extractorInput)) {
+            throw new ParserException("Could not find AMR header.");
+        }
+        maybeOutputFormat();
+        return readSample(extractorInput);
+    }
+
+    public static int frameSizeBytesByTypeNb(int i) {
+        return frameSizeBytesByTypeNb[i];
+    }
+
+    public static int frameSizeBytesByTypeWb(int i) {
+        return frameSizeBytesByTypeWb[i];
+    }
+
+    public static byte[] amrSignatureNb() {
+        byte[] bArr = amrSignatureNb;
+        return Arrays.copyOf(bArr, bArr.length);
+    }
+
+    public static byte[] amrSignatureWb() {
+        byte[] bArr = amrSignatureWb;
+        return Arrays.copyOf(bArr, bArr.length);
+    }
+
+    private boolean readAmrHeader(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        byte[] bArr = amrSignatureNb;
+        if (peekAmrSignature(extractorInput, bArr)) {
+            this.isWideBand = false;
+            extractorInput.skipFully(bArr.length);
+            return true;
+        }
+        byte[] bArr2 = amrSignatureWb;
+        if (!peekAmrSignature(extractorInput, bArr2)) {
+            return false;
+        }
+        this.isWideBand = true;
+        extractorInput.skipFully(bArr2.length);
+        return true;
+    }
+
+    private boolean peekAmrSignature(ExtractorInput extractorInput, byte[] bArr) throws IOException, InterruptedException {
+        extractorInput.resetPeekPosition();
+        byte[] bArr2 = new byte[bArr.length];
+        extractorInput.peekFully(bArr2, 0, bArr.length);
+        return Arrays.equals(bArr2, bArr);
+    }
+
+    private void maybeOutputFormat() {
+        if (this.hasOutputFormat) {
+            return;
+        }
+        this.hasOutputFormat = true;
+        boolean z = this.isWideBand;
+        this.trackOutput.format(Format.createAudioSampleFormat(null, z ? MimeTypes.AUDIO_AMR_WB : MimeTypes.AUDIO_AMR_NB, null, -1, MAX_FRAME_SIZE_BYTES, 1, z ? SAMPLE_RATE_WB : 8000, -1, null, null, 0, null));
+    }
+
+    private int readSample(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        if (this.currentSampleBytesRemaining == 0) {
+            try {
+                int readNextSampleSize = readNextSampleSize(extractorInput);
+                this.currentSampleTotalBytes = readNextSampleSize;
+                this.currentSampleBytesRemaining = readNextSampleSize;
+            } catch (EOFException unused) {
+                return -1;
+            }
+        }
+        int sampleData = this.trackOutput.sampleData(extractorInput, this.currentSampleBytesRemaining, true);
+        if (sampleData == -1) {
+            return -1;
+        }
+        int i = this.currentSampleBytesRemaining - sampleData;
+        this.currentSampleBytesRemaining = i;
+        if (i > 0) {
+            return 0;
+        }
+        this.trackOutput.sampleMetadata(this.currentSampleTimeUs, 1, this.currentSampleTotalBytes, 0, null);
+        this.currentSampleTimeUs += 20000;
+        return 0;
+    }
+
+    private int readNextSampleSize(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        extractorInput.resetPeekPosition();
+        extractorInput.peekFully(this.scratch, 0, 1);
+        byte b = this.scratch[0];
+        if ((b & 131) > 0) {
+            throw new ParserException("Invalid padding bits for frame header " + ((int) b));
+        }
+        return getFrameSizeInBytes((b >> 3) & 15);
+    }
+
+    private int getFrameSizeInBytes(int i) throws ParserException {
+        if (isValidFrameType(i)) {
+            return this.isWideBand ? frameSizeBytesByTypeWb[i] : frameSizeBytesByTypeNb[i];
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append("Illegal AMR ");
+        sb.append(this.isWideBand ? "WB" : "NB");
+        sb.append(" frame type ");
+        sb.append(i);
+        throw new ParserException(sb.toString());
+    }
+
+    private boolean isValidFrameType(int i) {
+        return i >= 0 && i <= 15 && (isWideBandValidFrameType(i) || isNarrowBandValidFrameType(i));
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/flv/AudioTagPayloadReader.java

@@ -0,0 +1,81 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.flv;
+
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.CodecSpecificDataUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.Collections;
+
+/* loaded from: classes4.dex */
+final class AudioTagPayloadReader extends TagPayloadReader {
+    private static final int AAC_PACKET_TYPE_AAC_RAW = 1;
+    private static final int AAC_PACKET_TYPE_SEQUENCE_HEADER = 0;
+    private static final int AUDIO_FORMAT_AAC = 10;
+    private static final int AUDIO_FORMAT_ALAW = 7;
+    private static final int AUDIO_FORMAT_MP3 = 2;
+    private static final int AUDIO_FORMAT_ULAW = 8;
+    private static final int[] AUDIO_SAMPLING_RATE_TABLE = {5512, 11025, 22050, 44100};
+    private int audioFormat;
+    private boolean hasOutputFormat;
+    private boolean hasParsedAudioDataHeader;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final void seek() {
+    }
+
+    public AudioTagPayloadReader(TrackOutput trackOutput) {
+        super(trackOutput);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final boolean parseHeader(ParsableByteArray parsableByteArray) throws TagPayloadReader.UnsupportedFormatException {
+        if (!this.hasParsedAudioDataHeader) {
+            int readUnsignedByte = parsableByteArray.readUnsignedByte();
+            int i = (readUnsignedByte >> 4) & 15;
+            this.audioFormat = i;
+            if (i == 2) {
+                this.output.format(Format.createAudioSampleFormat(null, MimeTypes.AUDIO_MPEG, null, -1, -1, 1, AUDIO_SAMPLING_RATE_TABLE[(readUnsignedByte >> 2) & 3], null, null, 0, null));
+                this.hasOutputFormat = true;
+            } else if (i == 7 || i == 8) {
+                this.output.format(Format.createAudioSampleFormat(null, i == 7 ? MimeTypes.AUDIO_ALAW : MimeTypes.AUDIO_MLAW, null, -1, -1, 1, 8000, (readUnsignedByte & 1) == 1 ? 2 : 3, null, null, 0, null));
+                this.hasOutputFormat = true;
+            } else if (i != 10) {
+                throw new TagPayloadReader.UnsupportedFormatException("Audio format not supported: " + this.audioFormat);
+            }
+            this.hasParsedAudioDataHeader = true;
+        } else {
+            parsableByteArray.skipBytes(1);
+        }
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final void parsePayload(ParsableByteArray parsableByteArray, long j) throws ParserException {
+        if (this.audioFormat == 2) {
+            int bytesLeft = parsableByteArray.bytesLeft();
+            this.output.sampleData(parsableByteArray, bytesLeft);
+            this.output.sampleMetadata(j, 1, bytesLeft, 0, null);
+            return;
+        }
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        if (readUnsignedByte != 0 || this.hasOutputFormat) {
+            if (this.audioFormat != 10 || readUnsignedByte == 1) {
+                int bytesLeft2 = parsableByteArray.bytesLeft();
+                this.output.sampleData(parsableByteArray, bytesLeft2);
+                this.output.sampleMetadata(j, 1, bytesLeft2, 0, null);
+                return;
+            }
+            return;
+        }
+        int bytesLeft3 = parsableByteArray.bytesLeft();
+        byte[] bArr = new byte[bytesLeft3];
+        parsableByteArray.readBytes(bArr, 0, bytesLeft3);
+        Pair<Integer, Integer> parseAacAudioSpecificConfig = CodecSpecificDataUtil.parseAacAudioSpecificConfig(bArr);
+        this.output.format(Format.createAudioSampleFormat(null, MimeTypes.AUDIO_AAC, null, -1, -1, ((Integer) parseAacAudioSpecificConfig.second).intValue(), ((Integer) parseAacAudioSpecificConfig.first).intValue(), Collections.singletonList(bArr), null, 0, null));
+        this.hasOutputFormat = true;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/flv/FlvExtractor.java

@@ -0,0 +1,203 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.flv;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class FlvExtractor implements Extractor {
+    private static final int FLV_HEADER_SIZE = 9;
+    private static final int FLV_TAG_HEADER_SIZE = 11;
+    private static final int STATE_READING_FLV_HEADER = 1;
+    private static final int STATE_READING_TAG_DATA = 4;
+    private static final int STATE_READING_TAG_HEADER = 3;
+    private static final int STATE_SKIPPING_TO_TAG_HEADER = 2;
+    private static final int TAG_TYPE_AUDIO = 8;
+    private static final int TAG_TYPE_SCRIPT_DATA = 18;
+    private static final int TAG_TYPE_VIDEO = 9;
+    private AudioTagPayloadReader audioReader;
+    private int bytesToNextTagHeader;
+    private ExtractorOutput extractorOutput;
+    private boolean outputSeekMap;
+    private int tagDataSize;
+    private long tagTimestampUs;
+    private int tagType;
+    private VideoTagPayloadReader videoReader;
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.FlvExtractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new FlvExtractor()};
+        }
+    };
+    private static final int FLV_TAG = Util.getIntegerCodeForString("FLV");
+    private final ParsableByteArray scratch = new ParsableByteArray(4);
+    private final ParsableByteArray headerBuffer = new ParsableByteArray(9);
+    private final ParsableByteArray tagHeaderBuffer = new ParsableByteArray(11);
+    private final ParsableByteArray tagData = new ParsableByteArray();
+    private final ScriptTagPayloadReader metadataReader = new ScriptTagPayloadReader();
+    private int state = 1;
+    private long mediaTagTimestampOffsetUs = C.TIME_UNSET;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface States {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        this.extractorOutput = extractorOutput;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.state = 1;
+        this.mediaTagTimestampOffsetUs = C.TIME_UNSET;
+        this.bytesToNextTagHeader = 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        extractorInput.peekFully(this.scratch.data, 0, 3);
+        this.scratch.setPosition(0);
+        if (this.scratch.readUnsignedInt24() != FLV_TAG) {
+            return false;
+        }
+        extractorInput.peekFully(this.scratch.data, 0, 2);
+        this.scratch.setPosition(0);
+        if ((this.scratch.readUnsignedShort() & 250) != 0) {
+            return false;
+        }
+        extractorInput.peekFully(this.scratch.data, 0, 4);
+        this.scratch.setPosition(0);
+        int readInt = this.scratch.readInt();
+        extractorInput.resetPeekPosition();
+        extractorInput.advancePeekPosition(readInt);
+        extractorInput.peekFully(this.scratch.data, 0, 4);
+        this.scratch.setPosition(0);
+        return this.scratch.readInt() == 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        while (true) {
+            int i = this.state;
+            if (i != 1) {
+                if (i == 2) {
+                    skipToTagHeader(extractorInput);
+                } else if (i != 3) {
+                    if (i == 4) {
+                        if (readTagData(extractorInput)) {
+                            return 0;
+                        }
+                    } else {
+                        throw new IllegalStateException();
+                    }
+                } else if (!readTagHeader(extractorInput)) {
+                    return -1;
+                }
+            } else if (!readFlvHeader(extractorInput)) {
+                return -1;
+            }
+        }
+    }
+
+    private boolean readFlvHeader(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        if (!extractorInput.readFully(this.headerBuffer.data, 0, 9, true)) {
+            return false;
+        }
+        this.headerBuffer.setPosition(0);
+        this.headerBuffer.skipBytes(4);
+        int readUnsignedByte = this.headerBuffer.readUnsignedByte();
+        boolean z = (readUnsignedByte & 4) != 0;
+        boolean z2 = (readUnsignedByte & 1) != 0;
+        if (z && this.audioReader == null) {
+            this.audioReader = new AudioTagPayloadReader(this.extractorOutput.track(8, 1));
+        }
+        if (z2 && this.videoReader == null) {
+            this.videoReader = new VideoTagPayloadReader(this.extractorOutput.track(9, 2));
+        }
+        this.extractorOutput.endTracks();
+        this.bytesToNextTagHeader = this.headerBuffer.readInt() - 5;
+        this.state = 2;
+        return true;
+    }
+
+    private void skipToTagHeader(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        extractorInput.skipFully(this.bytesToNextTagHeader);
+        this.bytesToNextTagHeader = 0;
+        this.state = 3;
+    }
+
+    private boolean readTagHeader(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        if (!extractorInput.readFully(this.tagHeaderBuffer.data, 0, 11, true)) {
+            return false;
+        }
+        this.tagHeaderBuffer.setPosition(0);
+        this.tagType = this.tagHeaderBuffer.readUnsignedByte();
+        this.tagDataSize = this.tagHeaderBuffer.readUnsignedInt24();
+        this.tagTimestampUs = this.tagHeaderBuffer.readUnsignedInt24();
+        this.tagTimestampUs = ((this.tagHeaderBuffer.readUnsignedByte() << 24) | this.tagTimestampUs) * 1000;
+        this.tagHeaderBuffer.skipBytes(3);
+        this.state = 4;
+        return true;
+    }
+
+    private boolean readTagData(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        int i = this.tagType;
+        boolean z = true;
+        if (i == 8 && this.audioReader != null) {
+            ensureReadyForMediaOutput();
+            this.audioReader.consume(prepareTagData(extractorInput), this.mediaTagTimestampOffsetUs + this.tagTimestampUs);
+        } else if (i == 9 && this.videoReader != null) {
+            ensureReadyForMediaOutput();
+            this.videoReader.consume(prepareTagData(extractorInput), this.mediaTagTimestampOffsetUs + this.tagTimestampUs);
+        } else if (i == 18 && !this.outputSeekMap) {
+            this.metadataReader.consume(prepareTagData(extractorInput), this.tagTimestampUs);
+            long durationUs = this.metadataReader.getDurationUs();
+            if (durationUs != C.TIME_UNSET) {
+                this.extractorOutput.seekMap(new SeekMap.Unseekable(durationUs));
+                this.outputSeekMap = true;
+            }
+        } else {
+            extractorInput.skipFully(this.tagDataSize);
+            z = false;
+        }
+        this.bytesToNextTagHeader = 4;
+        this.state = 2;
+        return z;
+    }
+
+    private ParsableByteArray prepareTagData(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        if (this.tagDataSize > this.tagData.capacity()) {
+            ParsableByteArray parsableByteArray = this.tagData;
+            parsableByteArray.reset(new byte[Math.max(parsableByteArray.capacity() * 2, this.tagDataSize)], 0);
+        } else {
+            this.tagData.setPosition(0);
+        }
+        this.tagData.setLimit(this.tagDataSize);
+        extractorInput.readFully(this.tagData.data, 0, this.tagDataSize);
+        return this.tagData;
+    }
+
+    private void ensureReadyForMediaOutput() {
+        if (!this.outputSeekMap) {
+            this.extractorOutput.seekMap(new SeekMap.Unseekable(C.TIME_UNSET));
+            this.outputSeekMap = true;
+        }
+        if (this.mediaTagTimestampOffsetUs == C.TIME_UNSET) {
+            this.mediaTagTimestampOffsetUs = this.metadataReader.getDurationUs() == C.TIME_UNSET ? -this.tagTimestampUs : 0L;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/flv/ScriptTagPayloadReader.java

@@ -0,0 +1,137 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.flv;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+
+/* loaded from: classes4.dex */
+final class ScriptTagPayloadReader extends TagPayloadReader {
+    private static final int AMF_TYPE_BOOLEAN = 1;
+    private static final int AMF_TYPE_DATE = 11;
+    private static final int AMF_TYPE_ECMA_ARRAY = 8;
+    private static final int AMF_TYPE_END_MARKER = 9;
+    private static final int AMF_TYPE_NUMBER = 0;
+    private static final int AMF_TYPE_OBJECT = 3;
+    private static final int AMF_TYPE_STRICT_ARRAY = 10;
+    private static final int AMF_TYPE_STRING = 2;
+    private static final String KEY_DURATION = "duration";
+    private static final String NAME_METADATA = "onMetaData";
+    private long durationUs;
+
+    public final long getDurationUs() {
+        return this.durationUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final boolean parseHeader(ParsableByteArray parsableByteArray) {
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final void seek() {
+    }
+
+    public ScriptTagPayloadReader() {
+        super(null);
+        this.durationUs = C.TIME_UNSET;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final void parsePayload(ParsableByteArray parsableByteArray, long j) throws ParserException {
+        if (readAmfType(parsableByteArray) != 2) {
+            throw new ParserException();
+        }
+        if (NAME_METADATA.equals(readAmfString(parsableByteArray)) && readAmfType(parsableByteArray) == 8) {
+            HashMap<String, Object> readAmfEcmaArray = readAmfEcmaArray(parsableByteArray);
+            if (readAmfEcmaArray.containsKey("duration")) {
+                double doubleValue = ((Double) readAmfEcmaArray.get("duration")).doubleValue();
+                if (doubleValue > 0.0d) {
+                    this.durationUs = (long) (doubleValue * 1000000.0d);
+                }
+            }
+        }
+    }
+
+    private static int readAmfType(ParsableByteArray parsableByteArray) {
+        return parsableByteArray.readUnsignedByte();
+    }
+
+    private static Boolean readAmfBoolean(ParsableByteArray parsableByteArray) {
+        return Boolean.valueOf(parsableByteArray.readUnsignedByte() == 1);
+    }
+
+    private static Double readAmfDouble(ParsableByteArray parsableByteArray) {
+        return Double.valueOf(Double.longBitsToDouble(parsableByteArray.readLong()));
+    }
+
+    private static String readAmfString(ParsableByteArray parsableByteArray) {
+        int readUnsignedShort = parsableByteArray.readUnsignedShort();
+        int position = parsableByteArray.getPosition();
+        parsableByteArray.skipBytes(readUnsignedShort);
+        return new String(parsableByteArray.data, position, readUnsignedShort);
+    }
+
+    private static ArrayList<Object> readAmfStrictArray(ParsableByteArray parsableByteArray) {
+        int readUnsignedIntToInt = parsableByteArray.readUnsignedIntToInt();
+        ArrayList<Object> arrayList = new ArrayList<>(readUnsignedIntToInt);
+        for (int i = 0; i < readUnsignedIntToInt; i++) {
+            arrayList.add(readAmfData(parsableByteArray, readAmfType(parsableByteArray)));
+        }
+        return arrayList;
+    }
+
+    private static HashMap<String, Object> readAmfObject(ParsableByteArray parsableByteArray) {
+        HashMap<String, Object> hashMap = new HashMap<>();
+        while (true) {
+            String readAmfString = readAmfString(parsableByteArray);
+            int readAmfType = readAmfType(parsableByteArray);
+            if (readAmfType == 9) {
+                return hashMap;
+            }
+            hashMap.put(readAmfString, readAmfData(parsableByteArray, readAmfType));
+        }
+    }
+
+    private static HashMap<String, Object> readAmfEcmaArray(ParsableByteArray parsableByteArray) {
+        int readUnsignedIntToInt = parsableByteArray.readUnsignedIntToInt();
+        HashMap<String, Object> hashMap = new HashMap<>(readUnsignedIntToInt);
+        for (int i = 0; i < readUnsignedIntToInt; i++) {
+            hashMap.put(readAmfString(parsableByteArray), readAmfData(parsableByteArray, readAmfType(parsableByteArray)));
+        }
+        return hashMap;
+    }
+
+    private static Date readAmfDate(ParsableByteArray parsableByteArray) {
+        Date date = new Date((long) readAmfDouble(parsableByteArray).doubleValue());
+        parsableByteArray.skipBytes(2);
+        return date;
+    }
+
+    private static Object readAmfData(ParsableByteArray parsableByteArray, int i) {
+        if (i == 0) {
+            return readAmfDouble(parsableByteArray);
+        }
+        if (i == 1) {
+            return readAmfBoolean(parsableByteArray);
+        }
+        if (i == 2) {
+            return readAmfString(parsableByteArray);
+        }
+        if (i == 3) {
+            return readAmfObject(parsableByteArray);
+        }
+        if (i == 8) {
+            return readAmfEcmaArray(parsableByteArray);
+        }
+        if (i == 10) {
+            return readAmfStrictArray(parsableByteArray);
+        }
+        if (i != 11) {
+            return null;
+        }
+        return readAmfDate(parsableByteArray);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/flv/TagPayloadReader.java

@@ -0,0 +1,32 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.flv;
+
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+
+/* loaded from: classes4.dex */
+abstract class TagPayloadReader {
+    protected final TrackOutput output;
+
+    public abstract boolean parseHeader(ParsableByteArray parsableByteArray) throws ParserException;
+
+    public abstract void parsePayload(ParsableByteArray parsableByteArray, long j) throws ParserException;
+
+    public abstract void seek();
+
+    public static final class UnsupportedFormatException extends ParserException {
+        public UnsupportedFormatException(String str) {
+            super(str);
+        }
+    }
+
+    public TagPayloadReader(TrackOutput trackOutput) {
+        this.output = trackOutput;
+    }
+
+    public final void consume(ParsableByteArray parsableByteArray, long j) throws ParserException {
+        if (parseHeader(parsableByteArray)) {
+            parsePayload(parsableByteArray, j);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/flv/VideoTagPayloadReader.java

@@ -0,0 +1,78 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.flv;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.NalUnitUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.video.AvcConfig;
+
+/* loaded from: classes4.dex */
+final class VideoTagPayloadReader extends TagPayloadReader {
+    private static final int AVC_PACKET_TYPE_AVC_NALU = 1;
+    private static final int AVC_PACKET_TYPE_SEQUENCE_HEADER = 0;
+    private static final int VIDEO_CODEC_AVC = 7;
+    private static final int VIDEO_FRAME_KEYFRAME = 1;
+    private static final int VIDEO_FRAME_VIDEO_INFO = 5;
+    private int frameType;
+    private boolean hasOutputFormat;
+    private final ParsableByteArray nalLength;
+    private final ParsableByteArray nalStartCode;
+    private int nalUnitLengthFieldLength;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final void seek() {
+    }
+
+    public VideoTagPayloadReader(TrackOutput trackOutput) {
+        super(trackOutput);
+        this.nalStartCode = new ParsableByteArray(NalUnitUtil.NAL_START_CODE);
+        this.nalLength = new ParsableByteArray(4);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final boolean parseHeader(ParsableByteArray parsableByteArray) throws TagPayloadReader.UnsupportedFormatException {
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        int i = (readUnsignedByte >> 4) & 15;
+        int i2 = readUnsignedByte & 15;
+        if (i2 == 7) {
+            this.frameType = i;
+            return i != 5;
+        }
+        throw new TagPayloadReader.UnsupportedFormatException("Video format not supported: " + i2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.TagPayloadReader
+    public final void parsePayload(ParsableByteArray parsableByteArray, long j) throws ParserException {
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        long readInt24 = j + (parsableByteArray.readInt24() * 1000);
+        if (readUnsignedByte == 0 && !this.hasOutputFormat) {
+            ParsableByteArray parsableByteArray2 = new ParsableByteArray(new byte[parsableByteArray.bytesLeft()]);
+            parsableByteArray.readBytes(parsableByteArray2.data, 0, parsableByteArray.bytesLeft());
+            AvcConfig parse = AvcConfig.parse(parsableByteArray2);
+            this.nalUnitLengthFieldLength = parse.nalUnitLengthFieldLength;
+            this.output.format(Format.createVideoSampleFormat(null, "video/avc", null, -1, -1, parse.width, parse.height, -1.0f, parse.initializationData, -1, parse.pixelWidthAspectRatio, null));
+            this.hasOutputFormat = true;
+            return;
+        }
+        if (readUnsignedByte == 1 && this.hasOutputFormat) {
+            byte[] bArr = this.nalLength.data;
+            bArr[0] = 0;
+            bArr[1] = 0;
+            bArr[2] = 0;
+            int i = 4 - this.nalUnitLengthFieldLength;
+            int i2 = 0;
+            while (parsableByteArray.bytesLeft() > 0) {
+                parsableByteArray.readBytes(this.nalLength.data, i, this.nalUnitLengthFieldLength);
+                this.nalLength.setPosition(0);
+                int readUnsignedIntToInt = this.nalLength.readUnsignedIntToInt();
+                this.nalStartCode.setPosition(0);
+                this.output.sampleData(this.nalStartCode, 4);
+                this.output.sampleData(parsableByteArray, readUnsignedIntToInt);
+                i2 = i2 + 4 + readUnsignedIntToInt;
+            }
+            this.output.sampleMetadata(readInt24, this.frameType == 1 ? 1 : 0, i2, 0, null);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mkv/DefaultEbmlReader.java

@@ -0,0 +1,171 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv;
+
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayDeque;
+
+/* loaded from: classes4.dex */
+final class DefaultEbmlReader implements EbmlReader {
+    private static final int ELEMENT_STATE_READ_CONTENT = 2;
+    private static final int ELEMENT_STATE_READ_CONTENT_SIZE = 1;
+    private static final int ELEMENT_STATE_READ_ID = 0;
+    private static final int MAX_ID_BYTES = 4;
+    private static final int MAX_INTEGER_ELEMENT_SIZE_BYTES = 8;
+    private static final int MAX_LENGTH_BYTES = 8;
+    private static final int VALID_FLOAT32_ELEMENT_SIZE_BYTES = 4;
+    private static final int VALID_FLOAT64_ELEMENT_SIZE_BYTES = 8;
+    private long elementContentSize;
+    private int elementId;
+    private int elementState;
+    private EbmlReaderOutput output;
+    private final byte[] scratch = new byte[8];
+    private final ArrayDeque<MasterElement> masterElementsStack = new ArrayDeque<>();
+    private final VarintReader varintReader = new VarintReader();
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ElementState {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv.EbmlReader
+    public final void init(EbmlReaderOutput ebmlReaderOutput) {
+        this.output = ebmlReaderOutput;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv.EbmlReader
+    public final void reset() {
+        this.elementState = 0;
+        this.masterElementsStack.clear();
+        this.varintReader.reset();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv.EbmlReader
+    public final boolean read(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        Assertions.checkState(this.output != null);
+        while (true) {
+            if (this.masterElementsStack.isEmpty() || extractorInput.getPosition() < this.masterElementsStack.peek().elementEndPosition) {
+                if (this.elementState == 0) {
+                    long readUnsignedVarint = this.varintReader.readUnsignedVarint(extractorInput, true, false, 4);
+                    if (readUnsignedVarint == -2) {
+                        readUnsignedVarint = maybeResyncToNextLevel1Element(extractorInput);
+                    }
+                    if (readUnsignedVarint == -1) {
+                        return false;
+                    }
+                    this.elementId = (int) readUnsignedVarint;
+                    this.elementState = 1;
+                }
+                if (this.elementState == 1) {
+                    this.elementContentSize = this.varintReader.readUnsignedVarint(extractorInput, false, true, 8);
+                    this.elementState = 2;
+                }
+                int elementType = this.output.getElementType(this.elementId);
+                if (elementType != 0) {
+                    if (elementType == 1) {
+                        long position = extractorInput.getPosition();
+                        this.masterElementsStack.push(new MasterElement(this.elementId, this.elementContentSize + position));
+                        this.output.startMasterElement(this.elementId, position, this.elementContentSize);
+                        this.elementState = 0;
+                        return true;
+                    }
+                    if (elementType == 2) {
+                        long j = this.elementContentSize;
+                        if (j > 8) {
+                            throw new ParserException("Invalid integer size: " + this.elementContentSize);
+                        }
+                        this.output.integerElement(this.elementId, readInteger(extractorInput, (int) j));
+                        this.elementState = 0;
+                        return true;
+                    }
+                    if (elementType == 3) {
+                        long j2 = this.elementContentSize;
+                        if (j2 > 2147483647L) {
+                            throw new ParserException("String element size: " + this.elementContentSize);
+                        }
+                        this.output.stringElement(this.elementId, readString(extractorInput, (int) j2));
+                        this.elementState = 0;
+                        return true;
+                    }
+                    if (elementType == 4) {
+                        this.output.binaryElement(this.elementId, (int) this.elementContentSize, extractorInput);
+                        this.elementState = 0;
+                        return true;
+                    }
+                    if (elementType != 5) {
+                        throw new ParserException("Invalid element type " + elementType);
+                    }
+                    long j3 = this.elementContentSize;
+                    if (j3 != 4 && j3 != 8) {
+                        throw new ParserException("Invalid float size: " + this.elementContentSize);
+                    }
+                    this.output.floatElement(this.elementId, readFloat(extractorInput, (int) j3));
+                    this.elementState = 0;
+                    return true;
+                }
+                extractorInput.skipFully((int) this.elementContentSize);
+                this.elementState = 0;
+            } else {
+                this.output.endMasterElement(this.masterElementsStack.pop().elementId);
+                return true;
+            }
+        }
+    }
+
+    private long maybeResyncToNextLevel1Element(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        extractorInput.resetPeekPosition();
+        while (true) {
+            extractorInput.peekFully(this.scratch, 0, 4);
+            int parseUnsignedVarintLength = VarintReader.parseUnsignedVarintLength(this.scratch[0]);
+            if (parseUnsignedVarintLength != -1 && parseUnsignedVarintLength <= 4) {
+                int assembleVarint = (int) VarintReader.assembleVarint(this.scratch, parseUnsignedVarintLength, false);
+                if (this.output.isLevel1Element(assembleVarint)) {
+                    extractorInput.skipFully(parseUnsignedVarintLength);
+                    return assembleVarint;
+                }
+            }
+            extractorInput.skipFully(1);
+        }
+    }
+
+    private long readInteger(ExtractorInput extractorInput, int i) throws IOException, InterruptedException {
+        extractorInput.readFully(this.scratch, 0, i);
+        long j = 0;
+        for (int i2 = 0; i2 < i; i2++) {
+            j = (j << 8) | (this.scratch[i2] & 255);
+        }
+        return j;
+    }
+
+    private double readFloat(ExtractorInput extractorInput, int i) throws IOException, InterruptedException {
+        long readInteger = readInteger(extractorInput, i);
+        if (i == 4) {
+            return Float.intBitsToFloat((int) readInteger);
+        }
+        return Double.longBitsToDouble(readInteger);
+    }
+
+    private String readString(ExtractorInput extractorInput, int i) throws IOException, InterruptedException {
+        if (i == 0) {
+            return "";
+        }
+        byte[] bArr = new byte[i];
+        extractorInput.readFully(bArr, 0, i);
+        while (i > 0 && bArr[i - 1] == 0) {
+            i--;
+        }
+        return new String(bArr, 0, i);
+    }
+
+    public static final class MasterElement {
+        private final long elementEndPosition;
+        private final int elementId;
+
+        private MasterElement(int i, long j) {
+            this.elementId = i;
+            this.elementEndPosition = j;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mkv/EbmlReader.java

@@ -0,0 +1,13 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+interface EbmlReader {
+    void init(EbmlReaderOutput ebmlReaderOutput);
+
+    boolean read(ExtractorInput extractorInput) throws IOException, InterruptedException;
+
+    void reset();
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mkv/EbmlReaderOutput.java

@@ -0,0 +1,37 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv;
+
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+interface EbmlReaderOutput {
+    public static final int TYPE_BINARY = 4;
+    public static final int TYPE_FLOAT = 5;
+    public static final int TYPE_MASTER = 1;
+    public static final int TYPE_STRING = 3;
+    public static final int TYPE_UNKNOWN = 0;
+    public static final int TYPE_UNSIGNED_INT = 2;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ElementType {
+    }
+
+    void binaryElement(int i, int i2, ExtractorInput extractorInput) throws IOException, InterruptedException;
+
+    void endMasterElement(int i) throws ParserException;
+
+    void floatElement(int i, double d) throws ParserException;
+
+    int getElementType(int i);
+
+    void integerElement(int i, long j) throws ParserException;
+
+    boolean isLevel1Element(int i);
+
+    void startMasterElement(int i, long j, long j2) throws ParserException;
+
+    void stringElement(int i, String str) throws ParserException;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mkv/Sniffer.java

@@ -0,0 +1,86 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv;
+
+import android.support.v4.media.session.PlaybackStateCompat;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+final class Sniffer {
+    private static final int ID_EBML = 440786851;
+    private static final int SEARCH_LENGTH = 1024;
+    private int peekLength;
+    private final ParsableByteArray scratch = new ParsableByteArray(8);
+
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        long length = extractorInput.getLength();
+        long j = PlaybackStateCompat.ACTION_PLAY_FROM_MEDIA_ID;
+        if (length != -1 && length <= PlaybackStateCompat.ACTION_PLAY_FROM_MEDIA_ID) {
+            j = length;
+        }
+        int i = (int) j;
+        extractorInput.peekFully(this.scratch.data, 0, 4);
+        long readUnsignedInt = this.scratch.readUnsignedInt();
+        this.peekLength = 4;
+        while (readUnsignedInt != 440786851) {
+            int i2 = this.peekLength + 1;
+            this.peekLength = i2;
+            if (i2 == i) {
+                return false;
+            }
+            extractorInput.peekFully(this.scratch.data, 0, 1);
+            readUnsignedInt = ((readUnsignedInt << 8) & (-256)) | (this.scratch.data[0] & 255);
+        }
+        long readUint = readUint(extractorInput);
+        long j2 = this.peekLength;
+        if (readUint == Long.MIN_VALUE) {
+            return false;
+        }
+        if (length != -1 && j2 + readUint >= length) {
+            return false;
+        }
+        while (true) {
+            int i3 = this.peekLength;
+            long j3 = j2 + readUint;
+            if (i3 >= j3) {
+                return ((long) i3) == j3;
+            }
+            if (readUint(extractorInput) == Long.MIN_VALUE) {
+                return false;
+            }
+            long readUint2 = readUint(extractorInput);
+            if (readUint2 < 0 || readUint2 > 2147483647L) {
+                break;
+            }
+            if (readUint2 != 0) {
+                int i4 = (int) readUint2;
+                extractorInput.advancePeekPosition(i4);
+                this.peekLength += i4;
+            }
+        }
+        return false;
+    }
+
+    private long readUint(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        int i = 0;
+        extractorInput.peekFully(this.scratch.data, 0, 1);
+        int i2 = this.scratch.data[0] & 255;
+        if (i2 == 0) {
+            return Long.MIN_VALUE;
+        }
+        int i3 = 128;
+        int i4 = 0;
+        while ((i2 & i3) == 0) {
+            i3 >>= 1;
+            i4++;
+        }
+        int i5 = i2 & (~i3);
+        extractorInput.peekFully(this.scratch.data, 1, i4);
+        while (i < i4) {
+            i++;
+            i5 = (this.scratch.data[i] & 255) + (i5 << 8);
+        }
+        this.peekLength += i4 + 1;
+        return i5;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mkv/VarintReader.java

@@ -0,0 +1,72 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+final class VarintReader {
+    private static final int STATE_BEGIN_READING = 0;
+    private static final int STATE_READ_CONTENTS = 1;
+    private static final long[] VARINT_LENGTH_MASKS = {128, 64, 32, 16, 8, 4, 2, 1};
+    private int length;
+    private final byte[] scratch = new byte[8];
+    private int state;
+
+    public final int getLastLength() {
+        return this.length;
+    }
+
+    public final void reset() {
+        this.state = 0;
+        this.length = 0;
+    }
+
+    public final long readUnsignedVarint(ExtractorInput extractorInput, boolean z, boolean z2, int i) throws IOException, InterruptedException {
+        if (this.state == 0) {
+            if (!extractorInput.readFully(this.scratch, 0, 1, z)) {
+                return -1L;
+            }
+            int parseUnsignedVarintLength = parseUnsignedVarintLength(this.scratch[0] & 255);
+            this.length = parseUnsignedVarintLength;
+            if (parseUnsignedVarintLength == -1) {
+                throw new IllegalStateException("No valid varint length mask found");
+            }
+            this.state = 1;
+        }
+        int i2 = this.length;
+        if (i2 > i) {
+            this.state = 0;
+            return -2L;
+        }
+        if (i2 != 1) {
+            extractorInput.readFully(this.scratch, 1, i2 - 1);
+        }
+        this.state = 0;
+        return assembleVarint(this.scratch, this.length, z2);
+    }
+
+    public static int parseUnsignedVarintLength(int i) {
+        int i2 = 0;
+        while (true) {
+            long[] jArr = VARINT_LENGTH_MASKS;
+            if (i2 >= jArr.length) {
+                return -1;
+            }
+            if ((jArr[i2] & i) != 0) {
+                return i2 + 1;
+            }
+            i2++;
+        }
+    }
+
+    public static long assembleVarint(byte[] bArr, int i, boolean z) {
+        long j = bArr[0] & 255;
+        if (z) {
+            j &= ~VARINT_LENGTH_MASKS[i - 1];
+        }
+        for (int i2 = 1; i2 < i; i2++) {
+            j = (j << 8) | (bArr[i2] & 255);
+        }
+        return j;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp3/ConstantBitrateSeeker.java

@@ -0,0 +1,68 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.MpegAudioHeader;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekPoint;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+final class ConstantBitrateSeeker implements Mp3Extractor.Seeker {
+    private static final int BITS_PER_BYTE = 8;
+    private final int bitrate;
+    private final long dataSize;
+    private final long durationUs;
+    private final long firstFramePosition;
+    private final int frameSize;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final long getDurationUs() {
+        return this.durationUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final boolean isSeekable() {
+        return this.dataSize != -1;
+    }
+
+    public ConstantBitrateSeeker(long j, long j2, MpegAudioHeader mpegAudioHeader) {
+        this.firstFramePosition = j2;
+        this.frameSize = mpegAudioHeader.frameSize;
+        this.bitrate = mpegAudioHeader.bitrate;
+        if (j == -1) {
+            this.dataSize = -1L;
+            this.durationUs = C.TIME_UNSET;
+        } else {
+            this.dataSize = j - j2;
+            this.durationUs = getTimeUs(j);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final SeekMap.SeekPoints getSeekPoints(long j) {
+        long j2 = this.dataSize;
+        if (j2 == -1) {
+            return new SeekMap.SeekPoints(new SeekPoint(0L, this.firstFramePosition));
+        }
+        int i = this.frameSize;
+        long constrainValue = Util.constrainValue((((this.bitrate * j) / 8000000) / i) * i, 0L, j2 - i);
+        long j3 = this.firstFramePosition + constrainValue;
+        long timeUs = getTimeUs(j3);
+        SeekPoint seekPoint = new SeekPoint(timeUs, j3);
+        if (timeUs < j) {
+            long j4 = this.dataSize;
+            int i2 = this.frameSize;
+            if (constrainValue != j4 - i2) {
+                long j5 = j3 + i2;
+                return new SeekMap.SeekPoints(seekPoint, new SeekPoint(getTimeUs(j5), j5));
+            }
+        }
+        return new SeekMap.SeekPoints(seekPoint);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor.Seeker
+    public final long getTimeUs(long j) {
+        return (Math.max(0L, j - this.firstFramePosition) * 8000000) / this.bitrate;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp3/Mp3Extractor.java

@@ -0,0 +1,380 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.GaplessInfoHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Id3Peeker;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.MpegAudioHeader;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.EOFException;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class Mp3Extractor implements Extractor {
+    public static final int FLAG_DISABLE_ID3_METADATA = 2;
+    public static final int FLAG_ENABLE_CONSTANT_BITRATE_SEEKING = 1;
+    private static final int MAX_SNIFF_BYTES = 16384;
+    private static final int MAX_SYNC_BYTES = 131072;
+    private static final int MPEG_AUDIO_HEADER_MASK = -128000;
+    private static final int SCRATCH_LENGTH = 10;
+    private static final int SEEK_HEADER_UNSET = 0;
+    private long basisTimeUs;
+    private ExtractorOutput extractorOutput;
+    private final int flags;
+    private final long forcedFirstSampleTimestampUs;
+    private final GaplessInfoHolder gaplessInfoHolder;
+    private final Id3Peeker id3Peeker;
+    private Metadata metadata;
+    private int sampleBytesRemaining;
+    private long samplesRead;
+    private final ParsableByteArray scratch;
+    private Seeker seeker;
+    private final MpegAudioHeader synchronizedHeader;
+    private int synchronizedHeaderData;
+    private TrackOutput trackOutput;
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new Mp3Extractor()};
+        }
+    };
+    private static final int SEEK_HEADER_XING = Util.getIntegerCodeForString("Xing");
+    private static final int SEEK_HEADER_INFO = Util.getIntegerCodeForString("Info");
+    private static final int SEEK_HEADER_VBRI = Util.getIntegerCodeForString("VBRI");
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Flags {
+    }
+
+    public interface Seeker extends SeekMap {
+        long getTimeUs(long j);
+    }
+
+    private static boolean headersMatch(int i, long j) {
+        return ((long) (i & MPEG_AUDIO_HEADER_MASK)) == (j & (-128000));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.synchronizedHeaderData = 0;
+        this.basisTimeUs = C.TIME_UNSET;
+        this.samplesRead = 0L;
+        this.sampleBytesRemaining = 0;
+    }
+
+    public Mp3Extractor() {
+        this(0);
+    }
+
+    public Mp3Extractor(int i) {
+        this(i, C.TIME_UNSET);
+    }
+
+    public Mp3Extractor(int i, long j) {
+        this.flags = i;
+        this.forcedFirstSampleTimestampUs = j;
+        this.scratch = new ParsableByteArray(10);
+        this.synchronizedHeader = new MpegAudioHeader();
+        this.gaplessInfoHolder = new GaplessInfoHolder();
+        this.basisTimeUs = C.TIME_UNSET;
+        this.id3Peeker = new Id3Peeker();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        return synchronize(extractorInput, true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        this.extractorOutput = extractorOutput;
+        this.trackOutput = extractorOutput.track(0, 1);
+        this.extractorOutput.endTracks();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        if (this.synchronizedHeaderData == 0) {
+            try {
+                synchronize(extractorInput, false);
+            } catch (EOFException unused) {
+                return -1;
+            }
+        }
+        if (this.seeker == null) {
+            Seeker maybeReadSeekFrame = maybeReadSeekFrame(extractorInput);
+            this.seeker = maybeReadSeekFrame;
+            if (maybeReadSeekFrame == null || (!maybeReadSeekFrame.isSeekable() && (this.flags & 1) != 0)) {
+                this.seeker = getConstantBitrateSeeker(extractorInput);
+            }
+            this.extractorOutput.seekMap(this.seeker);
+            TrackOutput trackOutput = this.trackOutput;
+            MpegAudioHeader mpegAudioHeader = this.synchronizedHeader;
+            String str = mpegAudioHeader.mimeType;
+            int i = mpegAudioHeader.channels;
+            int i2 = mpegAudioHeader.sampleRate;
+            GaplessInfoHolder gaplessInfoHolder = this.gaplessInfoHolder;
+            trackOutput.format(Format.createAudioSampleFormat(null, str, null, -1, 4096, i, i2, -1, gaplessInfoHolder.encoderDelay, gaplessInfoHolder.encoderPadding, null, null, 0, null, (this.flags & 2) != 0 ? null : this.metadata));
+        }
+        return readSample(extractorInput);
+    }
+
+    private int readSample(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        if (this.sampleBytesRemaining == 0) {
+            extractorInput.resetPeekPosition();
+            if (!extractorInput.peekFully(this.scratch.data, 0, 4, true)) {
+                return -1;
+            }
+            this.scratch.setPosition(0);
+            int readInt = this.scratch.readInt();
+            if (!headersMatch(readInt, this.synchronizedHeaderData) || MpegAudioHeader.getFrameSize(readInt) == -1) {
+                extractorInput.skipFully(1);
+                this.synchronizedHeaderData = 0;
+                return 0;
+            }
+            MpegAudioHeader.populateHeader(readInt, this.synchronizedHeader);
+            if (this.basisTimeUs == C.TIME_UNSET) {
+                this.basisTimeUs = this.seeker.getTimeUs(extractorInput.getPosition());
+                if (this.forcedFirstSampleTimestampUs != C.TIME_UNSET) {
+                    this.basisTimeUs += this.forcedFirstSampleTimestampUs - this.seeker.getTimeUs(0L);
+                }
+            }
+            this.sampleBytesRemaining = this.synchronizedHeader.frameSize;
+        }
+        int sampleData = this.trackOutput.sampleData(extractorInput, this.sampleBytesRemaining, true);
+        if (sampleData == -1) {
+            return -1;
+        }
+        int i = this.sampleBytesRemaining - sampleData;
+        this.sampleBytesRemaining = i;
+        if (i > 0) {
+            return 0;
+        }
+        this.trackOutput.sampleMetadata(this.basisTimeUs + ((this.samplesRead * 1000000) / r14.sampleRate), 1, this.synchronizedHeader.frameSize, 0, null);
+        this.samplesRead += this.synchronizedHeader.samplesPerFrame;
+        this.sampleBytesRemaining = 0;
+        return 0;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:50:0x009a, code lost:
+    
+        if (r14 == false) goto L49;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:51:0x009c, code lost:
+    
+        r13.skipFully(r1 + r5);
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:52:0x00a4, code lost:
+    
+        r12.synchronizedHeaderData = r4;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:53:0x00a6, code lost:
+    
+        return true;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:54:0x00a1, code lost:
+    
+        r13.resetPeekPosition();
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private boolean synchronize(com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput r13, boolean r14) throws java.io.IOException, java.lang.InterruptedException {
+        /*
+            r12 = this;
+            if (r14 == 0) goto L5
+            r0 = 16384(0x4000, float:2.2959E-41)
+            goto L7
+        L5:
+            r0 = 131072(0x20000, float:1.83671E-40)
+        L7:
+            r13.resetPeekPosition()
+            long r1 = r13.getPosition()
+            r3 = 0
+            int r1 = (r1 > r3 ? 1 : (r1 == r3 ? 0 : -1))
+            r2 = 0
+            if (r1 != 0) goto L3c
+            int r1 = r12.flags
+            r1 = r1 & 2
+            if (r1 == 0) goto L1e
+            com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.Id3Decoder$FramePredicate r1 = com.mbridge.msdk.playercommon.exoplayer2.extractor.GaplessInfoHolder.GAPLESS_INFO_ID3_FRAME_PREDICATE
+            goto L1f
+        L1e:
+            r1 = 0
+        L1f:
+            com.mbridge.msdk.playercommon.exoplayer2.extractor.Id3Peeker r3 = r12.id3Peeker
+            com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata r1 = r3.peekId3Data(r13, r1)
+            r12.metadata = r1
+            if (r1 == 0) goto L2e
+            com.mbridge.msdk.playercommon.exoplayer2.extractor.GaplessInfoHolder r3 = r12.gaplessInfoHolder
+            r3.setFromMetadata(r1)
+        L2e:
+            long r3 = r13.getPeekPosition()
+            int r1 = (int) r3
+            if (r14 != 0) goto L38
+            r13.skipFully(r1)
+        L38:
+            r3 = r2
+        L39:
+            r4 = r3
+            r5 = r4
+            goto L3f
+        L3c:
+            r1 = r2
+            r3 = r1
+            goto L39
+        L3f:
+            com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray r6 = r12.scratch
+            byte[] r6 = r6.data
+            r7 = 1
+            if (r3 <= 0) goto L48
+            r8 = r7
+            goto L49
+        L48:
+            r8 = r2
+        L49:
+            r9 = 4
+            boolean r6 = r13.peekFully(r6, r2, r9, r8)
+            if (r6 != 0) goto L51
+            goto L9a
+        L51:
+            com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray r6 = r12.scratch
+            r6.setPosition(r2)
+            com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray r6 = r12.scratch
+            int r6 = r6.readInt()
+            if (r4 == 0) goto L65
+            long r10 = (long) r4
+            boolean r8 = headersMatch(r6, r10)
+            if (r8 == 0) goto L6c
+        L65:
+            int r8 = com.mbridge.msdk.playercommon.exoplayer2.extractor.MpegAudioHeader.getFrameSize(r6)
+            r10 = -1
+            if (r8 != r10) goto L8d
+        L6c:
+            int r3 = r5 + 1
+            if (r5 != r0) goto L7b
+            if (r14 == 0) goto L73
+            return r2
+        L73:
+            com.mbridge.msdk.playercommon.exoplayer2.ParserException r13 = new com.mbridge.msdk.playercommon.exoplayer2.ParserException
+            java.lang.String r14 = "Searched too many bytes."
+            r13.<init>(r14)
+            throw r13
+        L7b:
+            if (r14 == 0) goto L86
+            r13.resetPeekPosition()
+            int r4 = r1 + r3
+            r13.advancePeekPosition(r4)
+            goto L89
+        L86:
+            r13.skipFully(r7)
+        L89:
+            r4 = r2
+            r5 = r3
+            r3 = r4
+            goto L3f
+        L8d:
+            int r3 = r3 + 1
+            if (r3 != r7) goto L98
+            com.mbridge.msdk.playercommon.exoplayer2.extractor.MpegAudioHeader r4 = r12.synchronizedHeader
+            com.mbridge.msdk.playercommon.exoplayer2.extractor.MpegAudioHeader.populateHeader(r6, r4)
+            r4 = r6
+            goto La7
+        L98:
+            if (r3 != r9) goto La7
+        L9a:
+            if (r14 == 0) goto La1
+            int r1 = r1 + r5
+            r13.skipFully(r1)
+            goto La4
+        La1:
+            r13.resetPeekPosition()
+        La4:
+            r12.synchronizedHeaderData = r4
+            return r7
+        La7:
+            int r8 = r8 + (-4)
+            r13.advancePeekPosition(r8)
+            goto L3f
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor.synchronize(com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput, boolean):boolean");
+    }
+
+    private Seeker maybeReadSeekFrame(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        ParsableByteArray parsableByteArray = new ParsableByteArray(this.synchronizedHeader.frameSize);
+        extractorInput.peekFully(parsableByteArray.data, 0, this.synchronizedHeader.frameSize);
+        MpegAudioHeader mpegAudioHeader = this.synchronizedHeader;
+        int i = 21;
+        if ((mpegAudioHeader.version & 1) != 0) {
+            if (mpegAudioHeader.channels != 1) {
+                i = 36;
+            }
+        } else if (mpegAudioHeader.channels == 1) {
+            i = 13;
+        }
+        int i2 = i;
+        int seekFrameHeader = getSeekFrameHeader(parsableByteArray, i2);
+        if (seekFrameHeader != SEEK_HEADER_XING && seekFrameHeader != SEEK_HEADER_INFO) {
+            if (seekFrameHeader == SEEK_HEADER_VBRI) {
+                VbriSeeker create = VbriSeeker.create(extractorInput.getLength(), extractorInput.getPosition(), this.synchronizedHeader, parsableByteArray);
+                extractorInput.skipFully(this.synchronizedHeader.frameSize);
+                return create;
+            }
+            extractorInput.resetPeekPosition();
+            return null;
+        }
+        XingSeeker create2 = XingSeeker.create(extractorInput.getLength(), extractorInput.getPosition(), this.synchronizedHeader, parsableByteArray);
+        if (create2 != null && !this.gaplessInfoHolder.hasGaplessInfo()) {
+            extractorInput.resetPeekPosition();
+            extractorInput.advancePeekPosition(i2 + 141);
+            extractorInput.peekFully(this.scratch.data, 0, 3);
+            this.scratch.setPosition(0);
+            this.gaplessInfoHolder.setFromXingHeaderValue(this.scratch.readUnsignedInt24());
+        }
+        extractorInput.skipFully(this.synchronizedHeader.frameSize);
+        return (create2 == null || create2.isSeekable() || seekFrameHeader != SEEK_HEADER_INFO) ? create2 : getConstantBitrateSeeker(extractorInput);
+    }
+
+    private Seeker getConstantBitrateSeeker(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        extractorInput.peekFully(this.scratch.data, 0, 4);
+        this.scratch.setPosition(0);
+        MpegAudioHeader.populateHeader(this.scratch.readInt(), this.synchronizedHeader);
+        return new ConstantBitrateSeeker(extractorInput.getLength(), extractorInput.getPosition(), this.synchronizedHeader);
+    }
+
+    private static int getSeekFrameHeader(ParsableByteArray parsableByteArray, int i) {
+        if (parsableByteArray.limit() >= i + 4) {
+            parsableByteArray.setPosition(i);
+            int readInt = parsableByteArray.readInt();
+            if (readInt == SEEK_HEADER_XING || readInt == SEEK_HEADER_INFO) {
+                return readInt;
+            }
+        }
+        if (parsableByteArray.limit() < 40) {
+            return 0;
+        }
+        parsableByteArray.setPosition(36);
+        int readInt2 = parsableByteArray.readInt();
+        int i2 = SEEK_HEADER_VBRI;
+        if (readInt2 == i2) {
+            return i2;
+        }
+        return 0;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp3/VbriSeeker.java

@@ -0,0 +1,96 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.MpegAudioHeader;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekPoint;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+final class VbriSeeker implements Mp3Extractor.Seeker {
+    private static final String TAG = "VbriSeeker";
+    private final long durationUs;
+    private final long[] positions;
+    private final long[] timesUs;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final long getDurationUs() {
+        return this.durationUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final boolean isSeekable() {
+        return true;
+    }
+
+    public static VbriSeeker create(long j, long j2, MpegAudioHeader mpegAudioHeader, ParsableByteArray parsableByteArray) {
+        int readUnsignedByte;
+        parsableByteArray.skipBytes(10);
+        int readInt = parsableByteArray.readInt();
+        if (readInt <= 0) {
+            return null;
+        }
+        int i = mpegAudioHeader.sampleRate;
+        long scaleLargeTimestamp = Util.scaleLargeTimestamp(readInt, (i >= 32000 ? 1152 : 576) * 1000000, i);
+        int readUnsignedShort = parsableByteArray.readUnsignedShort();
+        int readUnsignedShort2 = parsableByteArray.readUnsignedShort();
+        int readUnsignedShort3 = parsableByteArray.readUnsignedShort();
+        parsableByteArray.skipBytes(2);
+        long j3 = j2 + mpegAudioHeader.frameSize;
+        long[] jArr = new long[readUnsignedShort];
+        long[] jArr2 = new long[readUnsignedShort];
+        int i2 = 0;
+        long j4 = j2;
+        while (i2 < readUnsignedShort) {
+            long j5 = j3;
+            long j6 = scaleLargeTimestamp;
+            jArr[i2] = (i2 * scaleLargeTimestamp) / readUnsignedShort;
+            jArr2[i2] = Math.max(j4, j5);
+            if (readUnsignedShort3 == 1) {
+                readUnsignedByte = parsableByteArray.readUnsignedByte();
+            } else if (readUnsignedShort3 == 2) {
+                readUnsignedByte = parsableByteArray.readUnsignedShort();
+            } else if (readUnsignedShort3 == 3) {
+                readUnsignedByte = parsableByteArray.readUnsignedInt24();
+            } else {
+                if (readUnsignedShort3 != 4) {
+                    return null;
+                }
+                readUnsignedByte = parsableByteArray.readUnsignedIntToInt();
+            }
+            j4 += readUnsignedByte * readUnsignedShort2;
+            i2++;
+            j3 = j5;
+            scaleLargeTimestamp = j6;
+        }
+        long j7 = scaleLargeTimestamp;
+        if (j != -1 && j != j4) {
+            Log.w(TAG, "VBRI data size mismatch: " + j + ", " + j4);
+        }
+        return new VbriSeeker(jArr, jArr2, j7);
+    }
+
+    private VbriSeeker(long[] jArr, long[] jArr2, long j) {
+        this.timesUs = jArr;
+        this.positions = jArr2;
+        this.durationUs = j;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final SeekMap.SeekPoints getSeekPoints(long j) {
+        int binarySearchFloor = Util.binarySearchFloor(this.timesUs, j, true, true);
+        SeekPoint seekPoint = new SeekPoint(this.timesUs[binarySearchFloor], this.positions[binarySearchFloor]);
+        if (seekPoint.timeUs >= j || binarySearchFloor == this.timesUs.length - 1) {
+            return new SeekMap.SeekPoints(seekPoint);
+        }
+        int i = binarySearchFloor + 1;
+        return new SeekMap.SeekPoints(seekPoint, new SeekPoint(this.timesUs[i], this.positions[i]));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor.Seeker
+    public final long getTimeUs(long j) {
+        return this.timesUs[Util.binarySearchFloor(this.positions, j, true, true)];
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp3/XingSeeker.java

@@ -0,0 +1,106 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.MpegAudioHeader;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekPoint;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+final class XingSeeker implements Mp3Extractor.Seeker {
+    private static final String TAG = "XingSeeker";
+    private final long dataSize;
+    private final long dataStartPosition;
+    private final long durationUs;
+    private final long[] tableOfContents;
+    private final int xingFrameSize;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final long getDurationUs() {
+        return this.durationUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final boolean isSeekable() {
+        return this.tableOfContents != null;
+    }
+
+    public static XingSeeker create(long j, long j2, MpegAudioHeader mpegAudioHeader, ParsableByteArray parsableByteArray) {
+        int readUnsignedIntToInt;
+        int i = mpegAudioHeader.samplesPerFrame;
+        int i2 = mpegAudioHeader.sampleRate;
+        int readInt = parsableByteArray.readInt();
+        if ((readInt & 1) != 1 || (readUnsignedIntToInt = parsableByteArray.readUnsignedIntToInt()) == 0) {
+            return null;
+        }
+        long scaleLargeTimestamp = Util.scaleLargeTimestamp(readUnsignedIntToInt, i * 1000000, i2);
+        if ((readInt & 6) != 6) {
+            return new XingSeeker(j2, mpegAudioHeader.frameSize, scaleLargeTimestamp);
+        }
+        long readUnsignedIntToInt2 = parsableByteArray.readUnsignedIntToInt();
+        long[] jArr = new long[100];
+        for (int i3 = 0; i3 < 100; i3++) {
+            jArr[i3] = parsableByteArray.readUnsignedByte();
+        }
+        if (j != -1) {
+            long j3 = j2 + readUnsignedIntToInt2;
+            if (j != j3) {
+                Log.w(TAG, "XING data size mismatch: " + j + ", " + j3);
+            }
+        }
+        return new XingSeeker(j2, mpegAudioHeader.frameSize, scaleLargeTimestamp, readUnsignedIntToInt2, jArr);
+    }
+
+    private XingSeeker(long j, int i, long j2) {
+        this(j, i, j2, -1L, null);
+    }
+
+    private XingSeeker(long j, int i, long j2, long j3, long[] jArr) {
+        this.dataStartPosition = j;
+        this.xingFrameSize = i;
+        this.durationUs = j2;
+        this.dataSize = j3;
+        this.tableOfContents = jArr;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final SeekMap.SeekPoints getSeekPoints(long j) {
+        if (!isSeekable()) {
+            return new SeekMap.SeekPoints(new SeekPoint(0L, this.dataStartPosition + this.xingFrameSize));
+        }
+        long constrainValue = Util.constrainValue(j, 0L, this.durationUs);
+        double d = (constrainValue * 100.0d) / this.durationUs;
+        double d2 = 0.0d;
+        if (d > 0.0d) {
+            if (d >= 100.0d) {
+                d2 = 256.0d;
+            } else {
+                int i = (int) d;
+                double d3 = this.tableOfContents[i];
+                d2 = d3 + ((d - i) * ((i == 99 ? 256.0d : r3[i + 1]) - d3));
+            }
+        }
+        return new SeekMap.SeekPoints(new SeekPoint(constrainValue, this.dataStartPosition + Util.constrainValue(Math.round((d2 / 256.0d) * this.dataSize), this.xingFrameSize, this.dataSize - 1)));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor.Seeker
+    public final long getTimeUs(long j) {
+        long j2 = j - this.dataStartPosition;
+        if (!isSeekable() || j2 <= this.xingFrameSize) {
+            return 0L;
+        }
+        double d = (j2 * 256.0d) / this.dataSize;
+        int binarySearchFloor = Util.binarySearchFloor(this.tableOfContents, (long) d, true, true);
+        long timeUsForTableIndex = getTimeUsForTableIndex(binarySearchFloor);
+        long j3 = this.tableOfContents[binarySearchFloor];
+        int i = binarySearchFloor + 1;
+        long timeUsForTableIndex2 = getTimeUsForTableIndex(i);
+        return timeUsForTableIndex + Math.round((j3 == (binarySearchFloor == 99 ? 256L : this.tableOfContents[i]) ? 0.0d : (d - j3) / (r8 - j3)) * (timeUsForTableIndex2 - timeUsForTableIndex));
+    }
+
+    private long getTimeUsForTableIndex(int i) {
+        return (this.durationUs * i) / 100;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/Atom.java

@@ -0,0 +1,205 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import androidx.core.view.ViewCompat;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+abstract class Atom {
+    public static final int DEFINES_LARGE_SIZE = 1;
+    public static final int EXTENDS_TO_END_SIZE = 0;
+    public static final int FULL_HEADER_SIZE = 12;
+    public static final int HEADER_SIZE = 8;
+    public static final int LONG_HEADER_SIZE = 16;
+    public final int type;
+    public static final int TYPE_ftyp = Util.getIntegerCodeForString("ftyp");
+    public static final int TYPE_avc1 = Util.getIntegerCodeForString("avc1");
+    public static final int TYPE_avc3 = Util.getIntegerCodeForString("avc3");
+    public static final int TYPE_hvc1 = Util.getIntegerCodeForString("hvc1");
+    public static final int TYPE_hev1 = Util.getIntegerCodeForString("hev1");
+    public static final int TYPE_s263 = Util.getIntegerCodeForString("s263");
+    public static final int TYPE_d263 = Util.getIntegerCodeForString("d263");
+    public static final int TYPE_mdat = Util.getIntegerCodeForString("mdat");
+    public static final int TYPE_mp4a = Util.getIntegerCodeForString("mp4a");
+    public static final int TYPE__mp3 = Util.getIntegerCodeForString(".mp3");
+    public static final int TYPE_wave = Util.getIntegerCodeForString("wave");
+    public static final int TYPE_lpcm = Util.getIntegerCodeForString("lpcm");
+    public static final int TYPE_sowt = Util.getIntegerCodeForString("sowt");
+    public static final int TYPE_ac_3 = Util.getIntegerCodeForString("ac-3");
+    public static final int TYPE_dac3 = Util.getIntegerCodeForString("dac3");
+    public static final int TYPE_ec_3 = Util.getIntegerCodeForString("ec-3");
+    public static final int TYPE_dec3 = Util.getIntegerCodeForString("dec3");
+    public static final int TYPE_dtsc = Util.getIntegerCodeForString("dtsc");
+    public static final int TYPE_dtsh = Util.getIntegerCodeForString("dtsh");
+    public static final int TYPE_dtsl = Util.getIntegerCodeForString("dtsl");
+    public static final int TYPE_dtse = Util.getIntegerCodeForString("dtse");
+    public static final int TYPE_ddts = Util.getIntegerCodeForString("ddts");
+    public static final int TYPE_tfdt = Util.getIntegerCodeForString("tfdt");
+    public static final int TYPE_tfhd = Util.getIntegerCodeForString("tfhd");
+    public static final int TYPE_trex = Util.getIntegerCodeForString("trex");
+    public static final int TYPE_trun = Util.getIntegerCodeForString("trun");
+    public static final int TYPE_sidx = Util.getIntegerCodeForString("sidx");
+    public static final int TYPE_moov = Util.getIntegerCodeForString("moov");
+    public static final int TYPE_mvhd = Util.getIntegerCodeForString("mvhd");
+    public static final int TYPE_trak = Util.getIntegerCodeForString("trak");
+    public static final int TYPE_mdia = Util.getIntegerCodeForString("mdia");
+    public static final int TYPE_minf = Util.getIntegerCodeForString("minf");
+    public static final int TYPE_stbl = Util.getIntegerCodeForString("stbl");
+    public static final int TYPE_avcC = Util.getIntegerCodeForString("avcC");
+    public static final int TYPE_hvcC = Util.getIntegerCodeForString("hvcC");
+    public static final int TYPE_esds = Util.getIntegerCodeForString("esds");
+    public static final int TYPE_moof = Util.getIntegerCodeForString("moof");
+    public static final int TYPE_traf = Util.getIntegerCodeForString("traf");
+    public static final int TYPE_mvex = Util.getIntegerCodeForString("mvex");
+    public static final int TYPE_mehd = Util.getIntegerCodeForString("mehd");
+    public static final int TYPE_tkhd = Util.getIntegerCodeForString("tkhd");
+    public static final int TYPE_edts = Util.getIntegerCodeForString("edts");
+    public static final int TYPE_elst = Util.getIntegerCodeForString("elst");
+    public static final int TYPE_mdhd = Util.getIntegerCodeForString("mdhd");
+    public static final int TYPE_hdlr = Util.getIntegerCodeForString("hdlr");
+    public static final int TYPE_stsd = Util.getIntegerCodeForString("stsd");
+    public static final int TYPE_pssh = Util.getIntegerCodeForString("pssh");
+    public static final int TYPE_sinf = Util.getIntegerCodeForString("sinf");
+    public static final int TYPE_schm = Util.getIntegerCodeForString("schm");
+    public static final int TYPE_schi = Util.getIntegerCodeForString("schi");
+    public static final int TYPE_tenc = Util.getIntegerCodeForString("tenc");
+    public static final int TYPE_encv = Util.getIntegerCodeForString("encv");
+    public static final int TYPE_enca = Util.getIntegerCodeForString("enca");
+    public static final int TYPE_frma = Util.getIntegerCodeForString("frma");
+    public static final int TYPE_saiz = Util.getIntegerCodeForString("saiz");
+    public static final int TYPE_saio = Util.getIntegerCodeForString("saio");
+    public static final int TYPE_sbgp = Util.getIntegerCodeForString("sbgp");
+    public static final int TYPE_sgpd = Util.getIntegerCodeForString("sgpd");
+    public static final int TYPE_uuid = Util.getIntegerCodeForString("uuid");
+    public static final int TYPE_senc = Util.getIntegerCodeForString("senc");
+    public static final int TYPE_pasp = Util.getIntegerCodeForString("pasp");
+    public static final int TYPE_TTML = Util.getIntegerCodeForString("TTML");
+    public static final int TYPE_vmhd = Util.getIntegerCodeForString("vmhd");
+    public static final int TYPE_mp4v = Util.getIntegerCodeForString("mp4v");
+    public static final int TYPE_stts = Util.getIntegerCodeForString("stts");
+    public static final int TYPE_stss = Util.getIntegerCodeForString("stss");
+    public static final int TYPE_ctts = Util.getIntegerCodeForString("ctts");
+    public static final int TYPE_stsc = Util.getIntegerCodeForString("stsc");
+    public static final int TYPE_stsz = Util.getIntegerCodeForString("stsz");
+    public static final int TYPE_stz2 = Util.getIntegerCodeForString("stz2");
+    public static final int TYPE_stco = Util.getIntegerCodeForString("stco");
+    public static final int TYPE_co64 = Util.getIntegerCodeForString("co64");
+    public static final int TYPE_tx3g = Util.getIntegerCodeForString("tx3g");
+    public static final int TYPE_wvtt = Util.getIntegerCodeForString("wvtt");
+    public static final int TYPE_stpp = Util.getIntegerCodeForString("stpp");
+    public static final int TYPE_c608 = Util.getIntegerCodeForString("c608");
+    public static final int TYPE_samr = Util.getIntegerCodeForString("samr");
+    public static final int TYPE_sawb = Util.getIntegerCodeForString("sawb");
+    public static final int TYPE_udta = Util.getIntegerCodeForString("udta");
+    public static final int TYPE_meta = Util.getIntegerCodeForString("meta");
+    public static final int TYPE_ilst = Util.getIntegerCodeForString("ilst");
+    public static final int TYPE_mean = Util.getIntegerCodeForString("mean");
+    public static final int TYPE_name = Util.getIntegerCodeForString("name");
+    public static final int TYPE_data = Util.getIntegerCodeForString("data");
+    public static final int TYPE_emsg = Util.getIntegerCodeForString("emsg");
+    public static final int TYPE_st3d = Util.getIntegerCodeForString("st3d");
+    public static final int TYPE_sv3d = Util.getIntegerCodeForString("sv3d");
+    public static final int TYPE_proj = Util.getIntegerCodeForString("proj");
+    public static final int TYPE_vp08 = Util.getIntegerCodeForString("vp08");
+    public static final int TYPE_vp09 = Util.getIntegerCodeForString("vp09");
+    public static final int TYPE_vpcC = Util.getIntegerCodeForString("vpcC");
+    public static final int TYPE_camm = Util.getIntegerCodeForString("camm");
+    public static final int TYPE_alac = Util.getIntegerCodeForString("alac");
+
+    public static int parseFullAtomFlags(int i) {
+        return i & ViewCompat.MEASURED_SIZE_MASK;
+    }
+
+    public static int parseFullAtomVersion(int i) {
+        return (i >> 24) & 255;
+    }
+
+    public Atom(int i) {
+        this.type = i;
+    }
+
+    public String toString() {
+        return getAtomTypeString(this.type);
+    }
+
+    public static final class LeafAtom extends Atom {
+        public final ParsableByteArray data;
+
+        public LeafAtom(int i, ParsableByteArray parsableByteArray) {
+            super(i);
+            this.data = parsableByteArray;
+        }
+    }
+
+    public static final class ContainerAtom extends Atom {
+        public final List<ContainerAtom> containerChildren;
+        public final long endPosition;
+        public final List<LeafAtom> leafChildren;
+
+        public ContainerAtom(int i, long j) {
+            super(i);
+            this.endPosition = j;
+            this.leafChildren = new ArrayList();
+            this.containerChildren = new ArrayList();
+        }
+
+        public final void add(LeafAtom leafAtom) {
+            this.leafChildren.add(leafAtom);
+        }
+
+        public final void add(ContainerAtom containerAtom) {
+            this.containerChildren.add(containerAtom);
+        }
+
+        public final LeafAtom getLeafAtomOfType(int i) {
+            int size = this.leafChildren.size();
+            for (int i2 = 0; i2 < size; i2++) {
+                LeafAtom leafAtom = this.leafChildren.get(i2);
+                if (leafAtom.type == i) {
+                    return leafAtom;
+                }
+            }
+            return null;
+        }
+
+        public final ContainerAtom getContainerAtomOfType(int i) {
+            int size = this.containerChildren.size();
+            for (int i2 = 0; i2 < size; i2++) {
+                ContainerAtom containerAtom = this.containerChildren.get(i2);
+                if (containerAtom.type == i) {
+                    return containerAtom;
+                }
+            }
+            return null;
+        }
+
+        public final int getChildAtomOfTypeCount(int i) {
+            int size = this.leafChildren.size();
+            int i2 = 0;
+            for (int i3 = 0; i3 < size; i3++) {
+                if (this.leafChildren.get(i3).type == i) {
+                    i2++;
+                }
+            }
+            int size2 = this.containerChildren.size();
+            for (int i4 = 0; i4 < size2; i4++) {
+                if (this.containerChildren.get(i4).type == i) {
+                    i2++;
+                }
+            }
+            return i2;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Atom
+        public final String toString() {
+            return Atom.getAtomTypeString(this.type) + " leaves: " + Arrays.toString(this.leafChildren.toArray()) + " containers: " + Arrays.toString(this.containerChildren.toArray());
+        }
+    }
+
+    public static String getAtomTypeString(int i) {
+        return "" + ((char) ((i >> 24) & 255)) + ((char) ((i >> 16) & 255)) + ((char) ((i >> 8) & 255)) + ((char) (i & 255));
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/AtomParsers.java

@@ -0,0 +1,922 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.Ac3Util;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Atom;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.CodecSpecificDataUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import com.mbridge.msdk.playercommon.exoplayer2.video.AvcConfig;
+import com.mbridge.msdk.playercommon.exoplayer2.video.HevcConfig;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+final class AtomParsers {
+    private static final int MAX_GAPLESS_TRIM_SIZE_SAMPLES = 3;
+    private static final String TAG = "AtomParsers";
+    private static final int TYPE_vide = Util.getIntegerCodeForString("vide");
+    private static final int TYPE_soun = Util.getIntegerCodeForString("soun");
+    private static final int TYPE_text = Util.getIntegerCodeForString("text");
+    private static final int TYPE_sbtl = Util.getIntegerCodeForString("sbtl");
+    private static final int TYPE_subt = Util.getIntegerCodeForString("subt");
+    private static final int TYPE_clcp = Util.getIntegerCodeForString("clcp");
+    private static final int TYPE_meta = Util.getIntegerCodeForString("meta");
+
+    public interface SampleSizeBox {
+        int getSampleCount();
+
+        boolean isFixedSampleSize();
+
+        int readNextSampleSize();
+    }
+
+    public static final class UnhandledEditListException extends ParserException {
+    }
+
+    public static Track parseTrak(Atom.ContainerAtom containerAtom, Atom.LeafAtom leafAtom, long j, DrmInitData drmInitData, boolean z, boolean z2) throws ParserException {
+        Atom.LeafAtom leafAtom2;
+        long j2;
+        long[] jArr;
+        long[] jArr2;
+        Atom.ContainerAtom containerAtomOfType = containerAtom.getContainerAtomOfType(Atom.TYPE_mdia);
+        int parseHdlr = parseHdlr(containerAtomOfType.getLeafAtomOfType(Atom.TYPE_hdlr).data);
+        if (parseHdlr == -1) {
+            return null;
+        }
+        TkhdData parseTkhd = parseTkhd(containerAtom.getLeafAtomOfType(Atom.TYPE_tkhd).data);
+        long j3 = C.TIME_UNSET;
+        if (j == C.TIME_UNSET) {
+            leafAtom2 = leafAtom;
+            j2 = parseTkhd.duration;
+        } else {
+            leafAtom2 = leafAtom;
+            j2 = j;
+        }
+        long parseMvhd = parseMvhd(leafAtom2.data);
+        if (j2 != C.TIME_UNSET) {
+            j3 = Util.scaleLargeTimestamp(j2, 1000000L, parseMvhd);
+        }
+        long j4 = j3;
+        Atom.ContainerAtom containerAtomOfType2 = containerAtomOfType.getContainerAtomOfType(Atom.TYPE_minf).getContainerAtomOfType(Atom.TYPE_stbl);
+        Pair<Long, String> parseMdhd = parseMdhd(containerAtomOfType.getLeafAtomOfType(Atom.TYPE_mdhd).data);
+        StsdData parseStsd = parseStsd(containerAtomOfType2.getLeafAtomOfType(Atom.TYPE_stsd).data, parseTkhd.id, parseTkhd.rotationDegrees, (String) parseMdhd.second, drmInitData, z2);
+        if (z) {
+            jArr = null;
+            jArr2 = null;
+        } else {
+            Pair<long[], long[]> parseEdts = parseEdts(containerAtom.getContainerAtomOfType(Atom.TYPE_edts));
+            long[] jArr3 = (long[]) parseEdts.first;
+            jArr2 = (long[]) parseEdts.second;
+            jArr = jArr3;
+        }
+        if (parseStsd.format == null) {
+            return null;
+        }
+        return new Track(parseTkhd.id, parseHdlr, ((Long) parseMdhd.first).longValue(), parseMvhd, j4, parseStsd.format, parseStsd.requiredSampleTransformation, parseStsd.trackEncryptionBoxes, parseStsd.nalUnitLengthFieldLength, jArr, jArr2);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:121:0x0343  */
+    /* JADX WARN: Removed duplicated region for block: B:125:0x0351  */
+    /* JADX WARN: Removed duplicated region for block: B:135:0x0385 A[EDGE_INSN: B:135:0x0385->B:136:0x0385 BREAK  A[LOOP:5: B:123:0x034a->B:132:0x037f], SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:138:0x038a  */
+    /* JADX WARN: Removed duplicated region for block: B:141:0x0390  */
+    /* JADX WARN: Removed duplicated region for block: B:143:0x0396  */
+    /* JADX WARN: Removed duplicated region for block: B:145:0x039d  */
+    /* JADX WARN: Removed duplicated region for block: B:147:0x03a1  */
+    /* JADX WARN: Removed duplicated region for block: B:151:0x03af  */
+    /* JADX WARN: Removed duplicated region for block: B:182:0x0470 A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:185:0x03a5  */
+    /* JADX WARN: Removed duplicated region for block: B:186:0x0399  */
+    /* JADX WARN: Removed duplicated region for block: B:187:0x0393  */
+    /* JADX WARN: Removed duplicated region for block: B:188:0x038c  */
+    /* JADX WARN: Removed duplicated region for block: B:189:0x0345  */
+    /* JADX WARN: Removed duplicated region for block: B:204:0x0212  */
+    /* JADX WARN: Removed duplicated region for block: B:37:0x00d9  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.TrackSampleTable parseStbl(com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Track r40, com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Atom.ContainerAtom r41, com.mbridge.msdk.playercommon.exoplayer2.extractor.GaplessInfoHolder r42) throws com.mbridge.msdk.playercommon.exoplayer2.ParserException {
+        /*
+            Method dump skipped, instructions count: 1201
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.AtomParsers.parseStbl(com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Track, com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Atom$ContainerAtom, com.mbridge.msdk.playercommon.exoplayer2.extractor.GaplessInfoHolder):com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.TrackSampleTable");
+    }
+
+    public static Metadata parseUdta(Atom.LeafAtom leafAtom, boolean z) {
+        if (z) {
+            return null;
+        }
+        ParsableByteArray parsableByteArray = leafAtom.data;
+        parsableByteArray.setPosition(8);
+        while (parsableByteArray.bytesLeft() >= 8) {
+            int position = parsableByteArray.getPosition();
+            int readInt = parsableByteArray.readInt();
+            if (parsableByteArray.readInt() == Atom.TYPE_meta) {
+                parsableByteArray.setPosition(position);
+                return parseMetaAtom(parsableByteArray, position + readInt);
+            }
+            parsableByteArray.skipBytes(readInt - 8);
+        }
+        return null;
+    }
+
+    private static Metadata parseMetaAtom(ParsableByteArray parsableByteArray, int i) {
+        parsableByteArray.skipBytes(12);
+        while (parsableByteArray.getPosition() < i) {
+            int position = parsableByteArray.getPosition();
+            int readInt = parsableByteArray.readInt();
+            if (parsableByteArray.readInt() == Atom.TYPE_ilst) {
+                parsableByteArray.setPosition(position);
+                return parseIlst(parsableByteArray, position + readInt);
+            }
+            parsableByteArray.skipBytes(readInt - 8);
+        }
+        return null;
+    }
+
+    private static Metadata parseIlst(ParsableByteArray parsableByteArray, int i) {
+        parsableByteArray.skipBytes(8);
+        ArrayList arrayList = new ArrayList();
+        while (parsableByteArray.getPosition() < i) {
+            Metadata.Entry parseIlstElement = MetadataUtil.parseIlstElement(parsableByteArray);
+            if (parseIlstElement != null) {
+                arrayList.add(parseIlstElement);
+            }
+        }
+        if (arrayList.isEmpty()) {
+            return null;
+        }
+        return new Metadata(arrayList);
+    }
+
+    private static long parseMvhd(ParsableByteArray parsableByteArray) {
+        parsableByteArray.setPosition(8);
+        parsableByteArray.skipBytes(Atom.parseFullAtomVersion(parsableByteArray.readInt()) != 0 ? 16 : 8);
+        return parsableByteArray.readUnsignedInt();
+    }
+
+    private static TkhdData parseTkhd(ParsableByteArray parsableByteArray) {
+        long j;
+        parsableByteArray.setPosition(8);
+        int parseFullAtomVersion = Atom.parseFullAtomVersion(parsableByteArray.readInt());
+        parsableByteArray.skipBytes(parseFullAtomVersion == 0 ? 8 : 16);
+        int readInt = parsableByteArray.readInt();
+        parsableByteArray.skipBytes(4);
+        int position = parsableByteArray.getPosition();
+        int i = parseFullAtomVersion == 0 ? 4 : 8;
+        int i2 = 0;
+        int i3 = 0;
+        while (true) {
+            j = C.TIME_UNSET;
+            if (i3 < i) {
+                if (parsableByteArray.data[position + i3] != -1) {
+                    long readUnsignedInt = parseFullAtomVersion == 0 ? parsableByteArray.readUnsignedInt() : parsableByteArray.readUnsignedLongToLong();
+                    if (readUnsignedInt != 0) {
+                        j = readUnsignedInt;
+                    }
+                } else {
+                    i3++;
+                }
+            } else {
+                parsableByteArray.skipBytes(i);
+                break;
+            }
+        }
+        parsableByteArray.skipBytes(16);
+        int readInt2 = parsableByteArray.readInt();
+        int readInt3 = parsableByteArray.readInt();
+        parsableByteArray.skipBytes(4);
+        int readInt4 = parsableByteArray.readInt();
+        int readInt5 = parsableByteArray.readInt();
+        if (readInt2 == 0 && readInt3 == 65536 && readInt4 == -65536 && readInt5 == 0) {
+            i2 = 90;
+        } else if (readInt2 == 0 && readInt3 == -65536 && readInt4 == 65536 && readInt5 == 0) {
+            i2 = 270;
+        } else if (readInt2 == -65536 && readInt3 == 0 && readInt4 == 0 && readInt5 == -65536) {
+            i2 = 180;
+        }
+        return new TkhdData(readInt, j, i2);
+    }
+
+    private static int parseHdlr(ParsableByteArray parsableByteArray) {
+        parsableByteArray.setPosition(16);
+        int readInt = parsableByteArray.readInt();
+        if (readInt == TYPE_soun) {
+            return 1;
+        }
+        if (readInt == TYPE_vide) {
+            return 2;
+        }
+        if (readInt == TYPE_text || readInt == TYPE_sbtl || readInt == TYPE_subt || readInt == TYPE_clcp) {
+            return 3;
+        }
+        return readInt == TYPE_meta ? 4 : -1;
+    }
+
+    private static Pair<Long, String> parseMdhd(ParsableByteArray parsableByteArray) {
+        parsableByteArray.setPosition(8);
+        int parseFullAtomVersion = Atom.parseFullAtomVersion(parsableByteArray.readInt());
+        parsableByteArray.skipBytes(parseFullAtomVersion == 0 ? 8 : 16);
+        long readUnsignedInt = parsableByteArray.readUnsignedInt();
+        parsableByteArray.skipBytes(parseFullAtomVersion == 0 ? 4 : 8);
+        int readUnsignedShort = parsableByteArray.readUnsignedShort();
+        return Pair.create(Long.valueOf(readUnsignedInt), "" + ((char) (((readUnsignedShort >> 10) & 31) + 96)) + ((char) (((readUnsignedShort >> 5) & 31) + 96)) + ((char) ((readUnsignedShort & 31) + 96)));
+    }
+
+    private static StsdData parseStsd(ParsableByteArray parsableByteArray, int i, int i2, String str, DrmInitData drmInitData, boolean z) throws ParserException {
+        parsableByteArray.setPosition(12);
+        int readInt = parsableByteArray.readInt();
+        StsdData stsdData = new StsdData(readInt);
+        for (int i3 = 0; i3 < readInt; i3++) {
+            int position = parsableByteArray.getPosition();
+            int readInt2 = parsableByteArray.readInt();
+            Assertions.checkArgument(readInt2 > 0, "childAtomSize should be positive");
+            int readInt3 = parsableByteArray.readInt();
+            if (readInt3 == Atom.TYPE_avc1 || readInt3 == Atom.TYPE_avc3 || readInt3 == Atom.TYPE_encv || readInt3 == Atom.TYPE_mp4v || readInt3 == Atom.TYPE_hvc1 || readInt3 == Atom.TYPE_hev1 || readInt3 == Atom.TYPE_s263 || readInt3 == Atom.TYPE_vp08 || readInt3 == Atom.TYPE_vp09) {
+                parseVideoSampleEntry(parsableByteArray, readInt3, position, readInt2, i, i2, drmInitData, stsdData, i3);
+            } else if (readInt3 == Atom.TYPE_mp4a || readInt3 == Atom.TYPE_enca || readInt3 == Atom.TYPE_ac_3 || readInt3 == Atom.TYPE_ec_3 || readInt3 == Atom.TYPE_dtsc || readInt3 == Atom.TYPE_dtse || readInt3 == Atom.TYPE_dtsh || readInt3 == Atom.TYPE_dtsl || readInt3 == Atom.TYPE_samr || readInt3 == Atom.TYPE_sawb || readInt3 == Atom.TYPE_lpcm || readInt3 == Atom.TYPE_sowt || readInt3 == Atom.TYPE__mp3 || readInt3 == Atom.TYPE_alac) {
+                parseAudioSampleEntry(parsableByteArray, readInt3, position, readInt2, i, str, z, drmInitData, stsdData, i3);
+            } else if (readInt3 == Atom.TYPE_TTML || readInt3 == Atom.TYPE_tx3g || readInt3 == Atom.TYPE_wvtt || readInt3 == Atom.TYPE_stpp || readInt3 == Atom.TYPE_c608) {
+                parseTextSampleEntry(parsableByteArray, readInt3, position, readInt2, i, str, stsdData);
+            } else if (readInt3 == Atom.TYPE_camm) {
+                stsdData.format = Format.createSampleFormat(Integer.toString(i), MimeTypes.APPLICATION_CAMERA_MOTION, null, -1, null);
+            }
+            parsableByteArray.setPosition(position + readInt2);
+        }
+        return stsdData;
+    }
+
+    private static void parseTextSampleEntry(ParsableByteArray parsableByteArray, int i, int i2, int i3, int i4, String str, StsdData stsdData) throws ParserException {
+        parsableByteArray.setPosition(i2 + 16);
+        int i5 = Atom.TYPE_TTML;
+        String str2 = MimeTypes.APPLICATION_TTML;
+        List list = null;
+        long j = Long.MAX_VALUE;
+        if (i != i5) {
+            if (i == Atom.TYPE_tx3g) {
+                int i6 = i3 - 16;
+                byte[] bArr = new byte[i6];
+                parsableByteArray.readBytes(bArr, 0, i6);
+                list = Collections.singletonList(bArr);
+                str2 = MimeTypes.APPLICATION_TX3G;
+            } else if (i == Atom.TYPE_wvtt) {
+                str2 = MimeTypes.APPLICATION_MP4VTT;
+            } else if (i == Atom.TYPE_stpp) {
+                j = 0;
+            } else if (i == Atom.TYPE_c608) {
+                stsdData.requiredSampleTransformation = 1;
+                str2 = MimeTypes.APPLICATION_MP4CEA608;
+            } else {
+                throw new IllegalStateException();
+            }
+        }
+        stsdData.format = Format.createTextSampleFormat(Integer.toString(i4), str2, null, -1, 0, str, -1, null, j, list);
+    }
+
+    private static void parseVideoSampleEntry(ParsableByteArray parsableByteArray, int i, int i2, int i3, int i4, int i5, DrmInitData drmInitData, StsdData stsdData, int i6) throws ParserException {
+        DrmInitData drmInitData2 = drmInitData;
+        parsableByteArray.setPosition(i2 + 16);
+        parsableByteArray.skipBytes(16);
+        int readUnsignedShort = parsableByteArray.readUnsignedShort();
+        int readUnsignedShort2 = parsableByteArray.readUnsignedShort();
+        parsableByteArray.skipBytes(50);
+        int position = parsableByteArray.getPosition();
+        String str = null;
+        int i7 = i;
+        if (i7 == Atom.TYPE_encv) {
+            Pair<Integer, TrackEncryptionBox> parseSampleEntryEncryptionData = parseSampleEntryEncryptionData(parsableByteArray, i2, i3);
+            if (parseSampleEntryEncryptionData != null) {
+                i7 = ((Integer) parseSampleEntryEncryptionData.first).intValue();
+                drmInitData2 = drmInitData2 == null ? null : drmInitData2.copyWithSchemeType(((TrackEncryptionBox) parseSampleEntryEncryptionData.second).schemeType);
+                stsdData.trackEncryptionBoxes[i6] = (TrackEncryptionBox) parseSampleEntryEncryptionData.second;
+            }
+            parsableByteArray.setPosition(position);
+        }
+        DrmInitData drmInitData3 = drmInitData2;
+        float f = 1.0f;
+        List<byte[]> list = null;
+        byte[] bArr = null;
+        int i8 = -1;
+        boolean z = false;
+        while (position - i2 < i3) {
+            parsableByteArray.setPosition(position);
+            int position2 = parsableByteArray.getPosition();
+            int readInt = parsableByteArray.readInt();
+            if (readInt == 0 && parsableByteArray.getPosition() - i2 == i3) {
+                break;
+            }
+            int i9 = 1;
+            Assertions.checkArgument(readInt > 0, "childAtomSize should be positive");
+            int readInt2 = parsableByteArray.readInt();
+            if (readInt2 == Atom.TYPE_avcC) {
+                Assertions.checkState(str == null);
+                parsableByteArray.setPosition(position2 + 8);
+                AvcConfig parse = AvcConfig.parse(parsableByteArray);
+                list = parse.initializationData;
+                stsdData.nalUnitLengthFieldLength = parse.nalUnitLengthFieldLength;
+                if (!z) {
+                    f = parse.pixelWidthAspectRatio;
+                }
+                str = "video/avc";
+            } else if (readInt2 == Atom.TYPE_hvcC) {
+                Assertions.checkState(str == null);
+                parsableByteArray.setPosition(position2 + 8);
+                HevcConfig parse2 = HevcConfig.parse(parsableByteArray);
+                list = parse2.initializationData;
+                stsdData.nalUnitLengthFieldLength = parse2.nalUnitLengthFieldLength;
+                str = "video/hevc";
+            } else if (readInt2 == Atom.TYPE_vpcC) {
+                Assertions.checkState(str == null);
+                str = i7 == Atom.TYPE_vp08 ? MimeTypes.VIDEO_VP8 : MimeTypes.VIDEO_VP9;
+            } else if (readInt2 == Atom.TYPE_d263) {
+                Assertions.checkState(str == null);
+                str = MimeTypes.VIDEO_H263;
+            } else if (readInt2 == Atom.TYPE_esds) {
+                Assertions.checkState(str == null);
+                Pair<String, byte[]> parseEsdsFromParent = parseEsdsFromParent(parsableByteArray, position2);
+                str = (String) parseEsdsFromParent.first;
+                list = Collections.singletonList((byte[]) parseEsdsFromParent.second);
+            } else if (readInt2 == Atom.TYPE_pasp) {
+                f = parsePaspFromParent(parsableByteArray, position2);
+                z = true;
+            } else if (readInt2 == Atom.TYPE_sv3d) {
+                bArr = parseProjFromParent(parsableByteArray, position2, readInt);
+            } else if (readInt2 == Atom.TYPE_st3d) {
+                int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                parsableByteArray.skipBytes(3);
+                if (readUnsignedByte == 0) {
+                    int readUnsignedByte2 = parsableByteArray.readUnsignedByte();
+                    if (readUnsignedByte2 != 0) {
+                        if (readUnsignedByte2 != 1) {
+                            i9 = 2;
+                            if (readUnsignedByte2 != 2) {
+                                if (readUnsignedByte2 == 3) {
+                                    i8 = 3;
+                                }
+                            }
+                        }
+                        i8 = i9;
+                    } else {
+                        i8 = 0;
+                    }
+                }
+            }
+            position += readInt;
+        }
+        if (str == null) {
+            return;
+        }
+        stsdData.format = Format.createVideoSampleFormat(Integer.toString(i4), str, null, -1, -1, readUnsignedShort, readUnsignedShort2, -1.0f, list, i5, f, bArr, i8, null, drmInitData3);
+    }
+
+    private static Pair<long[], long[]> parseEdts(Atom.ContainerAtom containerAtom) {
+        Atom.LeafAtom leafAtomOfType;
+        if (containerAtom == null || (leafAtomOfType = containerAtom.getLeafAtomOfType(Atom.TYPE_elst)) == null) {
+            return Pair.create(null, null);
+        }
+        ParsableByteArray parsableByteArray = leafAtomOfType.data;
+        parsableByteArray.setPosition(8);
+        int parseFullAtomVersion = Atom.parseFullAtomVersion(parsableByteArray.readInt());
+        int readUnsignedIntToInt = parsableByteArray.readUnsignedIntToInt();
+        long[] jArr = new long[readUnsignedIntToInt];
+        long[] jArr2 = new long[readUnsignedIntToInt];
+        for (int i = 0; i < readUnsignedIntToInt; i++) {
+            jArr[i] = parseFullAtomVersion == 1 ? parsableByteArray.readUnsignedLongToLong() : parsableByteArray.readUnsignedInt();
+            jArr2[i] = parseFullAtomVersion == 1 ? parsableByteArray.readLong() : parsableByteArray.readInt();
+            if (parsableByteArray.readShort() != 1) {
+                throw new IllegalArgumentException("Unsupported media rate.");
+            }
+            parsableByteArray.skipBytes(2);
+        }
+        return Pair.create(jArr, jArr2);
+    }
+
+    private static float parsePaspFromParent(ParsableByteArray parsableByteArray, int i) {
+        parsableByteArray.setPosition(i + 8);
+        return parsableByteArray.readUnsignedIntToInt() / parsableByteArray.readUnsignedIntToInt();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private static void parseAudioSampleEntry(ParsableByteArray parsableByteArray, int i, int i2, int i3, int i4, String str, boolean z, DrmInitData drmInitData, StsdData stsdData, int i5) throws ParserException {
+        int i6;
+        int readUnsignedFixedPoint1616;
+        int i7;
+        String str2;
+        String str3;
+        String str4;
+        DrmInitData drmInitData2;
+        boolean z2;
+        int i8;
+        int i9;
+        int i10;
+        int i11 = i2;
+        DrmInitData drmInitData3 = drmInitData;
+        parsableByteArray.setPosition(i11 + 16);
+        int i12 = 0;
+        if (z) {
+            i6 = parsableByteArray.readUnsignedShort();
+            parsableByteArray.skipBytes(6);
+        } else {
+            parsableByteArray.skipBytes(8);
+            i6 = 0;
+        }
+        int i13 = 2;
+        boolean z3 = true;
+        if (i6 == 0 || i6 == 1) {
+            int readUnsignedShort = parsableByteArray.readUnsignedShort();
+            parsableByteArray.skipBytes(6);
+            readUnsignedFixedPoint1616 = parsableByteArray.readUnsignedFixedPoint1616();
+            if (i6 == 1) {
+                parsableByteArray.skipBytes(16);
+            }
+            i7 = readUnsignedShort;
+        } else {
+            if (i6 != 2) {
+                return;
+            }
+            parsableByteArray.skipBytes(16);
+            readUnsignedFixedPoint1616 = (int) Math.round(parsableByteArray.readDouble());
+            i7 = parsableByteArray.readUnsignedIntToInt();
+            parsableByteArray.skipBytes(20);
+        }
+        int position = parsableByteArray.getPosition();
+        int i14 = i;
+        if (i14 == Atom.TYPE_enca) {
+            Pair<Integer, TrackEncryptionBox> parseSampleEntryEncryptionData = parseSampleEntryEncryptionData(parsableByteArray, i11, i3);
+            if (parseSampleEntryEncryptionData != null) {
+                i14 = ((Integer) parseSampleEntryEncryptionData.first).intValue();
+                drmInitData3 = drmInitData3 == null ? null : drmInitData3.copyWithSchemeType(((TrackEncryptionBox) parseSampleEntryEncryptionData.second).schemeType);
+                stsdData.trackEncryptionBoxes[i5] = (TrackEncryptionBox) parseSampleEntryEncryptionData.second;
+            }
+            parsableByteArray.setPosition(position);
+        }
+        DrmInitData drmInitData4 = drmInitData3;
+        int i15 = Atom.TYPE_ac_3;
+        String str5 = MimeTypes.AUDIO_RAW;
+        if (i14 == i15) {
+            str2 = MimeTypes.AUDIO_AC3;
+        } else if (i14 == Atom.TYPE_ec_3) {
+            str2 = MimeTypes.AUDIO_E_AC3;
+        } else if (i14 == Atom.TYPE_dtsc) {
+            str2 = MimeTypes.AUDIO_DTS;
+        } else if (i14 == Atom.TYPE_dtsh || i14 == Atom.TYPE_dtsl) {
+            str2 = MimeTypes.AUDIO_DTS_HD;
+        } else if (i14 == Atom.TYPE_dtse) {
+            str2 = MimeTypes.AUDIO_DTS_EXPRESS;
+        } else if (i14 == Atom.TYPE_samr) {
+            str2 = MimeTypes.AUDIO_AMR_NB;
+        } else if (i14 == Atom.TYPE_sawb) {
+            str2 = MimeTypes.AUDIO_AMR_WB;
+        } else if (i14 == Atom.TYPE_lpcm || i14 == Atom.TYPE_sowt) {
+            str2 = MimeTypes.AUDIO_RAW;
+        } else if (i14 == Atom.TYPE__mp3) {
+            str2 = MimeTypes.AUDIO_MPEG;
+        } else {
+            str2 = i14 == Atom.TYPE_alac ? MimeTypes.AUDIO_ALAC : null;
+        }
+        String str6 = str2;
+        int i16 = readUnsignedFixedPoint1616;
+        int i17 = i7;
+        int i18 = position;
+        byte[] bArr = null;
+        while (i18 - i11 < i3) {
+            parsableByteArray.setPosition(i18);
+            int readInt = parsableByteArray.readInt();
+            Assertions.checkArgument(readInt > 0 ? z3 : i12, "childAtomSize should be positive");
+            int readInt2 = parsableByteArray.readInt();
+            int i19 = Atom.TYPE_esds;
+            if (readInt2 == i19) {
+                str3 = str6;
+                str4 = str5;
+                drmInitData2 = drmInitData4;
+                z2 = z3;
+                i8 = i13;
+                i9 = i12;
+            } else if (z && readInt2 == Atom.TYPE_wave) {
+                str3 = str6;
+                str4 = str5;
+                drmInitData2 = drmInitData4;
+                i8 = i13;
+                i9 = i12;
+                z2 = true;
+            } else {
+                if (readInt2 == Atom.TYPE_dac3) {
+                    parsableByteArray.setPosition(i18 + 8);
+                    stsdData.format = Ac3Util.parseAc3AnnexFFormat(parsableByteArray, Integer.toString(i4), str, drmInitData4);
+                } else if (readInt2 == Atom.TYPE_dec3) {
+                    parsableByteArray.setPosition(i18 + 8);
+                    stsdData.format = Ac3Util.parseEAc3AnnexFFormat(parsableByteArray, Integer.toString(i4), str, drmInitData4);
+                } else {
+                    if (readInt2 == Atom.TYPE_ddts) {
+                        str3 = str6;
+                        str4 = str5;
+                        drmInitData2 = drmInitData4;
+                        i10 = i18;
+                        z2 = true;
+                        i8 = i13;
+                        i9 = i12;
+                        stsdData.format = Format.createAudioSampleFormat(Integer.toString(i4), str6, null, -1, -1, i17, i16, null, drmInitData2, 0, str);
+                        readInt = readInt;
+                    } else {
+                        i10 = i18;
+                        str3 = str6;
+                        str4 = str5;
+                        drmInitData2 = drmInitData4;
+                        i8 = i13;
+                        i9 = i12;
+                        z2 = true;
+                        if (readInt2 == Atom.TYPE_alac) {
+                            byte[] bArr2 = new byte[readInt];
+                            i18 = i10;
+                            parsableByteArray.setPosition(i18);
+                            parsableByteArray.readBytes(bArr2, i9, readInt);
+                            bArr = bArr2;
+                            str6 = str3;
+                            i18 += readInt;
+                            i12 = i9;
+                            z3 = z2;
+                            drmInitData4 = drmInitData2;
+                            i13 = i8;
+                            str5 = str4;
+                            i11 = i2;
+                        }
+                    }
+                    i18 = i10;
+                    str6 = str3;
+                    i18 += readInt;
+                    i12 = i9;
+                    z3 = z2;
+                    drmInitData4 = drmInitData2;
+                    i13 = i8;
+                    str5 = str4;
+                    i11 = i2;
+                }
+                str3 = str6;
+                str4 = str5;
+                drmInitData2 = drmInitData4;
+                i8 = i13;
+                i9 = i12;
+                z2 = true;
+                str6 = str3;
+                i18 += readInt;
+                i12 = i9;
+                z3 = z2;
+                drmInitData4 = drmInitData2;
+                i13 = i8;
+                str5 = str4;
+                i11 = i2;
+            }
+            int findEsdsPosition = readInt2 == i19 ? i18 : findEsdsPosition(parsableByteArray, i18, readInt);
+            if (findEsdsPosition != -1) {
+                Pair<String, byte[]> parseEsdsFromParent = parseEsdsFromParent(parsableByteArray, findEsdsPosition);
+                str6 = (String) parseEsdsFromParent.first;
+                bArr = (byte[]) parseEsdsFromParent.second;
+                if (MimeTypes.AUDIO_AAC.equals(str6)) {
+                    Pair<Integer, Integer> parseAacAudioSpecificConfig = CodecSpecificDataUtil.parseAacAudioSpecificConfig(bArr);
+                    i16 = ((Integer) parseAacAudioSpecificConfig.first).intValue();
+                    i17 = ((Integer) parseAacAudioSpecificConfig.second).intValue();
+                }
+                i18 += readInt;
+                i12 = i9;
+                z3 = z2;
+                drmInitData4 = drmInitData2;
+                i13 = i8;
+                str5 = str4;
+                i11 = i2;
+            }
+            str6 = str3;
+            i18 += readInt;
+            i12 = i9;
+            z3 = z2;
+            drmInitData4 = drmInitData2;
+            i13 = i8;
+            str5 = str4;
+            i11 = i2;
+        }
+        String str7 = str6;
+        String str8 = str5;
+        DrmInitData drmInitData5 = drmInitData4;
+        int i20 = i13;
+        if (stsdData.format != null || str7 == null) {
+            return;
+        }
+        stsdData.format = Format.createAudioSampleFormat(Integer.toString(i4), str7, null, -1, -1, i17, i16, str8.equals(str7) ? i20 : -1, bArr != null ? Collections.singletonList(bArr) : null, drmInitData5, 0, str);
+    }
+
+    private static int findEsdsPosition(ParsableByteArray parsableByteArray, int i, int i2) {
+        int position = parsableByteArray.getPosition();
+        while (position - i < i2) {
+            parsableByteArray.setPosition(position);
+            int readInt = parsableByteArray.readInt();
+            Assertions.checkArgument(readInt > 0, "childAtomSize should be positive");
+            if (parsableByteArray.readInt() == Atom.TYPE_esds) {
+                return position;
+            }
+            position += readInt;
+        }
+        return -1;
+    }
+
+    private static Pair<String, byte[]> parseEsdsFromParent(ParsableByteArray parsableByteArray, int i) {
+        parsableByteArray.setPosition(i + 12);
+        parsableByteArray.skipBytes(1);
+        parseExpandableClassSize(parsableByteArray);
+        parsableByteArray.skipBytes(2);
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        if ((readUnsignedByte & 128) != 0) {
+            parsableByteArray.skipBytes(2);
+        }
+        if ((readUnsignedByte & 64) != 0) {
+            parsableByteArray.skipBytes(parsableByteArray.readUnsignedShort());
+        }
+        if ((readUnsignedByte & 32) != 0) {
+            parsableByteArray.skipBytes(2);
+        }
+        parsableByteArray.skipBytes(1);
+        parseExpandableClassSize(parsableByteArray);
+        String mimeTypeFromMp4ObjectType = MimeTypes.getMimeTypeFromMp4ObjectType(parsableByteArray.readUnsignedByte());
+        if (MimeTypes.AUDIO_MPEG.equals(mimeTypeFromMp4ObjectType) || MimeTypes.AUDIO_DTS.equals(mimeTypeFromMp4ObjectType) || MimeTypes.AUDIO_DTS_HD.equals(mimeTypeFromMp4ObjectType)) {
+            return Pair.create(mimeTypeFromMp4ObjectType, null);
+        }
+        parsableByteArray.skipBytes(12);
+        parsableByteArray.skipBytes(1);
+        int parseExpandableClassSize = parseExpandableClassSize(parsableByteArray);
+        byte[] bArr = new byte[parseExpandableClassSize];
+        parsableByteArray.readBytes(bArr, 0, parseExpandableClassSize);
+        return Pair.create(mimeTypeFromMp4ObjectType, bArr);
+    }
+
+    private static Pair<Integer, TrackEncryptionBox> parseSampleEntryEncryptionData(ParsableByteArray parsableByteArray, int i, int i2) {
+        Pair<Integer, TrackEncryptionBox> parseCommonEncryptionSinfFromParent;
+        int position = parsableByteArray.getPosition();
+        while (position - i < i2) {
+            parsableByteArray.setPosition(position);
+            int readInt = parsableByteArray.readInt();
+            Assertions.checkArgument(readInt > 0, "childAtomSize should be positive");
+            if (parsableByteArray.readInt() == Atom.TYPE_sinf && (parseCommonEncryptionSinfFromParent = parseCommonEncryptionSinfFromParent(parsableByteArray, position, readInt)) != null) {
+                return parseCommonEncryptionSinfFromParent;
+            }
+            position += readInt;
+        }
+        return null;
+    }
+
+    public static Pair<Integer, TrackEncryptionBox> parseCommonEncryptionSinfFromParent(ParsableByteArray parsableByteArray, int i, int i2) {
+        int i3 = i + 8;
+        int i4 = -1;
+        int i5 = 0;
+        String str = null;
+        Integer num = null;
+        while (i3 - i < i2) {
+            parsableByteArray.setPosition(i3);
+            int readInt = parsableByteArray.readInt();
+            int readInt2 = parsableByteArray.readInt();
+            if (readInt2 == Atom.TYPE_frma) {
+                num = Integer.valueOf(parsableByteArray.readInt());
+            } else if (readInt2 == Atom.TYPE_schm) {
+                parsableByteArray.skipBytes(4);
+                str = parsableByteArray.readString(4);
+            } else if (readInt2 == Atom.TYPE_schi) {
+                i4 = i3;
+                i5 = readInt;
+            }
+            i3 += readInt;
+        }
+        if (!C.CENC_TYPE_cenc.equals(str) && !C.CENC_TYPE_cbc1.equals(str) && !C.CENC_TYPE_cens.equals(str) && !C.CENC_TYPE_cbcs.equals(str)) {
+            return null;
+        }
+        Assertions.checkArgument(num != null, "frma atom is mandatory");
+        Assertions.checkArgument(i4 != -1, "schi atom is mandatory");
+        TrackEncryptionBox parseSchiFromParent = parseSchiFromParent(parsableByteArray, i4, i5, str);
+        Assertions.checkArgument(parseSchiFromParent != null, "tenc atom is mandatory");
+        return Pair.create(num, parseSchiFromParent);
+    }
+
+    private static TrackEncryptionBox parseSchiFromParent(ParsableByteArray parsableByteArray, int i, int i2, String str) {
+        int i3;
+        int i4;
+        int i5 = i + 8;
+        while (true) {
+            byte[] bArr = null;
+            if (i5 - i >= i2) {
+                return null;
+            }
+            parsableByteArray.setPosition(i5);
+            int readInt = parsableByteArray.readInt();
+            if (parsableByteArray.readInt() == Atom.TYPE_tenc) {
+                int parseFullAtomVersion = Atom.parseFullAtomVersion(parsableByteArray.readInt());
+                parsableByteArray.skipBytes(1);
+                if (parseFullAtomVersion == 0) {
+                    parsableByteArray.skipBytes(1);
+                    i4 = 0;
+                    i3 = 0;
+                } else {
+                    int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                    i3 = readUnsignedByte & 15;
+                    i4 = (readUnsignedByte & PsExtractor.VIDEO_STREAM_MASK) >> 4;
+                }
+                boolean z = parsableByteArray.readUnsignedByte() == 1;
+                int readUnsignedByte2 = parsableByteArray.readUnsignedByte();
+                byte[] bArr2 = new byte[16];
+                parsableByteArray.readBytes(bArr2, 0, 16);
+                if (z && readUnsignedByte2 == 0) {
+                    int readUnsignedByte3 = parsableByteArray.readUnsignedByte();
+                    bArr = new byte[readUnsignedByte3];
+                    parsableByteArray.readBytes(bArr, 0, readUnsignedByte3);
+                }
+                return new TrackEncryptionBox(z, str, readUnsignedByte2, bArr2, i4, i3, bArr);
+            }
+            i5 += readInt;
+        }
+    }
+
+    private static byte[] parseProjFromParent(ParsableByteArray parsableByteArray, int i, int i2) {
+        int i3 = i + 8;
+        while (i3 - i < i2) {
+            parsableByteArray.setPosition(i3);
+            int readInt = parsableByteArray.readInt();
+            if (parsableByteArray.readInt() == Atom.TYPE_proj) {
+                return Arrays.copyOfRange(parsableByteArray.data, i3, readInt + i3);
+            }
+            i3 += readInt;
+        }
+        return null;
+    }
+
+    private static int parseExpandableClassSize(ParsableByteArray parsableByteArray) {
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        int i = readUnsignedByte & 127;
+        while ((readUnsignedByte & 128) == 128) {
+            readUnsignedByte = parsableByteArray.readUnsignedByte();
+            i = (i << 7) | (readUnsignedByte & 127);
+        }
+        return i;
+    }
+
+    private static boolean canApplyEditWithGaplessInfo(long[] jArr, long j, long j2, long j3) {
+        int length = jArr.length - 1;
+        return jArr[0] <= j2 && j2 < jArr[Util.constrainValue(3, 0, length)] && jArr[Util.constrainValue(jArr.length - 3, 0, length)] < j3 && j3 <= j;
+    }
+
+    private AtomParsers() {
+    }
+
+    public static final class ChunkIterator {
+        private final ParsableByteArray chunkOffsets;
+        private final boolean chunkOffsetsAreLongs;
+        public int index;
+        public final int length;
+        private int nextSamplesPerChunkChangeIndex;
+        public int numSamples;
+        public long offset;
+        private int remainingSamplesPerChunkChanges;
+        private final ParsableByteArray stsc;
+
+        public ChunkIterator(ParsableByteArray parsableByteArray, ParsableByteArray parsableByteArray2, boolean z) {
+            this.stsc = parsableByteArray;
+            this.chunkOffsets = parsableByteArray2;
+            this.chunkOffsetsAreLongs = z;
+            parsableByteArray2.setPosition(12);
+            this.length = parsableByteArray2.readUnsignedIntToInt();
+            parsableByteArray.setPosition(12);
+            this.remainingSamplesPerChunkChanges = parsableByteArray.readUnsignedIntToInt();
+            Assertions.checkState(parsableByteArray.readInt() == 1, "first_chunk must be 1");
+            this.index = -1;
+        }
+
+        public final boolean moveNext() {
+            long readUnsignedInt;
+            int i = this.index + 1;
+            this.index = i;
+            if (i == this.length) {
+                return false;
+            }
+            if (this.chunkOffsetsAreLongs) {
+                readUnsignedInt = this.chunkOffsets.readUnsignedLongToLong();
+            } else {
+                readUnsignedInt = this.chunkOffsets.readUnsignedInt();
+            }
+            this.offset = readUnsignedInt;
+            if (this.index == this.nextSamplesPerChunkChangeIndex) {
+                this.numSamples = this.stsc.readUnsignedIntToInt();
+                this.stsc.skipBytes(4);
+                int i2 = this.remainingSamplesPerChunkChanges - 1;
+                this.remainingSamplesPerChunkChanges = i2;
+                this.nextSamplesPerChunkChangeIndex = i2 > 0 ? this.stsc.readUnsignedIntToInt() - 1 : -1;
+            }
+            return true;
+        }
+    }
+
+    public static final class TkhdData {
+        private final long duration;
+        private final int id;
+        private final int rotationDegrees;
+
+        public TkhdData(int i, long j, int i2) {
+            this.id = i;
+            this.duration = j;
+            this.rotationDegrees = i2;
+        }
+    }
+
+    public static final class StsdData {
+        public static final int STSD_HEADER_SIZE = 8;
+        public Format format;
+        public int nalUnitLengthFieldLength;
+        public int requiredSampleTransformation = 0;
+        public final TrackEncryptionBox[] trackEncryptionBoxes;
+
+        public StsdData(int i) {
+            this.trackEncryptionBoxes = new TrackEncryptionBox[i];
+        }
+    }
+
+    public static final class StszSampleSizeBox implements SampleSizeBox {
+        private final ParsableByteArray data;
+        private final int fixedSampleSize;
+        private final int sampleCount;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.AtomParsers.SampleSizeBox
+        public final int getSampleCount() {
+            return this.sampleCount;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.AtomParsers.SampleSizeBox
+        public final boolean isFixedSampleSize() {
+            return this.fixedSampleSize != 0;
+        }
+
+        public StszSampleSizeBox(Atom.LeafAtom leafAtom) {
+            ParsableByteArray parsableByteArray = leafAtom.data;
+            this.data = parsableByteArray;
+            parsableByteArray.setPosition(12);
+            this.fixedSampleSize = parsableByteArray.readUnsignedIntToInt();
+            this.sampleCount = parsableByteArray.readUnsignedIntToInt();
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.AtomParsers.SampleSizeBox
+        public final int readNextSampleSize() {
+            int i = this.fixedSampleSize;
+            return i == 0 ? this.data.readUnsignedIntToInt() : i;
+        }
+    }
+
+    public static final class Stz2SampleSizeBox implements SampleSizeBox {
+        private int currentByte;
+        private final ParsableByteArray data;
+        private final int fieldSize;
+        private final int sampleCount;
+        private int sampleIndex;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.AtomParsers.SampleSizeBox
+        public final int getSampleCount() {
+            return this.sampleCount;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.AtomParsers.SampleSizeBox
+        public final boolean isFixedSampleSize() {
+            return false;
+        }
+
+        public Stz2SampleSizeBox(Atom.LeafAtom leafAtom) {
+            ParsableByteArray parsableByteArray = leafAtom.data;
+            this.data = parsableByteArray;
+            parsableByteArray.setPosition(12);
+            this.fieldSize = parsableByteArray.readUnsignedIntToInt() & 255;
+            this.sampleCount = parsableByteArray.readUnsignedIntToInt();
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.AtomParsers.SampleSizeBox
+        public final int readNextSampleSize() {
+            int i = this.fieldSize;
+            if (i == 8) {
+                return this.data.readUnsignedByte();
+            }
+            if (i == 16) {
+                return this.data.readUnsignedShort();
+            }
+            int i2 = this.sampleIndex;
+            this.sampleIndex = i2 + 1;
+            if (i2 % 2 != 0) {
+                return this.currentByte & 15;
+            }
+            int readUnsignedByte = this.data.readUnsignedByte();
+            this.currentByte = readUnsignedByte;
+            return (readUnsignedByte & PsExtractor.VIDEO_STREAM_MASK) >> 4;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/DefaultSampleValues.java

@@ -0,0 +1,16 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+/* loaded from: classes4.dex */
+final class DefaultSampleValues {
+    public final int duration;
+    public final int flags;
+    public final int sampleDescriptionIndex;
+    public final int size;
+
+    public DefaultSampleValues(int i, int i2, int i3, int i4) {
+        this.sampleDescriptionIndex = i;
+        this.duration = i2;
+        this.size = i3;
+        this.flags = i4;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/FixedSampleSizeRechunker.java

@@ -0,0 +1,62 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+final class FixedSampleSizeRechunker {
+    private static final int MAX_SAMPLE_SIZE = 8192;
+
+    public static final class Results {
+        public final long duration;
+        public final int[] flags;
+        public final int maximumSize;
+        public final long[] offsets;
+        public final int[] sizes;
+        public final long[] timestamps;
+
+        private Results(long[] jArr, int[] iArr, int i, long[] jArr2, int[] iArr2, long j) {
+            this.offsets = jArr;
+            this.sizes = iArr;
+            this.maximumSize = i;
+            this.timestamps = jArr2;
+            this.flags = iArr2;
+            this.duration = j;
+        }
+    }
+
+    public static Results rechunk(int i, long[] jArr, int[] iArr, long j) {
+        int i2 = 8192 / i;
+        int i3 = 0;
+        for (int i4 : iArr) {
+            i3 += Util.ceilDivide(i4, i2);
+        }
+        long[] jArr2 = new long[i3];
+        int[] iArr2 = new int[i3];
+        long[] jArr3 = new long[i3];
+        int[] iArr3 = new int[i3];
+        int i5 = 0;
+        int i6 = 0;
+        int i7 = 0;
+        for (int i8 = 0; i8 < iArr.length; i8++) {
+            int i9 = iArr[i8];
+            long j2 = jArr[i8];
+            while (i9 > 0) {
+                int min = Math.min(i2, i9);
+                jArr2[i6] = j2;
+                int i10 = i * min;
+                iArr2[i6] = i10;
+                i7 = Math.max(i7, i10);
+                jArr3[i6] = i5 * j;
+                iArr3[i6] = 1;
+                j2 += iArr2[i6];
+                i5 += min;
+                i9 -= min;
+                i6++;
+            }
+        }
+        return new Results(jArr2, iArr2, i7, jArr3, iArr3, j * i5);
+    }
+
+    private FixedSampleSizeRechunker() {
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/MetadataUtil.java

@@ -0,0 +1,297 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import android.util.Log;
+import com.ironsource.mediationsdk.IronSourceSegment;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.ApicFrame;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.CommentFrame;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.Id3Frame;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.InternalFrame;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.TextInformationFrame;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+final class MetadataUtil {
+    private static final String LANGUAGE_UNDEFINED = "und";
+    private static final String TAG = "MetadataUtil";
+    private static final int SHORT_TYPE_NAME_1 = Util.getIntegerCodeForString("nam");
+    private static final int SHORT_TYPE_NAME_2 = Util.getIntegerCodeForString("trk");
+    private static final int SHORT_TYPE_COMMENT = Util.getIntegerCodeForString("cmt");
+    private static final int SHORT_TYPE_YEAR = Util.getIntegerCodeForString("day");
+    private static final int SHORT_TYPE_ARTIST = Util.getIntegerCodeForString("ART");
+    private static final int SHORT_TYPE_ENCODER = Util.getIntegerCodeForString("too");
+    private static final int SHORT_TYPE_ALBUM = Util.getIntegerCodeForString("alb");
+    private static final int SHORT_TYPE_COMPOSER_1 = Util.getIntegerCodeForString("com");
+    private static final int SHORT_TYPE_COMPOSER_2 = Util.getIntegerCodeForString("wrt");
+    private static final int SHORT_TYPE_LYRICS = Util.getIntegerCodeForString("lyr");
+    private static final int SHORT_TYPE_GENRE = Util.getIntegerCodeForString(IronSourceSegment.GENDER);
+    private static final int TYPE_COVER_ART = Util.getIntegerCodeForString("covr");
+    private static final int TYPE_GENRE = Util.getIntegerCodeForString("gnre");
+    private static final int TYPE_GROUPING = Util.getIntegerCodeForString("grp");
+    private static final int TYPE_DISK_NUMBER = Util.getIntegerCodeForString("disk");
+    private static final int TYPE_TRACK_NUMBER = Util.getIntegerCodeForString("trkn");
+    private static final int TYPE_TEMPO = Util.getIntegerCodeForString("tmpo");
+    private static final int TYPE_COMPILATION = Util.getIntegerCodeForString("cpil");
+    private static final int TYPE_ALBUM_ARTIST = Util.getIntegerCodeForString("aART");
+    private static final int TYPE_SORT_TRACK_NAME = Util.getIntegerCodeForString("sonm");
+    private static final int TYPE_SORT_ALBUM = Util.getIntegerCodeForString("soal");
+    private static final int TYPE_SORT_ARTIST = Util.getIntegerCodeForString("soar");
+    private static final int TYPE_SORT_ALBUM_ARTIST = Util.getIntegerCodeForString("soaa");
+    private static final int TYPE_SORT_COMPOSER = Util.getIntegerCodeForString("soco");
+    private static final int TYPE_RATING = Util.getIntegerCodeForString("rtng");
+    private static final int TYPE_GAPLESS_ALBUM = Util.getIntegerCodeForString("pgap");
+    private static final int TYPE_TV_SORT_SHOW = Util.getIntegerCodeForString("sosn");
+    private static final int TYPE_TV_SHOW = Util.getIntegerCodeForString("tvsh");
+    private static final int TYPE_INTERNAL = Util.getIntegerCodeForString(InternalFrame.ID);
+    private static final String[] STANDARD_GENRES = {"Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska", "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental", "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock", "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy", "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave", "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock", "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob", "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock", "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock", "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech", "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass", "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba", "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle", "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall", "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie", "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap", "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian", "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop", "Synthpop"};
+
+    private MetadataUtil() {
+    }
+
+    public static Metadata.Entry parseIlstElement(ParsableByteArray parsableByteArray) {
+        int position = parsableByteArray.getPosition() + parsableByteArray.readInt();
+        int readInt = parsableByteArray.readInt();
+        int i = (readInt >> 24) & 255;
+        try {
+            if (i == 169 || i == 65533) {
+                int i2 = 16777215 & readInt;
+                if (i2 == SHORT_TYPE_COMMENT) {
+                    return parseCommentAttribute(readInt, parsableByteArray);
+                }
+                if (i2 != SHORT_TYPE_NAME_1 && i2 != SHORT_TYPE_NAME_2) {
+                    if (i2 != SHORT_TYPE_COMPOSER_1 && i2 != SHORT_TYPE_COMPOSER_2) {
+                        if (i2 == SHORT_TYPE_YEAR) {
+                            return parseTextAttribute(readInt, "TDRC", parsableByteArray);
+                        }
+                        if (i2 == SHORT_TYPE_ARTIST) {
+                            return parseTextAttribute(readInt, "TPE1", parsableByteArray);
+                        }
+                        if (i2 == SHORT_TYPE_ENCODER) {
+                            return parseTextAttribute(readInt, "TSSE", parsableByteArray);
+                        }
+                        if (i2 == SHORT_TYPE_ALBUM) {
+                            return parseTextAttribute(readInt, "TALB", parsableByteArray);
+                        }
+                        if (i2 == SHORT_TYPE_LYRICS) {
+                            return parseTextAttribute(readInt, "USLT", parsableByteArray);
+                        }
+                        if (i2 == SHORT_TYPE_GENRE) {
+                            return parseTextAttribute(readInt, "TCON", parsableByteArray);
+                        }
+                        if (i2 == TYPE_GROUPING) {
+                            return parseTextAttribute(readInt, "TIT1", parsableByteArray);
+                        }
+                    }
+                    return parseTextAttribute(readInt, "TCOM", parsableByteArray);
+                }
+                return parseTextAttribute(readInt, "TIT2", parsableByteArray);
+            }
+            if (readInt == TYPE_GENRE) {
+                return parseStandardGenreAttribute(parsableByteArray);
+            }
+            if (readInt == TYPE_DISK_NUMBER) {
+                return parseIndexAndCountAttribute(readInt, "TPOS", parsableByteArray);
+            }
+            if (readInt == TYPE_TRACK_NUMBER) {
+                return parseIndexAndCountAttribute(readInt, "TRCK", parsableByteArray);
+            }
+            if (readInt == TYPE_TEMPO) {
+                return parseUint8Attribute(readInt, "TBPM", parsableByteArray, true, false);
+            }
+            if (readInt == TYPE_COMPILATION) {
+                return parseUint8Attribute(readInt, "TCMP", parsableByteArray, true, true);
+            }
+            if (readInt == TYPE_COVER_ART) {
+                return parseCoverArt(parsableByteArray);
+            }
+            if (readInt == TYPE_ALBUM_ARTIST) {
+                return parseTextAttribute(readInt, "TPE2", parsableByteArray);
+            }
+            if (readInt == TYPE_SORT_TRACK_NAME) {
+                return parseTextAttribute(readInt, "TSOT", parsableByteArray);
+            }
+            if (readInt == TYPE_SORT_ALBUM) {
+                return parseTextAttribute(readInt, "TSO2", parsableByteArray);
+            }
+            if (readInt == TYPE_SORT_ARTIST) {
+                return parseTextAttribute(readInt, "TSOA", parsableByteArray);
+            }
+            if (readInt == TYPE_SORT_ALBUM_ARTIST) {
+                return parseTextAttribute(readInt, "TSOP", parsableByteArray);
+            }
+            if (readInt == TYPE_SORT_COMPOSER) {
+                return parseTextAttribute(readInt, "TSOC", parsableByteArray);
+            }
+            if (readInt == TYPE_RATING) {
+                return parseUint8Attribute(readInt, "ITUNESADVISORY", parsableByteArray, false, false);
+            }
+            if (readInt == TYPE_GAPLESS_ALBUM) {
+                return parseUint8Attribute(readInt, "ITUNESGAPLESS", parsableByteArray, false, true);
+            }
+            if (readInt == TYPE_TV_SORT_SHOW) {
+                return parseTextAttribute(readInt, "TVSHOWSORT", parsableByteArray);
+            }
+            if (readInt == TYPE_TV_SHOW) {
+                return parseTextAttribute(readInt, "TVSHOW", parsableByteArray);
+            }
+            if (readInt == TYPE_INTERNAL) {
+                return parseInternalAttribute(parsableByteArray, position);
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.append("Skipped unknown metadata entry: ");
+            sb.append(Atom.getAtomTypeString(readInt));
+            parsableByteArray.setPosition(position);
+            return null;
+        } finally {
+            parsableByteArray.setPosition(position);
+        }
+    }
+
+    private static TextInformationFrame parseTextAttribute(int i, String str, ParsableByteArray parsableByteArray) {
+        int readInt = parsableByteArray.readInt();
+        if (parsableByteArray.readInt() == Atom.TYPE_data) {
+            parsableByteArray.skipBytes(8);
+            return new TextInformationFrame(str, null, parsableByteArray.readNullTerminatedString(readInt - 16));
+        }
+        Log.w(TAG, "Failed to parse text attribute: " + Atom.getAtomTypeString(i));
+        return null;
+    }
+
+    private static CommentFrame parseCommentAttribute(int i, ParsableByteArray parsableByteArray) {
+        int readInt = parsableByteArray.readInt();
+        if (parsableByteArray.readInt() == Atom.TYPE_data) {
+            parsableByteArray.skipBytes(8);
+            String readNullTerminatedString = parsableByteArray.readNullTerminatedString(readInt - 16);
+            return new CommentFrame("und", readNullTerminatedString, readNullTerminatedString);
+        }
+        Log.w(TAG, "Failed to parse comment attribute: " + Atom.getAtomTypeString(i));
+        return null;
+    }
+
+    private static Id3Frame parseUint8Attribute(int i, String str, ParsableByteArray parsableByteArray, boolean z, boolean z2) {
+        int parseUint8AttributeValue = parseUint8AttributeValue(parsableByteArray);
+        if (z2) {
+            parseUint8AttributeValue = Math.min(1, parseUint8AttributeValue);
+        }
+        if (parseUint8AttributeValue >= 0) {
+            if (z) {
+                return new TextInformationFrame(str, null, Integer.toString(parseUint8AttributeValue));
+            }
+            return new CommentFrame("und", str, Integer.toString(parseUint8AttributeValue));
+        }
+        Log.w(TAG, "Failed to parse uint8 attribute: " + Atom.getAtomTypeString(i));
+        return null;
+    }
+
+    private static TextInformationFrame parseIndexAndCountAttribute(int i, String str, ParsableByteArray parsableByteArray) {
+        int readInt = parsableByteArray.readInt();
+        if (parsableByteArray.readInt() == Atom.TYPE_data && readInt >= 22) {
+            parsableByteArray.skipBytes(10);
+            int readUnsignedShort = parsableByteArray.readUnsignedShort();
+            if (readUnsignedShort > 0) {
+                String str2 = "" + readUnsignedShort;
+                int readUnsignedShort2 = parsableByteArray.readUnsignedShort();
+                if (readUnsignedShort2 > 0) {
+                    str2 = str2 + "/" + readUnsignedShort2;
+                }
+                return new TextInformationFrame(str, null, str2);
+            }
+        }
+        Log.w(TAG, "Failed to parse index/count attribute: " + Atom.getAtomTypeString(i));
+        return null;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x001c  */
+    /* JADX WARN: Removed duplicated region for block: B:7:0x0014  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.TextInformationFrame parseStandardGenreAttribute(com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray r3) {
+        /*
+            int r3 = parseUint8AttributeValue(r3)
+            r0 = 0
+            if (r3 <= 0) goto L11
+            java.lang.String[] r1 = com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.MetadataUtil.STANDARD_GENRES
+            int r2 = r1.length
+            if (r3 > r2) goto L11
+            int r3 = r3 + (-1)
+            r3 = r1[r3]
+            goto L12
+        L11:
+            r3 = r0
+        L12:
+            if (r3 == 0) goto L1c
+            com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.TextInformationFrame r1 = new com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.TextInformationFrame
+            java.lang.String r2 = "TCON"
+            r1.<init>(r2, r0, r3)
+            return r1
+        L1c:
+            java.lang.String r3 = "MetadataUtil"
+            java.lang.String r1 = "Failed to parse standard genre code"
+            android.util.Log.w(r3, r1)
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.MetadataUtil.parseStandardGenreAttribute(com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray):com.mbridge.msdk.playercommon.exoplayer2.metadata.id3.TextInformationFrame");
+    }
+
+    private static ApicFrame parseCoverArt(ParsableByteArray parsableByteArray) {
+        int readInt = parsableByteArray.readInt();
+        if (parsableByteArray.readInt() == Atom.TYPE_data) {
+            int parseFullAtomFlags = Atom.parseFullAtomFlags(parsableByteArray.readInt());
+            String str = parseFullAtomFlags == 13 ? "image/jpeg" : parseFullAtomFlags == 14 ? "image/png" : null;
+            if (str == null) {
+                Log.w(TAG, "Unrecognized cover art flags: " + parseFullAtomFlags);
+                return null;
+            }
+            parsableByteArray.skipBytes(4);
+            int i = readInt - 16;
+            byte[] bArr = new byte[i];
+            parsableByteArray.readBytes(bArr, 0, i);
+            return new ApicFrame(str, null, 3, bArr);
+        }
+        Log.w(TAG, "Failed to parse cover art attribute");
+        return null;
+    }
+
+    private static Id3Frame parseInternalAttribute(ParsableByteArray parsableByteArray, int i) {
+        String str = null;
+        String str2 = null;
+        int i2 = -1;
+        int i3 = -1;
+        while (parsableByteArray.getPosition() < i) {
+            int position = parsableByteArray.getPosition();
+            int readInt = parsableByteArray.readInt();
+            int readInt2 = parsableByteArray.readInt();
+            parsableByteArray.skipBytes(4);
+            if (readInt2 == Atom.TYPE_mean) {
+                str = parsableByteArray.readNullTerminatedString(readInt - 12);
+            } else if (readInt2 == Atom.TYPE_name) {
+                str2 = parsableByteArray.readNullTerminatedString(readInt - 12);
+            } else {
+                if (readInt2 == Atom.TYPE_data) {
+                    i2 = position;
+                    i3 = readInt;
+                }
+                parsableByteArray.skipBytes(readInt - 12);
+            }
+        }
+        if (str == null || str2 == null || i2 == -1) {
+            return null;
+        }
+        parsableByteArray.setPosition(i2);
+        parsableByteArray.skipBytes(16);
+        return new InternalFrame(str, str2, parsableByteArray.readNullTerminatedString(i3 - 16));
+    }
+
+    private static int parseUint8AttributeValue(ParsableByteArray parsableByteArray) {
+        parsableByteArray.skipBytes(4);
+        if (parsableByteArray.readInt() == Atom.TYPE_data) {
+            parsableByteArray.skipBytes(8);
+            return parsableByteArray.readUnsignedByte();
+        }
+        Log.w(TAG, "Failed to parse uint8 attribute value");
+        return -1;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/Mp4Extractor.java

@@ -0,0 +1,569 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.GaplessInfoHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekPoint;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Atom;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.AtomParsers;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.NalUnitUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+
+/* loaded from: classes4.dex */
+public final class Mp4Extractor implements Extractor, SeekMap {
+    public static final int FLAG_WORKAROUND_IGNORE_EDIT_LISTS = 1;
+    private static final long MAXIMUM_READ_AHEAD_BYTES_STREAM = 10485760;
+    private static final long RELOAD_MINIMUM_SEEK_DISTANCE = 262144;
+    private static final int STATE_READING_ATOM_HEADER = 0;
+    private static final int STATE_READING_ATOM_PAYLOAD = 1;
+    private static final int STATE_READING_SAMPLE = 2;
+    private long[][] accumulatedSampleSizes;
+    private ParsableByteArray atomData;
+    private final ParsableByteArray atomHeader;
+    private int atomHeaderBytesRead;
+    private long atomSize;
+    private int atomType;
+    private final ArrayDeque<Atom.ContainerAtom> containerAtoms;
+    private long durationUs;
+    private ExtractorOutput extractorOutput;
+    private int firstVideoTrackIndex;
+    private final int flags;
+    private boolean isQuickTime;
+    private final ParsableByteArray nalLength;
+    private final ParsableByteArray nalStartCode;
+    private int parserState;
+    private int sampleBytesWritten;
+    private int sampleCurrentNalBytesRemaining;
+    private int sampleTrackIndex;
+    private Mp4Track[] tracks;
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Mp4Extractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new Mp4Extractor()};
+        }
+    };
+    private static final int BRAND_QUICKTIME = Util.getIntegerCodeForString("qt  ");
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Flags {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    private void enterReadingAtomHeaderState() {
+        this.parserState = 0;
+        this.atomHeaderBytesRead = 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final long getDurationUs() {
+        return this.durationUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        this.extractorOutput = extractorOutput;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final boolean isSeekable() {
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    public Mp4Extractor() {
+        this(0);
+    }
+
+    public Mp4Extractor(int i) {
+        this.flags = i;
+        this.atomHeader = new ParsableByteArray(16);
+        this.containerAtoms = new ArrayDeque<>();
+        this.nalStartCode = new ParsableByteArray(NalUnitUtil.NAL_START_CODE);
+        this.nalLength = new ParsableByteArray(4);
+        this.sampleTrackIndex = -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        return Sniffer.sniffUnfragmented(extractorInput);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.containerAtoms.clear();
+        this.atomHeaderBytesRead = 0;
+        this.sampleTrackIndex = -1;
+        this.sampleBytesWritten = 0;
+        this.sampleCurrentNalBytesRemaining = 0;
+        if (j == 0) {
+            enterReadingAtomHeaderState();
+        } else if (this.tracks != null) {
+            updateSampleIndices(j2);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        while (true) {
+            int i = this.parserState;
+            if (i != 0) {
+                if (i != 1) {
+                    if (i == 2) {
+                        return readSample(extractorInput, positionHolder);
+                    }
+                    throw new IllegalStateException();
+                }
+                if (readAtomPayload(extractorInput, positionHolder)) {
+                    return 1;
+                }
+            } else if (!readAtomHeader(extractorInput)) {
+                return -1;
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final SeekMap.SeekPoints getSeekPoints(long j) {
+        long j2;
+        long j3;
+        int indexOfLaterOrEqualSynchronizationSample;
+        Mp4Track[] mp4TrackArr = this.tracks;
+        if (mp4TrackArr.length == 0) {
+            return new SeekMap.SeekPoints(SeekPoint.START);
+        }
+        int i = this.firstVideoTrackIndex;
+        long j4 = -1;
+        if (i != -1) {
+            TrackSampleTable trackSampleTable = mp4TrackArr[i].sampleTable;
+            int synchronizationSampleIndex = getSynchronizationSampleIndex(trackSampleTable, j);
+            if (synchronizationSampleIndex == -1) {
+                return new SeekMap.SeekPoints(SeekPoint.START);
+            }
+            long j5 = trackSampleTable.timestampsUs[synchronizationSampleIndex];
+            j2 = trackSampleTable.offsets[synchronizationSampleIndex];
+            if (j5 >= j || synchronizationSampleIndex >= trackSampleTable.sampleCount - 1 || (indexOfLaterOrEqualSynchronizationSample = trackSampleTable.getIndexOfLaterOrEqualSynchronizationSample(j)) == -1 || indexOfLaterOrEqualSynchronizationSample == synchronizationSampleIndex) {
+                j3 = -9223372036854775807L;
+            } else {
+                j3 = trackSampleTable.timestampsUs[indexOfLaterOrEqualSynchronizationSample];
+                j4 = trackSampleTable.offsets[indexOfLaterOrEqualSynchronizationSample];
+            }
+            j = j5;
+        } else {
+            j2 = Long.MAX_VALUE;
+            j3 = -9223372036854775807L;
+        }
+        int i2 = 0;
+        while (true) {
+            Mp4Track[] mp4TrackArr2 = this.tracks;
+            if (i2 >= mp4TrackArr2.length) {
+                break;
+            }
+            if (i2 != this.firstVideoTrackIndex) {
+                TrackSampleTable trackSampleTable2 = mp4TrackArr2[i2].sampleTable;
+                long maybeAdjustSeekOffset = maybeAdjustSeekOffset(trackSampleTable2, j, j2);
+                if (j3 != C.TIME_UNSET) {
+                    j4 = maybeAdjustSeekOffset(trackSampleTable2, j3, j4);
+                }
+                j2 = maybeAdjustSeekOffset;
+            }
+            i2++;
+        }
+        SeekPoint seekPoint = new SeekPoint(j, j2);
+        if (j3 == C.TIME_UNSET) {
+            return new SeekMap.SeekPoints(seekPoint);
+        }
+        return new SeekMap.SeekPoints(seekPoint, new SeekPoint(j3, j4));
+    }
+
+    private boolean readAtomHeader(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        if (this.atomHeaderBytesRead == 0) {
+            if (!extractorInput.readFully(this.atomHeader.data, 0, 8, true)) {
+                return false;
+            }
+            this.atomHeaderBytesRead = 8;
+            this.atomHeader.setPosition(0);
+            this.atomSize = this.atomHeader.readUnsignedInt();
+            this.atomType = this.atomHeader.readInt();
+        }
+        long j = this.atomSize;
+        if (j == 1) {
+            extractorInput.readFully(this.atomHeader.data, 8, 8);
+            this.atomHeaderBytesRead += 8;
+            this.atomSize = this.atomHeader.readUnsignedLongToLong();
+        } else if (j == 0) {
+            long length = extractorInput.getLength();
+            if (length == -1 && !this.containerAtoms.isEmpty()) {
+                length = this.containerAtoms.peek().endPosition;
+            }
+            if (length != -1) {
+                this.atomSize = (length - extractorInput.getPosition()) + this.atomHeaderBytesRead;
+            }
+        }
+        if (this.atomSize < this.atomHeaderBytesRead) {
+            throw new ParserException("Atom size less than header length (unsupported).");
+        }
+        if (shouldParseContainerAtom(this.atomType)) {
+            long position = (extractorInput.getPosition() + this.atomSize) - this.atomHeaderBytesRead;
+            this.containerAtoms.push(new Atom.ContainerAtom(this.atomType, position));
+            if (this.atomSize == this.atomHeaderBytesRead) {
+                processAtomEnded(position);
+            } else {
+                enterReadingAtomHeaderState();
+            }
+        } else if (shouldParseLeafAtom(this.atomType)) {
+            Assertions.checkState(this.atomHeaderBytesRead == 8);
+            Assertions.checkState(this.atomSize <= 2147483647L);
+            ParsableByteArray parsableByteArray = new ParsableByteArray((int) this.atomSize);
+            this.atomData = parsableByteArray;
+            System.arraycopy(this.atomHeader.data, 0, parsableByteArray.data, 0, 8);
+            this.parserState = 1;
+        } else {
+            this.atomData = null;
+            this.parserState = 1;
+        }
+        return true;
+    }
+
+    private boolean readAtomPayload(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        boolean z;
+        long j = this.atomSize - this.atomHeaderBytesRead;
+        long position = extractorInput.getPosition() + j;
+        ParsableByteArray parsableByteArray = this.atomData;
+        if (parsableByteArray != null) {
+            extractorInput.readFully(parsableByteArray.data, this.atomHeaderBytesRead, (int) j);
+            if (this.atomType == Atom.TYPE_ftyp) {
+                this.isQuickTime = processFtypAtom(this.atomData);
+            } else if (!this.containerAtoms.isEmpty()) {
+                this.containerAtoms.peek().add(new Atom.LeafAtom(this.atomType, this.atomData));
+            }
+        } else if (j < 262144) {
+            extractorInput.skipFully((int) j);
+        } else {
+            positionHolder.position = extractorInput.getPosition() + j;
+            z = true;
+            processAtomEnded(position);
+            return (z || this.parserState == 2) ? false : true;
+        }
+        z = false;
+        processAtomEnded(position);
+        if (z) {
+        }
+    }
+
+    private void processAtomEnded(long j) throws ParserException {
+        while (!this.containerAtoms.isEmpty() && this.containerAtoms.peek().endPosition == j) {
+            Atom.ContainerAtom pop = this.containerAtoms.pop();
+            if (pop.type == Atom.TYPE_moov) {
+                processMoovAtom(pop);
+                this.containerAtoms.clear();
+                this.parserState = 2;
+            } else if (!this.containerAtoms.isEmpty()) {
+                this.containerAtoms.peek().add(pop);
+            }
+        }
+        if (this.parserState != 2) {
+            enterReadingAtomHeaderState();
+        }
+    }
+
+    private void processMoovAtom(Atom.ContainerAtom containerAtom) throws ParserException {
+        Metadata metadata;
+        ArrayList<TrackSampleTable> trackSampleTables;
+        ArrayList arrayList = new ArrayList();
+        GaplessInfoHolder gaplessInfoHolder = new GaplessInfoHolder();
+        Atom.LeafAtom leafAtomOfType = containerAtom.getLeafAtomOfType(Atom.TYPE_udta);
+        if (leafAtomOfType != null) {
+            metadata = AtomParsers.parseUdta(leafAtomOfType, this.isQuickTime);
+            if (metadata != null) {
+                gaplessInfoHolder.setFromMetadata(metadata);
+            }
+        } else {
+            metadata = null;
+        }
+        int i = 1;
+        int i2 = 0;
+        try {
+            trackSampleTables = getTrackSampleTables(containerAtom, gaplessInfoHolder, (this.flags & 1) != 0);
+        } catch (AtomParsers.UnhandledEditListException unused) {
+            gaplessInfoHolder = new GaplessInfoHolder();
+            trackSampleTables = getTrackSampleTables(containerAtom, gaplessInfoHolder, true);
+        }
+        int size = trackSampleTables.size();
+        int i3 = -1;
+        long j = C.TIME_UNSET;
+        while (i2 < size) {
+            TrackSampleTable trackSampleTable = trackSampleTables.get(i2);
+            Track track = trackSampleTable.track;
+            Mp4Track mp4Track = new Mp4Track(track, trackSampleTable, this.extractorOutput.track(i2, track.type));
+            Format copyWithMaxInputSize = track.format.copyWithMaxInputSize(trackSampleTable.maximumSize + 30);
+            if (track.type == i) {
+                if (gaplessInfoHolder.hasGaplessInfo()) {
+                    copyWithMaxInputSize = copyWithMaxInputSize.copyWithGaplessInfo(gaplessInfoHolder.encoderDelay, gaplessInfoHolder.encoderPadding);
+                }
+                if (metadata != null) {
+                    copyWithMaxInputSize = copyWithMaxInputSize.copyWithMetadata(metadata);
+                }
+            }
+            mp4Track.trackOutput.format(copyWithMaxInputSize);
+            long j2 = track.durationUs;
+            if (j2 == C.TIME_UNSET) {
+                j2 = trackSampleTable.durationUs;
+            }
+            j = Math.max(j, j2);
+            if (track.type == 2 && i3 == -1) {
+                i3 = arrayList.size();
+            }
+            arrayList.add(mp4Track);
+            i2++;
+            i = 1;
+        }
+        this.firstVideoTrackIndex = i3;
+        this.durationUs = j;
+        Mp4Track[] mp4TrackArr = (Mp4Track[]) arrayList.toArray(new Mp4Track[arrayList.size()]);
+        this.tracks = mp4TrackArr;
+        this.accumulatedSampleSizes = calculateAccumulatedSampleSizes(mp4TrackArr);
+        this.extractorOutput.endTracks();
+        this.extractorOutput.seekMap(this);
+    }
+
+    private ArrayList<TrackSampleTable> getTrackSampleTables(Atom.ContainerAtom containerAtom, GaplessInfoHolder gaplessInfoHolder, boolean z) throws ParserException {
+        Track parseTrak;
+        ArrayList<TrackSampleTable> arrayList = new ArrayList<>();
+        for (int i = 0; i < containerAtom.containerChildren.size(); i++) {
+            Atom.ContainerAtom containerAtom2 = containerAtom.containerChildren.get(i);
+            if (containerAtom2.type == Atom.TYPE_trak && (parseTrak = AtomParsers.parseTrak(containerAtom2, containerAtom.getLeafAtomOfType(Atom.TYPE_mvhd), C.TIME_UNSET, null, z, this.isQuickTime)) != null) {
+                TrackSampleTable parseStbl = AtomParsers.parseStbl(parseTrak, containerAtom2.getContainerAtomOfType(Atom.TYPE_mdia).getContainerAtomOfType(Atom.TYPE_minf).getContainerAtomOfType(Atom.TYPE_stbl), gaplessInfoHolder);
+                if (parseStbl.sampleCount != 0) {
+                    arrayList.add(parseStbl);
+                }
+            }
+        }
+        return arrayList;
+    }
+
+    private int readSample(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        long position = extractorInput.getPosition();
+        if (this.sampleTrackIndex == -1) {
+            int trackIndexOfNextReadSample = getTrackIndexOfNextReadSample(position);
+            this.sampleTrackIndex = trackIndexOfNextReadSample;
+            if (trackIndexOfNextReadSample == -1) {
+                return -1;
+            }
+        }
+        Mp4Track mp4Track = this.tracks[this.sampleTrackIndex];
+        TrackOutput trackOutput = mp4Track.trackOutput;
+        int i = mp4Track.sampleIndex;
+        TrackSampleTable trackSampleTable = mp4Track.sampleTable;
+        long j = trackSampleTable.offsets[i];
+        int i2 = trackSampleTable.sizes[i];
+        long j2 = (j - position) + this.sampleBytesWritten;
+        if (j2 < 0 || j2 >= 262144) {
+            positionHolder.position = j;
+            return 1;
+        }
+        if (mp4Track.track.sampleTransformation == 1) {
+            j2 += 8;
+            i2 -= 8;
+        }
+        extractorInput.skipFully((int) j2);
+        int i3 = mp4Track.track.nalUnitLengthFieldLength;
+        if (i3 == 0) {
+            while (true) {
+                int i4 = this.sampleBytesWritten;
+                if (i4 >= i2) {
+                    break;
+                }
+                int sampleData = trackOutput.sampleData(extractorInput, i2 - i4, false);
+                this.sampleBytesWritten += sampleData;
+                this.sampleCurrentNalBytesRemaining -= sampleData;
+            }
+        } else {
+            byte[] bArr = this.nalLength.data;
+            bArr[0] = 0;
+            bArr[1] = 0;
+            bArr[2] = 0;
+            int i5 = 4 - i3;
+            while (this.sampleBytesWritten < i2) {
+                int i6 = this.sampleCurrentNalBytesRemaining;
+                if (i6 == 0) {
+                    extractorInput.readFully(this.nalLength.data, i5, i3);
+                    this.nalLength.setPosition(0);
+                    this.sampleCurrentNalBytesRemaining = this.nalLength.readUnsignedIntToInt();
+                    this.nalStartCode.setPosition(0);
+                    trackOutput.sampleData(this.nalStartCode, 4);
+                    this.sampleBytesWritten += 4;
+                    i2 += i5;
+                } else {
+                    int sampleData2 = trackOutput.sampleData(extractorInput, i6, false);
+                    this.sampleBytesWritten += sampleData2;
+                    this.sampleCurrentNalBytesRemaining -= sampleData2;
+                }
+            }
+        }
+        int i7 = i2;
+        TrackSampleTable trackSampleTable2 = mp4Track.sampleTable;
+        trackOutput.sampleMetadata(trackSampleTable2.timestampsUs[i], trackSampleTable2.flags[i], i7, 0, null);
+        mp4Track.sampleIndex++;
+        this.sampleTrackIndex = -1;
+        this.sampleBytesWritten = 0;
+        this.sampleCurrentNalBytesRemaining = 0;
+        return 0;
+    }
+
+    private int getTrackIndexOfNextReadSample(long j) {
+        int i = -1;
+        int i2 = -1;
+        int i3 = 0;
+        long j2 = Long.MAX_VALUE;
+        boolean z = true;
+        long j3 = Long.MAX_VALUE;
+        boolean z2 = true;
+        long j4 = Long.MAX_VALUE;
+        while (true) {
+            Mp4Track[] mp4TrackArr = this.tracks;
+            if (i3 >= mp4TrackArr.length) {
+                break;
+            }
+            Mp4Track mp4Track = mp4TrackArr[i3];
+            int i4 = mp4Track.sampleIndex;
+            TrackSampleTable trackSampleTable = mp4Track.sampleTable;
+            if (i4 != trackSampleTable.sampleCount) {
+                long j5 = trackSampleTable.offsets[i4];
+                long j6 = this.accumulatedSampleSizes[i3][i4];
+                long j7 = j5 - j;
+                boolean z3 = j7 < 0 || j7 >= 262144;
+                if ((!z3 && z2) || (z3 == z2 && j7 < j4)) {
+                    z2 = z3;
+                    j4 = j7;
+                    i2 = i3;
+                    j3 = j6;
+                }
+                if (j6 < j2) {
+                    z = z3;
+                    i = i3;
+                    j2 = j6;
+                }
+            }
+            i3++;
+        }
+        return (j2 == Long.MAX_VALUE || !z || j3 < j2 + MAXIMUM_READ_AHEAD_BYTES_STREAM) ? i2 : i;
+    }
+
+    private void updateSampleIndices(long j) {
+        for (Mp4Track mp4Track : this.tracks) {
+            TrackSampleTable trackSampleTable = mp4Track.sampleTable;
+            int indexOfEarlierOrEqualSynchronizationSample = trackSampleTable.getIndexOfEarlierOrEqualSynchronizationSample(j);
+            if (indexOfEarlierOrEqualSynchronizationSample == -1) {
+                indexOfEarlierOrEqualSynchronizationSample = trackSampleTable.getIndexOfLaterOrEqualSynchronizationSample(j);
+            }
+            mp4Track.sampleIndex = indexOfEarlierOrEqualSynchronizationSample;
+        }
+    }
+
+    private static long[][] calculateAccumulatedSampleSizes(Mp4Track[] mp4TrackArr) {
+        long[][] jArr = new long[mp4TrackArr.length][];
+        int[] iArr = new int[mp4TrackArr.length];
+        long[] jArr2 = new long[mp4TrackArr.length];
+        boolean[] zArr = new boolean[mp4TrackArr.length];
+        for (int i = 0; i < mp4TrackArr.length; i++) {
+            jArr[i] = new long[mp4TrackArr[i].sampleTable.sampleCount];
+            jArr2[i] = mp4TrackArr[i].sampleTable.timestampsUs[0];
+        }
+        long j = 0;
+        int i2 = 0;
+        while (i2 < mp4TrackArr.length) {
+            long j2 = Long.MAX_VALUE;
+            int i3 = -1;
+            for (int i4 = 0; i4 < mp4TrackArr.length; i4++) {
+                if (!zArr[i4]) {
+                    long j3 = jArr2[i4];
+                    if (j3 <= j2) {
+                        i3 = i4;
+                        j2 = j3;
+                    }
+                }
+            }
+            int i5 = iArr[i3];
+            long[] jArr3 = jArr[i3];
+            jArr3[i5] = j;
+            TrackSampleTable trackSampleTable = mp4TrackArr[i3].sampleTable;
+            j += trackSampleTable.sizes[i5];
+            int i6 = i5 + 1;
+            iArr[i3] = i6;
+            if (i6 < jArr3.length) {
+                jArr2[i3] = trackSampleTable.timestampsUs[i6];
+            } else {
+                zArr[i3] = true;
+                i2++;
+            }
+        }
+        return jArr;
+    }
+
+    private static long maybeAdjustSeekOffset(TrackSampleTable trackSampleTable, long j, long j2) {
+        int synchronizationSampleIndex = getSynchronizationSampleIndex(trackSampleTable, j);
+        return synchronizationSampleIndex == -1 ? j2 : Math.min(trackSampleTable.offsets[synchronizationSampleIndex], j2);
+    }
+
+    private static int getSynchronizationSampleIndex(TrackSampleTable trackSampleTable, long j) {
+        int indexOfEarlierOrEqualSynchronizationSample = trackSampleTable.getIndexOfEarlierOrEqualSynchronizationSample(j);
+        return indexOfEarlierOrEqualSynchronizationSample == -1 ? trackSampleTable.getIndexOfLaterOrEqualSynchronizationSample(j) : indexOfEarlierOrEqualSynchronizationSample;
+    }
+
+    private static boolean processFtypAtom(ParsableByteArray parsableByteArray) {
+        parsableByteArray.setPosition(8);
+        if (parsableByteArray.readInt() == BRAND_QUICKTIME) {
+            return true;
+        }
+        parsableByteArray.skipBytes(4);
+        while (parsableByteArray.bytesLeft() > 0) {
+            if (parsableByteArray.readInt() == BRAND_QUICKTIME) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean shouldParseLeafAtom(int i) {
+        return i == Atom.TYPE_mdhd || i == Atom.TYPE_mvhd || i == Atom.TYPE_hdlr || i == Atom.TYPE_stsd || i == Atom.TYPE_stts || i == Atom.TYPE_stss || i == Atom.TYPE_ctts || i == Atom.TYPE_elst || i == Atom.TYPE_stsc || i == Atom.TYPE_stsz || i == Atom.TYPE_stz2 || i == Atom.TYPE_stco || i == Atom.TYPE_co64 || i == Atom.TYPE_tkhd || i == Atom.TYPE_ftyp || i == Atom.TYPE_udta;
+    }
+
+    private static boolean shouldParseContainerAtom(int i) {
+        return i == Atom.TYPE_moov || i == Atom.TYPE_trak || i == Atom.TYPE_mdia || i == Atom.TYPE_minf || i == Atom.TYPE_stbl || i == Atom.TYPE_edts;
+    }
+
+    public static final class Mp4Track {
+        public int sampleIndex;
+        public final TrackSampleTable sampleTable;
+        public final Track track;
+        public final TrackOutput trackOutput;
+
+        public Mp4Track(Track track, TrackSampleTable trackSampleTable, TrackOutput trackOutput) {
+            this.track = track;
+            this.sampleTable = trackSampleTable;
+            this.trackOutput = trackOutput;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/PsshAtomUtil.java

@@ -0,0 +1,117 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import csdk.gluads.Consts;
+import java.nio.ByteBuffer;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public final class PsshAtomUtil {
+    private static final String TAG = "PsshAtomUtil";
+
+    private PsshAtomUtil() {
+    }
+
+    public static byte[] buildPsshAtom(UUID uuid, @Nullable byte[] bArr) {
+        return buildPsshAtom(uuid, null, bArr);
+    }
+
+    public static byte[] buildPsshAtom(UUID uuid, @Nullable UUID[] uuidArr, @Nullable byte[] bArr) {
+        boolean z = uuidArr != null;
+        int length = bArr != null ? bArr.length : 0;
+        int i = length + 32;
+        if (z) {
+            i += (uuidArr.length * 16) + 4;
+        }
+        ByteBuffer allocate = ByteBuffer.allocate(i);
+        allocate.putInt(i);
+        allocate.putInt(Atom.TYPE_pssh);
+        allocate.putInt(z ? 16777216 : 0);
+        allocate.putLong(uuid.getMostSignificantBits());
+        allocate.putLong(uuid.getLeastSignificantBits());
+        if (z) {
+            allocate.putInt(uuidArr.length);
+            for (UUID uuid2 : uuidArr) {
+                allocate.putLong(uuid2.getMostSignificantBits());
+                allocate.putLong(uuid2.getLeastSignificantBits());
+            }
+        }
+        if (length != 0) {
+            allocate.putInt(bArr.length);
+            allocate.put(bArr);
+        }
+        return allocate.array();
+    }
+
+    @Nullable
+    public static UUID parseUuid(byte[] bArr) {
+        PsshAtom parsePsshAtom = parsePsshAtom(bArr);
+        if (parsePsshAtom == null) {
+            return null;
+        }
+        return parsePsshAtom.uuid;
+    }
+
+    public static int parseVersion(byte[] bArr) {
+        PsshAtom parsePsshAtom = parsePsshAtom(bArr);
+        if (parsePsshAtom == null) {
+            return -1;
+        }
+        return parsePsshAtom.version;
+    }
+
+    @Nullable
+    public static byte[] parseSchemeSpecificData(byte[] bArr, UUID uuid) {
+        PsshAtom parsePsshAtom = parsePsshAtom(bArr);
+        if (parsePsshAtom == null) {
+            return null;
+        }
+        if (uuid != null && !uuid.equals(parsePsshAtom.uuid)) {
+            Log.w(TAG, "UUID mismatch. Expected: " + uuid + ", got: " + parsePsshAtom.uuid + Consts.STRING_PERIOD);
+            return null;
+        }
+        return parsePsshAtom.schemeData;
+    }
+
+    @Nullable
+    private static PsshAtom parsePsshAtom(byte[] bArr) {
+        ParsableByteArray parsableByteArray = new ParsableByteArray(bArr);
+        if (parsableByteArray.limit() < 32) {
+            return null;
+        }
+        parsableByteArray.setPosition(0);
+        if (parsableByteArray.readInt() != parsableByteArray.bytesLeft() + 4 || parsableByteArray.readInt() != Atom.TYPE_pssh) {
+            return null;
+        }
+        int parseFullAtomVersion = Atom.parseFullAtomVersion(parsableByteArray.readInt());
+        if (parseFullAtomVersion > 1) {
+            Log.w(TAG, "Unsupported pssh version: " + parseFullAtomVersion);
+            return null;
+        }
+        UUID uuid = new UUID(parsableByteArray.readLong(), parsableByteArray.readLong());
+        if (parseFullAtomVersion == 1) {
+            parsableByteArray.skipBytes(parsableByteArray.readUnsignedIntToInt() * 16);
+        }
+        int readUnsignedIntToInt = parsableByteArray.readUnsignedIntToInt();
+        if (readUnsignedIntToInt != parsableByteArray.bytesLeft()) {
+            return null;
+        }
+        byte[] bArr2 = new byte[readUnsignedIntToInt];
+        parsableByteArray.readBytes(bArr2, 0, readUnsignedIntToInt);
+        return new PsshAtom(uuid, parseFullAtomVersion, bArr2);
+    }
+
+    public static class PsshAtom {
+        private final byte[] schemeData;
+        private final UUID uuid;
+        private final int version;
+
+        public PsshAtom(UUID uuid, int i, byte[] bArr) {
+            this.uuid = uuid;
+            this.version = i;
+            this.schemeData = bArr;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/Sniffer.java

@@ -0,0 +1,121 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import android.support.v4.media.session.PlaybackStateCompat;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+final class Sniffer {
+    private static final int[] COMPATIBLE_BRANDS = {Util.getIntegerCodeForString("isom"), Util.getIntegerCodeForString("iso2"), Util.getIntegerCodeForString("iso3"), Util.getIntegerCodeForString("iso4"), Util.getIntegerCodeForString("iso5"), Util.getIntegerCodeForString("iso6"), Util.getIntegerCodeForString("avc1"), Util.getIntegerCodeForString("hvc1"), Util.getIntegerCodeForString("hev1"), Util.getIntegerCodeForString("mp41"), Util.getIntegerCodeForString("mp42"), Util.getIntegerCodeForString("3g2a"), Util.getIntegerCodeForString("3g2b"), Util.getIntegerCodeForString("3gr6"), Util.getIntegerCodeForString("3gs6"), Util.getIntegerCodeForString("3ge6"), Util.getIntegerCodeForString("3gg6"), Util.getIntegerCodeForString("M4V "), Util.getIntegerCodeForString("M4A "), Util.getIntegerCodeForString("f4v "), Util.getIntegerCodeForString("kddi"), Util.getIntegerCodeForString("M4VP"), Util.getIntegerCodeForString("qt  "), Util.getIntegerCodeForString("MSNV")};
+    private static final int SEARCH_LENGTH = 4096;
+
+    public static boolean sniffFragmented(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        return sniffInternal(extractorInput, true);
+    }
+
+    public static boolean sniffUnfragmented(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        return sniffInternal(extractorInput, false);
+    }
+
+    private static boolean sniffInternal(ExtractorInput extractorInput, boolean z) throws IOException, InterruptedException {
+        boolean z2;
+        boolean z3;
+        int i;
+        long length = extractorInput.getLength();
+        long j = -1;
+        if (length == -1 || length > PlaybackStateCompat.ACTION_SKIP_TO_QUEUE_ITEM) {
+            length = 4096;
+        }
+        int i2 = (int) length;
+        ParsableByteArray parsableByteArray = new ParsableByteArray(64);
+        int i3 = 0;
+        boolean z4 = false;
+        while (i3 < i2) {
+            parsableByteArray.reset(8);
+            extractorInput.peekFully(parsableByteArray.data, 0, 8);
+            long readUnsignedInt = parsableByteArray.readUnsignedInt();
+            int readInt = parsableByteArray.readInt();
+            if (readUnsignedInt == 1) {
+                extractorInput.peekFully(parsableByteArray.data, 8, 8);
+                parsableByteArray.setLimit(16);
+                i = 16;
+                readUnsignedInt = parsableByteArray.readUnsignedLongToLong();
+            } else {
+                if (readUnsignedInt == 0) {
+                    long length2 = extractorInput.getLength();
+                    if (length2 != j) {
+                        readUnsignedInt = 8 + (length2 - extractorInput.getPosition());
+                    }
+                }
+                i = 8;
+            }
+            long j2 = i;
+            if (readUnsignedInt < j2) {
+                return false;
+            }
+            i3 += i;
+            if (readInt != Atom.TYPE_moov) {
+                if (readInt == Atom.TYPE_moof || readInt == Atom.TYPE_mvex) {
+                    z2 = true;
+                    z3 = true;
+                    break;
+                }
+                if ((i3 + readUnsignedInt) - j2 >= i2) {
+                    break;
+                }
+                int i4 = (int) (readUnsignedInt - j2);
+                i3 += i4;
+                if (readInt == Atom.TYPE_ftyp) {
+                    if (i4 < 8) {
+                        return false;
+                    }
+                    parsableByteArray.reset(i4);
+                    extractorInput.peekFully(parsableByteArray.data, 0, i4);
+                    int i5 = i4 / 4;
+                    int i6 = 0;
+                    while (true) {
+                        if (i6 >= i5) {
+                            break;
+                        }
+                        if (i6 == 1) {
+                            parsableByteArray.skipBytes(4);
+                        } else if (isCompatibleBrand(parsableByteArray.readInt())) {
+                            z4 = true;
+                            break;
+                        }
+                        i6++;
+                    }
+                    if (!z4) {
+                        return false;
+                    }
+                } else if (i4 != 0) {
+                    extractorInput.advancePeekPosition(i4);
+                }
+                j = -1;
+            }
+        }
+        z2 = true;
+        z3 = false;
+        if (z4 && z == z3) {
+            return z2;
+        }
+        return false;
+    }
+
+    private static boolean isCompatibleBrand(int i) {
+        if ((i >>> 8) == Util.getIntegerCodeForString("3gp")) {
+            return true;
+        }
+        for (int i2 : COMPATIBLE_BRANDS) {
+            if (i2 == i) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private Sniffer() {
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/Track.java

@@ -0,0 +1,55 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class Track {
+    public static final int TRANSFORMATION_CEA608_CDAT = 1;
+    public static final int TRANSFORMATION_NONE = 0;
+    public final long durationUs;
+
+    @Nullable
+    public final long[] editListDurations;
+
+    @Nullable
+    public final long[] editListMediaTimes;
+    public final Format format;
+    public final int id;
+    public final long movieTimescale;
+    public final int nalUnitLengthFieldLength;
+
+    @Nullable
+    private final TrackEncryptionBox[] sampleDescriptionEncryptionBoxes;
+    public final int sampleTransformation;
+    public final long timescale;
+    public final int type;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Transformation {
+    }
+
+    public Track(int i, int i2, long j, long j2, long j3, Format format, int i3, @Nullable TrackEncryptionBox[] trackEncryptionBoxArr, int i4, @Nullable long[] jArr, @Nullable long[] jArr2) {
+        this.id = i;
+        this.type = i2;
+        this.timescale = j;
+        this.movieTimescale = j2;
+        this.durationUs = j3;
+        this.format = format;
+        this.sampleTransformation = i3;
+        this.sampleDescriptionEncryptionBoxes = trackEncryptionBoxArr;
+        this.nalUnitLengthFieldLength = i4;
+        this.editListDurations = jArr;
+        this.editListMediaTimes = jArr2;
+    }
+
+    public final TrackEncryptionBox getSampleDescriptionEncryptionBox(int i) {
+        TrackEncryptionBox[] trackEncryptionBoxArr = this.sampleDescriptionEncryptionBoxes;
+        if (trackEncryptionBoxArr == null) {
+            return null;
+        }
+        return trackEncryptionBoxArr[i];
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/TrackEncryptionBox.java

@@ -0,0 +1,72 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public final class TrackEncryptionBox {
+    private static final String TAG = "TrackEncryptionBox";
+    public final TrackOutput.CryptoData cryptoData;
+    public final byte[] defaultInitializationVector;
+    public final int initializationVectorSize;
+    public final boolean isEncrypted;
+
+    @Nullable
+    public final String schemeType;
+
+    public TrackEncryptionBox(boolean z, @Nullable String str, int i, byte[] bArr, int i2, int i3, @Nullable byte[] bArr2) {
+        Assertions.checkArgument((bArr2 == null) ^ (i == 0));
+        this.isEncrypted = z;
+        this.schemeType = str;
+        this.initializationVectorSize = i;
+        this.defaultInitializationVector = bArr2;
+        this.cryptoData = new TrackOutput.CryptoData(schemeToCryptoMode(str), bArr, i2, i3);
+    }
+
+    /* JADX WARN: Failed to restore switch over string. Please report as a decompilation issue */
+    private static int schemeToCryptoMode(@Nullable String str) {
+        if (str == null) {
+            return 1;
+        }
+        char c = 65535;
+        switch (str.hashCode()) {
+            case 3046605:
+                if (str.equals(C.CENC_TYPE_cbc1)) {
+                    c = 0;
+                    break;
+                }
+                break;
+            case 3046671:
+                if (str.equals(C.CENC_TYPE_cbcs)) {
+                    c = 1;
+                    break;
+                }
+                break;
+            case 3049879:
+                if (str.equals(C.CENC_TYPE_cenc)) {
+                    c = 2;
+                    break;
+                }
+                break;
+            case 3049895:
+                if (str.equals(C.CENC_TYPE_cens)) {
+                    c = 3;
+                    break;
+                }
+                break;
+        }
+        switch (c) {
+            case 0:
+            case 1:
+                return 2;
+            default:
+                Log.w(TAG, "Unsupported protection scheme type '" + str + "'. Assuming AES-CTR crypto mode.");
+            case 2:
+            case 3:
+                return 1;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/TrackFragment.java

@@ -0,0 +1,81 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+final class TrackFragment {
+    public long atomPosition;
+    public long auxiliaryDataPosition;
+    public long dataPosition;
+    public boolean definesEncryptionData;
+    public DefaultSampleValues header;
+    public long nextFragmentDecodeTime;
+    public int[] sampleCompositionTimeOffsetTable;
+    public int sampleCount;
+    public long[] sampleDecodingTimeTable;
+    public ParsableByteArray sampleEncryptionData;
+    public int sampleEncryptionDataLength;
+    public boolean sampleEncryptionDataNeedsFill;
+    public boolean[] sampleHasSubsampleEncryptionTable;
+    public boolean[] sampleIsSyncFrameTable;
+    public int[] sampleSizeTable;
+    public TrackEncryptionBox trackEncryptionBox;
+    public int trunCount;
+    public long[] trunDataPosition;
+    public int[] trunLength;
+
+    public final void reset() {
+        this.trunCount = 0;
+        this.nextFragmentDecodeTime = 0L;
+        this.definesEncryptionData = false;
+        this.sampleEncryptionDataNeedsFill = false;
+        this.trackEncryptionBox = null;
+    }
+
+    public final void initTables(int i, int i2) {
+        this.trunCount = i;
+        this.sampleCount = i2;
+        int[] iArr = this.trunLength;
+        if (iArr == null || iArr.length < i) {
+            this.trunDataPosition = new long[i];
+            this.trunLength = new int[i];
+        }
+        int[] iArr2 = this.sampleSizeTable;
+        if (iArr2 == null || iArr2.length < i2) {
+            int i3 = (i2 * 125) / 100;
+            this.sampleSizeTable = new int[i3];
+            this.sampleCompositionTimeOffsetTable = new int[i3];
+            this.sampleDecodingTimeTable = new long[i3];
+            this.sampleIsSyncFrameTable = new boolean[i3];
+            this.sampleHasSubsampleEncryptionTable = new boolean[i3];
+        }
+    }
+
+    public final void initEncryptionData(int i) {
+        ParsableByteArray parsableByteArray = this.sampleEncryptionData;
+        if (parsableByteArray == null || parsableByteArray.limit() < i) {
+            this.sampleEncryptionData = new ParsableByteArray(i);
+        }
+        this.sampleEncryptionDataLength = i;
+        this.definesEncryptionData = true;
+        this.sampleEncryptionDataNeedsFill = true;
+    }
+
+    public final void fillEncryptionData(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        extractorInput.readFully(this.sampleEncryptionData.data, 0, this.sampleEncryptionDataLength);
+        this.sampleEncryptionData.setPosition(0);
+        this.sampleEncryptionDataNeedsFill = false;
+    }
+
+    public final void fillEncryptionData(ParsableByteArray parsableByteArray) {
+        parsableByteArray.readBytes(this.sampleEncryptionData.data, 0, this.sampleEncryptionDataLength);
+        this.sampleEncryptionData.setPosition(0);
+        this.sampleEncryptionDataNeedsFill = false;
+    }
+
+    public final long getSamplePresentationTime(int i) {
+        return this.sampleDecodingTimeTable[i] + this.sampleCompositionTimeOffsetTable[i];
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/mp4/TrackSampleTable.java

@@ -0,0 +1,48 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4;
+
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+final class TrackSampleTable {
+    public final long durationUs;
+    public final int[] flags;
+    public final int maximumSize;
+    public final long[] offsets;
+    public final int sampleCount;
+    public final int[] sizes;
+    public final long[] timestampsUs;
+    public final Track track;
+
+    public TrackSampleTable(Track track, long[] jArr, int[] iArr, int i, long[] jArr2, int[] iArr2, long j) {
+        Assertions.checkArgument(iArr.length == jArr2.length);
+        Assertions.checkArgument(jArr.length == jArr2.length);
+        Assertions.checkArgument(iArr2.length == jArr2.length);
+        this.track = track;
+        this.offsets = jArr;
+        this.sizes = iArr;
+        this.maximumSize = i;
+        this.timestampsUs = jArr2;
+        this.flags = iArr2;
+        this.durationUs = j;
+        this.sampleCount = jArr.length;
+    }
+
+    public final int getIndexOfEarlierOrEqualSynchronizationSample(long j) {
+        for (int binarySearchFloor = Util.binarySearchFloor(this.timestampsUs, j, true, false); binarySearchFloor >= 0; binarySearchFloor--) {
+            if ((this.flags[binarySearchFloor] & 1) != 0) {
+                return binarySearchFloor;
+            }
+        }
+        return -1;
+    }
+
+    public final int getIndexOfLaterOrEqualSynchronizationSample(long j) {
+        for (int binarySearchCeil = Util.binarySearchCeil(this.timestampsUs, j, true, false); binarySearchCeil < this.timestampsUs.length; binarySearchCeil++) {
+            if ((this.flags[binarySearchCeil] & 1) != 0) {
+                return binarySearchCeil;
+            }
+        }
+        return -1;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/DefaultOggSeeker.java

@@ -0,0 +1,249 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import androidx.work.WorkRequest;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekPoint;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.io.EOFException;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+final class DefaultOggSeeker implements OggSeeker {
+    private static final int DEFAULT_OFFSET = 30000;
+    public static final int MATCH_BYTE_RANGE = 100000;
+    public static final int MATCH_RANGE = 72000;
+    private static final int STATE_IDLE = 3;
+    private static final int STATE_READ_LAST_PAGE = 1;
+    private static final int STATE_SEEK = 2;
+    private static final int STATE_SEEK_TO_END = 0;
+    private long end;
+    private long endGranule;
+    private final long endPosition;
+    private final OggPageHeader pageHeader = new OggPageHeader();
+    private long positionBeforeSeekToEnd;
+    private long start;
+    private long startGranule;
+    private final long startPosition;
+    private int state;
+    private final StreamReader streamReader;
+    private long targetGranule;
+    private long totalGranules;
+
+    public final void resetSeeking() {
+        this.start = this.startPosition;
+        this.end = this.endPosition;
+        this.startGranule = 0L;
+        this.endGranule = this.totalGranules;
+    }
+
+    public DefaultOggSeeker(long j, long j2, StreamReader streamReader, int i, long j3) {
+        Assertions.checkArgument(j >= 0 && j2 > j);
+        this.streamReader = streamReader;
+        this.startPosition = j;
+        this.endPosition = j2;
+        if (i != j2 - j) {
+            this.state = 0;
+        } else {
+            this.totalGranules = j3;
+            this.state = 3;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+    public final long read(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        int i = this.state;
+        if (i == 0) {
+            long position = extractorInput.getPosition();
+            this.positionBeforeSeekToEnd = position;
+            this.state = 1;
+            long j = this.endPosition - 65307;
+            if (j > position) {
+                return j;
+            }
+        } else if (i != 1) {
+            if (i != 2) {
+                if (i == 3) {
+                    return -1L;
+                }
+                throw new IllegalStateException();
+            }
+            long j2 = this.targetGranule;
+            long j3 = 0;
+            if (j2 != 0) {
+                long nextSeekPosition = getNextSeekPosition(j2, extractorInput);
+                if (nextSeekPosition >= 0) {
+                    return nextSeekPosition;
+                }
+                j3 = skipToPageOfGranule(extractorInput, this.targetGranule, -(nextSeekPosition + 2));
+            }
+            this.state = 3;
+            return -(j3 + 2);
+        }
+        this.totalGranules = readGranuleOfLastPage(extractorInput);
+        this.state = 3;
+        return this.positionBeforeSeekToEnd;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+    public final long startSeek(long j) {
+        int i = this.state;
+        Assertions.checkArgument(i == 3 || i == 2);
+        this.targetGranule = j != 0 ? this.streamReader.convertTimeToGranule(j) : 0L;
+        this.state = 2;
+        resetSeeking();
+        return this.targetGranule;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+    public final OggSeekMap createSeekMap() {
+        if (this.totalGranules != 0) {
+            return new OggSeekMap();
+        }
+        return null;
+    }
+
+    public final long getNextSeekPosition(long j, ExtractorInput extractorInput) throws IOException, InterruptedException {
+        if (this.start == this.end) {
+            return -(this.startGranule + 2);
+        }
+        long position = extractorInput.getPosition();
+        if (!skipToNextPage(extractorInput, this.end)) {
+            long j2 = this.start;
+            if (j2 != position) {
+                return j2;
+            }
+            throw new IOException("No ogg page can be found.");
+        }
+        this.pageHeader.populate(extractorInput, false);
+        extractorInput.resetPeekPosition();
+        OggPageHeader oggPageHeader = this.pageHeader;
+        long j3 = oggPageHeader.granulePosition;
+        long j4 = j - j3;
+        int i = oggPageHeader.headerSize + oggPageHeader.bodySize;
+        if (j4 >= 0 && j4 <= 72000) {
+            extractorInput.skipFully(i);
+            return -(this.pageHeader.granulePosition + 2);
+        }
+        if (j4 < 0) {
+            this.end = position;
+            this.endGranule = j3;
+        } else {
+            long j5 = i;
+            long position2 = extractorInput.getPosition() + j5;
+            this.start = position2;
+            this.startGranule = this.pageHeader.granulePosition;
+            if ((this.end - position2) + j5 < 100000) {
+                extractorInput.skipFully(i);
+                return -(this.startGranule + 2);
+            }
+        }
+        long j6 = this.end;
+        long j7 = this.start;
+        if (j6 - j7 < 100000) {
+            this.end = j7;
+            return j7;
+        }
+        long j8 = i;
+        long j9 = j4 > 0 ? 1L : 2L;
+        long position3 = extractorInput.getPosition();
+        long j10 = this.end;
+        long j11 = this.start;
+        return Math.min(Math.max((position3 - (j8 * j9)) + ((j4 * (j10 - j11)) / (this.endGranule - this.startGranule)), j11), this.end - 1);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public long getEstimatedPosition(long j, long j2, long j3) {
+        long j4 = this.endPosition;
+        long j5 = this.startPosition;
+        long j6 = j + (((j2 * (j4 - j5)) / this.totalGranules) - j3);
+        if (j6 >= j5) {
+            j5 = j6;
+        }
+        return j5 >= j4 ? j4 - 1 : j5;
+    }
+
+    public class OggSeekMap implements SeekMap {
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public boolean isSeekable() {
+            return true;
+        }
+
+        private OggSeekMap() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public SeekMap.SeekPoints getSeekPoints(long j) {
+            if (j != 0) {
+                long convertTimeToGranule = DefaultOggSeeker.this.streamReader.convertTimeToGranule(j);
+                DefaultOggSeeker defaultOggSeeker = DefaultOggSeeker.this;
+                return new SeekMap.SeekPoints(new SeekPoint(j, defaultOggSeeker.getEstimatedPosition(defaultOggSeeker.startPosition, convertTimeToGranule, WorkRequest.DEFAULT_BACKOFF_DELAY_MILLIS)));
+            }
+            return new SeekMap.SeekPoints(new SeekPoint(0L, DefaultOggSeeker.this.startPosition));
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public long getDurationUs() {
+            return DefaultOggSeeker.this.streamReader.convertGranuleToTime(DefaultOggSeeker.this.totalGranules);
+        }
+    }
+
+    public final void skipToNextPage(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        if (!skipToNextPage(extractorInput, this.endPosition)) {
+            throw new EOFException();
+        }
+    }
+
+    public final boolean skipToNextPage(ExtractorInput extractorInput, long j) throws IOException, InterruptedException {
+        int i;
+        long min = Math.min(j + 3, this.endPosition);
+        int i2 = 2048;
+        byte[] bArr = new byte[2048];
+        while (true) {
+            int i3 = 0;
+            if (extractorInput.getPosition() + i2 > min && (i2 = (int) (min - extractorInput.getPosition())) < 4) {
+                return false;
+            }
+            extractorInput.peekFully(bArr, 0, i2, false);
+            while (true) {
+                i = i2 - 3;
+                if (i3 < i) {
+                    if (bArr[i3] == 79 && bArr[i3 + 1] == 103 && bArr[i3 + 2] == 103 && bArr[i3 + 3] == 83) {
+                        extractorInput.skipFully(i3);
+                        return true;
+                    }
+                    i3++;
+                }
+            }
+            extractorInput.skipFully(i);
+        }
+    }
+
+    public final long readGranuleOfLastPage(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        skipToNextPage(extractorInput);
+        this.pageHeader.reset();
+        while ((this.pageHeader.type & 4) != 4 && extractorInput.getPosition() < this.endPosition) {
+            this.pageHeader.populate(extractorInput, false);
+            OggPageHeader oggPageHeader = this.pageHeader;
+            extractorInput.skipFully(oggPageHeader.headerSize + oggPageHeader.bodySize);
+        }
+        return this.pageHeader.granulePosition;
+    }
+
+    public final long skipToPageOfGranule(ExtractorInput extractorInput, long j, long j2) throws IOException, InterruptedException {
+        this.pageHeader.populate(extractorInput, false);
+        while (true) {
+            OggPageHeader oggPageHeader = this.pageHeader;
+            if (oggPageHeader.granulePosition < j) {
+                extractorInput.skipFully(oggPageHeader.headerSize + oggPageHeader.bodySize);
+                OggPageHeader oggPageHeader2 = this.pageHeader;
+                long j3 = oggPageHeader2.granulePosition;
+                oggPageHeader2.populate(extractorInput, false);
+                j2 = j3;
+            } else {
+                extractorInput.resetPeekPosition();
+                return j2;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/FlacReader.java

@@ -0,0 +1,195 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekPoint;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.FlacStreamInfo;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import kotlin.jvm.internal.ByteCompanionObject;
+
+/* loaded from: classes4.dex */
+final class FlacReader extends StreamReader {
+    private static final byte AUDIO_PACKET_TYPE = -1;
+    private static final int FRAME_HEADER_SAMPLE_NUMBER_OFFSET = 4;
+    private static final byte SEEKTABLE_PACKET_TYPE = 3;
+    private FlacOggSeeker flacOggSeeker;
+    private FlacStreamInfo streamInfo;
+
+    public static boolean verifyBitstreamType(ParsableByteArray parsableByteArray) {
+        return parsableByteArray.bytesLeft() >= 5 && parsableByteArray.readUnsignedByte() == 127 && parsableByteArray.readUnsignedInt() == 1179402563;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final void reset(boolean z) {
+        super.reset(z);
+        if (z) {
+            this.streamInfo = null;
+            this.flacOggSeeker = null;
+        }
+    }
+
+    private static boolean isAudioPacket(byte[] bArr) {
+        return bArr[0] == -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final long preparePayload(ParsableByteArray parsableByteArray) {
+        if (isAudioPacket(parsableByteArray.data)) {
+            return getFlacFrameBlockSize(parsableByteArray);
+        }
+        return -1L;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final boolean readHeaders(ParsableByteArray parsableByteArray, long j, StreamReader.SetupData setupData) throws IOException, InterruptedException {
+        byte[] bArr = parsableByteArray.data;
+        if (this.streamInfo == null) {
+            this.streamInfo = new FlacStreamInfo(bArr, 17);
+            byte[] copyOfRange = Arrays.copyOfRange(bArr, 9, parsableByteArray.limit());
+            copyOfRange[4] = ByteCompanionObject.MIN_VALUE;
+            List singletonList = Collections.singletonList(copyOfRange);
+            int bitRate = this.streamInfo.bitRate();
+            FlacStreamInfo flacStreamInfo = this.streamInfo;
+            setupData.format = Format.createAudioSampleFormat(null, MimeTypes.AUDIO_FLAC, null, -1, bitRate, flacStreamInfo.channels, flacStreamInfo.sampleRate, singletonList, null, 0, null);
+            return true;
+        }
+        if ((bArr[0] & Byte.MAX_VALUE) == 3) {
+            FlacOggSeeker flacOggSeeker = new FlacOggSeeker();
+            this.flacOggSeeker = flacOggSeeker;
+            flacOggSeeker.parseSeekTable(parsableByteArray);
+            return true;
+        }
+        if (!isAudioPacket(bArr)) {
+            return true;
+        }
+        FlacOggSeeker flacOggSeeker2 = this.flacOggSeeker;
+        if (flacOggSeeker2 != null) {
+            flacOggSeeker2.setFirstFrameOffset(j);
+            setupData.oggSeeker = this.flacOggSeeker;
+        }
+        return false;
+    }
+
+    private int getFlacFrameBlockSize(ParsableByteArray parsableByteArray) {
+        int i;
+        int i2;
+        int i3 = (parsableByteArray.data[2] & AUDIO_PACKET_TYPE) >> 4;
+        switch (i3) {
+            case 1:
+                return PsExtractor.AUDIO_STREAM;
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+                i = 576;
+                i2 = i3 - 2;
+                break;
+            case 6:
+            case 7:
+                parsableByteArray.skipBytes(4);
+                parsableByteArray.readUtf8EncodedLong();
+                int readUnsignedByte = i3 == 6 ? parsableByteArray.readUnsignedByte() : parsableByteArray.readUnsignedShort();
+                parsableByteArray.setPosition(0);
+                return readUnsignedByte + 1;
+            case 8:
+            case 9:
+            case 10:
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 15:
+                i2 = i3 - 8;
+                i = 256;
+                break;
+            default:
+                return -1;
+        }
+        return i << i2;
+    }
+
+    public class FlacOggSeeker implements SeekMap, OggSeeker {
+        private static final int METADATA_LENGTH_OFFSET = 1;
+        private static final int SEEK_POINT_SIZE = 18;
+        private long firstFrameOffset = -1;
+        private long pendingSeekGranule = -1;
+        private long[] seekPointGranules;
+        private long[] seekPointOffsets;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+        public SeekMap createSeekMap() {
+            return this;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public boolean isSeekable() {
+            return true;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+        public long read(ExtractorInput extractorInput) throws IOException, InterruptedException {
+            long j = this.pendingSeekGranule;
+            if (j < 0) {
+                return -1L;
+            }
+            long j2 = -(j + 2);
+            this.pendingSeekGranule = -1L;
+            return j2;
+        }
+
+        public void setFirstFrameOffset(long j) {
+            this.firstFrameOffset = j;
+        }
+
+        public FlacOggSeeker() {
+        }
+
+        public void parseSeekTable(ParsableByteArray parsableByteArray) {
+            parsableByteArray.skipBytes(1);
+            int readUnsignedInt24 = parsableByteArray.readUnsignedInt24() / 18;
+            this.seekPointGranules = new long[readUnsignedInt24];
+            this.seekPointOffsets = new long[readUnsignedInt24];
+            for (int i = 0; i < readUnsignedInt24; i++) {
+                this.seekPointGranules[i] = parsableByteArray.readLong();
+                this.seekPointOffsets[i] = parsableByteArray.readLong();
+                parsableByteArray.skipBytes(2);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+        public long startSeek(long j) {
+            long convertTimeToGranule = FlacReader.this.convertTimeToGranule(j);
+            this.pendingSeekGranule = this.seekPointGranules[Util.binarySearchFloor(this.seekPointGranules, convertTimeToGranule, true, true)];
+            return convertTimeToGranule;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public SeekMap.SeekPoints getSeekPoints(long j) {
+            int binarySearchFloor = Util.binarySearchFloor(this.seekPointGranules, FlacReader.this.convertTimeToGranule(j), true, true);
+            long convertGranuleToTime = FlacReader.this.convertGranuleToTime(this.seekPointGranules[binarySearchFloor]);
+            SeekPoint seekPoint = new SeekPoint(convertGranuleToTime, this.firstFrameOffset + this.seekPointOffsets[binarySearchFloor]);
+            if (convertGranuleToTime < j) {
+                long[] jArr = this.seekPointGranules;
+                if (binarySearchFloor != jArr.length - 1) {
+                    int i = binarySearchFloor + 1;
+                    return new SeekMap.SeekPoints(seekPoint, new SeekPoint(FlacReader.this.convertGranuleToTime(jArr[i]), this.firstFrameOffset + this.seekPointOffsets[i]));
+                }
+            }
+            return new SeekMap.SeekPoints(seekPoint);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+        public long getDurationUs() {
+            return FlacReader.this.streamInfo.durationUs();
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/OggExtractor.java

@@ -0,0 +1,91 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public class OggExtractor implements Extractor {
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggExtractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new OggExtractor()};
+        }
+    };
+    private static final int MAX_VERIFICATION_BYTES = 8;
+    private ExtractorOutput output;
+    private StreamReader streamReader;
+    private boolean streamReaderInitialized;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public void init(ExtractorOutput extractorOutput) {
+        this.output = extractorOutput;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public void release() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        try {
+            return sniffInternal(extractorInput);
+        } catch (ParserException unused) {
+            return false;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public void seek(long j, long j2) {
+        StreamReader streamReader = this.streamReader;
+        if (streamReader != null) {
+            streamReader.seek(j, j2);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        if (this.streamReader == null) {
+            if (!sniffInternal(extractorInput)) {
+                throw new ParserException("Failed to determine bitstream type");
+            }
+            extractorInput.resetPeekPosition();
+        }
+        if (!this.streamReaderInitialized) {
+            TrackOutput track = this.output.track(0, 1);
+            this.output.endTracks();
+            this.streamReader.init(this.output, track);
+            this.streamReaderInitialized = true;
+        }
+        return this.streamReader.read(extractorInput, positionHolder);
+    }
+
+    private boolean sniffInternal(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        OggPageHeader oggPageHeader = new OggPageHeader();
+        if (oggPageHeader.populate(extractorInput, true) && (oggPageHeader.type & 2) == 2) {
+            int min = Math.min(oggPageHeader.bodySize, 8);
+            ParsableByteArray parsableByteArray = new ParsableByteArray(min);
+            extractorInput.peekFully(parsableByteArray.data, 0, min);
+            if (FlacReader.verifyBitstreamType(resetPosition(parsableByteArray))) {
+                this.streamReader = new FlacReader();
+            } else if (VorbisReader.verifyBitstreamType(resetPosition(parsableByteArray))) {
+                this.streamReader = new VorbisReader();
+            } else if (OpusReader.verifyBitstreamType(resetPosition(parsableByteArray))) {
+                this.streamReader = new OpusReader();
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private static ParsableByteArray resetPosition(ParsableByteArray parsableByteArray) {
+        parsableByteArray.setPosition(0);
+        return parsableByteArray;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/OggPacket.java

@@ -0,0 +1,103 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.IOException;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+final class OggPacket {
+    private boolean populated;
+    private int segmentCount;
+    private final OggPageHeader pageHeader = new OggPageHeader();
+    private final ParsableByteArray packetArray = new ParsableByteArray(new byte[OggPageHeader.MAX_PAGE_PAYLOAD], 0);
+    private int currentSegmentIndex = -1;
+
+    public final OggPageHeader getPageHeader() {
+        return this.pageHeader;
+    }
+
+    public final ParsableByteArray getPayload() {
+        return this.packetArray;
+    }
+
+    public final void reset() {
+        this.pageHeader.reset();
+        this.packetArray.reset();
+        this.currentSegmentIndex = -1;
+        this.populated = false;
+    }
+
+    public final boolean populate(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        int i;
+        Assertions.checkState(extractorInput != null);
+        if (this.populated) {
+            this.populated = false;
+            this.packetArray.reset();
+        }
+        while (!this.populated) {
+            if (this.currentSegmentIndex < 0) {
+                if (!this.pageHeader.populate(extractorInput, true)) {
+                    return false;
+                }
+                OggPageHeader oggPageHeader = this.pageHeader;
+                int i2 = oggPageHeader.headerSize;
+                if ((oggPageHeader.type & 1) == 1 && this.packetArray.limit() == 0) {
+                    i2 += calculatePacketSize(0);
+                    i = this.segmentCount;
+                } else {
+                    i = 0;
+                }
+                extractorInput.skipFully(i2);
+                this.currentSegmentIndex = i;
+            }
+            int calculatePacketSize = calculatePacketSize(this.currentSegmentIndex);
+            int i3 = this.currentSegmentIndex + this.segmentCount;
+            if (calculatePacketSize > 0) {
+                if (this.packetArray.capacity() < this.packetArray.limit() + calculatePacketSize) {
+                    ParsableByteArray parsableByteArray = this.packetArray;
+                    parsableByteArray.data = Arrays.copyOf(parsableByteArray.data, parsableByteArray.limit() + calculatePacketSize);
+                }
+                ParsableByteArray parsableByteArray2 = this.packetArray;
+                extractorInput.readFully(parsableByteArray2.data, parsableByteArray2.limit(), calculatePacketSize);
+                ParsableByteArray parsableByteArray3 = this.packetArray;
+                parsableByteArray3.setLimit(parsableByteArray3.limit() + calculatePacketSize);
+                this.populated = this.pageHeader.laces[i3 + (-1)] != 255;
+            }
+            if (i3 == this.pageHeader.pageSegmentCount) {
+                i3 = -1;
+            }
+            this.currentSegmentIndex = i3;
+        }
+        return true;
+    }
+
+    public final void trimPayload() {
+        ParsableByteArray parsableByteArray = this.packetArray;
+        byte[] bArr = parsableByteArray.data;
+        if (bArr.length == 65025) {
+            return;
+        }
+        parsableByteArray.data = Arrays.copyOf(bArr, Math.max(OggPageHeader.MAX_PAGE_PAYLOAD, parsableByteArray.limit()));
+    }
+
+    private int calculatePacketSize(int i) {
+        int i2;
+        int i3 = 0;
+        this.segmentCount = 0;
+        do {
+            int i4 = this.segmentCount;
+            int i5 = i + i4;
+            OggPageHeader oggPageHeader = this.pageHeader;
+            if (i5 >= oggPageHeader.pageSegmentCount) {
+                break;
+            }
+            int[] iArr = oggPageHeader.laces;
+            this.segmentCount = i4 + 1;
+            i2 = iArr[i4 + i];
+            i3 += i2;
+        } while (i2 == 255);
+        return i3;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/OggPageHeader.java

@@ -0,0 +1,80 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.EOFException;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+final class OggPageHeader {
+    public static final int EMPTY_PAGE_HEADER_SIZE = 27;
+    public static final int MAX_PAGE_PAYLOAD = 65025;
+    public static final int MAX_PAGE_SIZE = 65307;
+    public static final int MAX_SEGMENT_COUNT = 255;
+    private static final int TYPE_OGGS = Util.getIntegerCodeForString("OggS");
+    public int bodySize;
+    public long granulePosition;
+    public int headerSize;
+    public long pageChecksum;
+    public int pageSegmentCount;
+    public long pageSequenceNumber;
+    public int revision;
+    public long streamSerialNumber;
+    public int type;
+    public final int[] laces = new int[255];
+    private final ParsableByteArray scratch = new ParsableByteArray(255);
+
+    public final void reset() {
+        this.revision = 0;
+        this.type = 0;
+        this.granulePosition = 0L;
+        this.streamSerialNumber = 0L;
+        this.pageSequenceNumber = 0L;
+        this.pageChecksum = 0L;
+        this.pageSegmentCount = 0;
+        this.headerSize = 0;
+        this.bodySize = 0;
+    }
+
+    public final boolean populate(ExtractorInput extractorInput, boolean z) throws IOException, InterruptedException {
+        this.scratch.reset();
+        reset();
+        if ((extractorInput.getLength() != -1 && extractorInput.getLength() - extractorInput.getPeekPosition() < 27) || !extractorInput.peekFully(this.scratch.data, 0, 27, true)) {
+            if (z) {
+                return false;
+            }
+            throw new EOFException();
+        }
+        if (this.scratch.readUnsignedInt() != TYPE_OGGS) {
+            if (z) {
+                return false;
+            }
+            throw new ParserException("expected OggS capture pattern at begin of page");
+        }
+        int readUnsignedByte = this.scratch.readUnsignedByte();
+        this.revision = readUnsignedByte;
+        if (readUnsignedByte != 0) {
+            if (z) {
+                return false;
+            }
+            throw new ParserException("unsupported bit stream revision");
+        }
+        this.type = this.scratch.readUnsignedByte();
+        this.granulePosition = this.scratch.readLittleEndianLong();
+        this.streamSerialNumber = this.scratch.readLittleEndianUnsignedInt();
+        this.pageSequenceNumber = this.scratch.readLittleEndianUnsignedInt();
+        this.pageChecksum = this.scratch.readLittleEndianUnsignedInt();
+        int readUnsignedByte2 = this.scratch.readUnsignedByte();
+        this.pageSegmentCount = readUnsignedByte2;
+        this.headerSize = readUnsignedByte2 + 27;
+        this.scratch.reset();
+        extractorInput.peekFully(this.scratch.data, 0, this.pageSegmentCount);
+        for (int i = 0; i < this.pageSegmentCount; i++) {
+            this.laces[i] = this.scratch.readUnsignedByte();
+            this.bodySize += this.laces[i];
+        }
+        return true;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/OggSeeker.java

@@ -0,0 +1,14 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+interface OggSeeker {
+    SeekMap createSeekMap();
+
+    long read(ExtractorInput extractorInput) throws IOException, InterruptedException;
+
+    long startSeek(long j);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/OpusReader.java

@@ -0,0 +1,88 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.newreward.function.common.MBridgeCommon;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+final class OpusReader extends StreamReader {
+    private static final int DEFAULT_SEEK_PRE_ROLL_SAMPLES = 3840;
+    private static final int OPUS_CODE = Util.getIntegerCodeForString("Opus");
+    private static final byte[] OPUS_SIGNATURE = {79, 112, 117, 115, 72, 101, 97, 100};
+    private static final int SAMPLE_RATE = 48000;
+    private boolean headerRead;
+
+    public static boolean verifyBitstreamType(ParsableByteArray parsableByteArray) {
+        int bytesLeft = parsableByteArray.bytesLeft();
+        byte[] bArr = OPUS_SIGNATURE;
+        if (bytesLeft < bArr.length) {
+            return false;
+        }
+        byte[] bArr2 = new byte[bArr.length];
+        parsableByteArray.readBytes(bArr2, 0, bArr.length);
+        return Arrays.equals(bArr2, bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final void reset(boolean z) {
+        super.reset(z);
+        if (z) {
+            this.headerRead = false;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final long preparePayload(ParsableByteArray parsableByteArray) {
+        return convertTimeToGranule(getPacketDurationUs(parsableByteArray.data));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final boolean readHeaders(ParsableByteArray parsableByteArray, long j, StreamReader.SetupData setupData) throws IOException, InterruptedException {
+        if (!this.headerRead) {
+            byte[] copyOf = Arrays.copyOf(parsableByteArray.data, parsableByteArray.limit());
+            int i = copyOf[9] & 255;
+            int i2 = ((copyOf[11] & 255) << 8) | (copyOf[10] & 255);
+            ArrayList arrayList = new ArrayList(3);
+            arrayList.add(copyOf);
+            putNativeOrderLong(arrayList, i2);
+            putNativeOrderLong(arrayList, DEFAULT_SEEK_PRE_ROLL_SAMPLES);
+            setupData.format = Format.createAudioSampleFormat(null, MimeTypes.AUDIO_OPUS, null, -1, -1, i, SAMPLE_RATE, arrayList, null, 0, null);
+            this.headerRead = true;
+            return true;
+        }
+        boolean z = parsableByteArray.readInt() == OPUS_CODE;
+        parsableByteArray.setPosition(0);
+        return z;
+    }
+
+    private void putNativeOrderLong(List<byte[]> list, int i) {
+        list.add(ByteBuffer.allocate(8).order(ByteOrder.nativeOrder()).putLong((i * C.NANOS_PER_SECOND) / 48000).array());
+    }
+
+    private long getPacketDurationUs(byte[] bArr) {
+        int i;
+        byte b = bArr[0];
+        int i2 = b & 255;
+        int i3 = b & 3;
+        if (i3 != 0) {
+            i = 2;
+            if (i3 != 1 && i3 != 2) {
+                i = bArr[1] & 63;
+            }
+        } else {
+            i = 1;
+        }
+        int i4 = i2 >> 3;
+        return i * (i4 >= 16 ? 2500 << r0 : i4 >= 12 ? 10000 << (i4 & 1) : (i4 & 3) == 3 ? MBridgeCommon.DEFAULT_LOAD_TIMEOUT : 10000 << r0);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/StreamReader.java

@@ -0,0 +1,183 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+abstract class StreamReader {
+    private static final int STATE_END_OF_INPUT = 3;
+    private static final int STATE_READ_HEADERS = 0;
+    private static final int STATE_READ_PAYLOAD = 2;
+    private static final int STATE_SKIP_HEADERS = 1;
+    private long currentGranule;
+    private ExtractorOutput extractorOutput;
+    private boolean formatSet;
+    private long lengthOfReadPacket;
+    private final OggPacket oggPacket = new OggPacket();
+    private OggSeeker oggSeeker;
+    private long payloadStartPosition;
+    private int sampleRate;
+    private boolean seekMapSet;
+    private SetupData setupData;
+    private int state;
+    private long targetGranule;
+    private TrackOutput trackOutput;
+
+    public static class SetupData {
+        Format format;
+        OggSeeker oggSeeker;
+    }
+
+    public void onSeekEnd(long j) {
+        this.currentGranule = j;
+    }
+
+    public abstract long preparePayload(ParsableByteArray parsableByteArray);
+
+    public abstract boolean readHeaders(ParsableByteArray parsableByteArray, long j, SetupData setupData) throws IOException, InterruptedException;
+
+    public void init(ExtractorOutput extractorOutput, TrackOutput trackOutput) {
+        this.extractorOutput = extractorOutput;
+        this.trackOutput = trackOutput;
+        reset(true);
+    }
+
+    public void reset(boolean z) {
+        if (z) {
+            this.setupData = new SetupData();
+            this.payloadStartPosition = 0L;
+            this.state = 0;
+        } else {
+            this.state = 1;
+        }
+        this.targetGranule = -1L;
+        this.currentGranule = 0L;
+    }
+
+    public final void seek(long j, long j2) {
+        this.oggPacket.reset();
+        if (j == 0) {
+            reset(!this.seekMapSet);
+        } else if (this.state != 0) {
+            this.targetGranule = this.oggSeeker.startSeek(j2);
+            this.state = 2;
+        }
+    }
+
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        int i = this.state;
+        if (i == 0) {
+            return readHeaders(extractorInput);
+        }
+        if (i != 1) {
+            if (i == 2) {
+                return readPayload(extractorInput, positionHolder);
+            }
+            throw new IllegalStateException();
+        }
+        extractorInput.skipFully((int) this.payloadStartPosition);
+        this.state = 2;
+        return 0;
+    }
+
+    private int readHeaders(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        while (this.oggPacket.populate(extractorInput)) {
+            this.lengthOfReadPacket = extractorInput.getPosition() - this.payloadStartPosition;
+            boolean readHeaders = readHeaders(this.oggPacket.getPayload(), this.payloadStartPosition, this.setupData);
+            if (readHeaders) {
+                this.payloadStartPosition = extractorInput.getPosition();
+            }
+            if (!readHeaders) {
+                Format format = this.setupData.format;
+                this.sampleRate = format.sampleRate;
+                if (!this.formatSet) {
+                    this.trackOutput.format(format);
+                    this.formatSet = true;
+                }
+                OggSeeker oggSeeker = this.setupData.oggSeeker;
+                if (oggSeeker != null) {
+                    this.oggSeeker = oggSeeker;
+                } else if (extractorInput.getLength() == -1) {
+                    this.oggSeeker = new UnseekableOggSeeker();
+                } else {
+                    OggPageHeader pageHeader = this.oggPacket.getPageHeader();
+                    this.oggSeeker = new DefaultOggSeeker(this.payloadStartPosition, extractorInput.getLength(), this, pageHeader.headerSize + pageHeader.bodySize, pageHeader.granulePosition);
+                }
+                this.setupData = null;
+                this.state = 2;
+                this.oggPacket.trimPayload();
+                return 0;
+            }
+        }
+        this.state = 3;
+        return -1;
+    }
+
+    private int readPayload(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        long read = this.oggSeeker.read(extractorInput);
+        if (read >= 0) {
+            positionHolder.position = read;
+            return 1;
+        }
+        if (read < -1) {
+            onSeekEnd(-(read + 2));
+        }
+        if (!this.seekMapSet) {
+            this.extractorOutput.seekMap(this.oggSeeker.createSeekMap());
+            this.seekMapSet = true;
+        }
+        if (this.lengthOfReadPacket <= 0 && !this.oggPacket.populate(extractorInput)) {
+            this.state = 3;
+            return -1;
+        }
+        this.lengthOfReadPacket = 0L;
+        ParsableByteArray payload = this.oggPacket.getPayload();
+        long preparePayload = preparePayload(payload);
+        if (preparePayload >= 0) {
+            long j = this.currentGranule;
+            if (j + preparePayload >= this.targetGranule) {
+                long convertGranuleToTime = convertGranuleToTime(j);
+                this.trackOutput.sampleData(payload, payload.limit());
+                this.trackOutput.sampleMetadata(convertGranuleToTime, 1, payload.limit(), 0, null);
+                this.targetGranule = -1L;
+            }
+        }
+        this.currentGranule += preparePayload;
+        return 0;
+    }
+
+    public long convertGranuleToTime(long j) {
+        return (j * 1000000) / this.sampleRate;
+    }
+
+    public long convertTimeToGranule(long j) {
+        return (this.sampleRate * j) / 1000000;
+    }
+
+    public static final class UnseekableOggSeeker implements OggSeeker {
+        private UnseekableOggSeeker() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+        public final long read(ExtractorInput extractorInput) throws IOException, InterruptedException {
+            return -1L;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+        public final long startSeek(long j) {
+            return 0L;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggSeeker
+        public final SeekMap createSeekMap() {
+            return new SeekMap.Unseekable(C.TIME_UNSET);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/VorbisBitArray.java

@@ -0,0 +1,76 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+final class VorbisBitArray {
+    private int bitOffset;
+    private final int byteLimit;
+    private int byteOffset;
+    private final byte[] data;
+
+    public final int bitsLeft() {
+        return ((this.byteLimit - this.byteOffset) * 8) - this.bitOffset;
+    }
+
+    public final int getPosition() {
+        return (this.byteOffset * 8) + this.bitOffset;
+    }
+
+    public final void reset() {
+        this.byteOffset = 0;
+        this.bitOffset = 0;
+    }
+
+    public VorbisBitArray(byte[] bArr) {
+        this.data = bArr;
+        this.byteLimit = bArr.length;
+    }
+
+    public final boolean readBit() {
+        boolean z = (((this.data[this.byteOffset] & 255) >> this.bitOffset) & 1) == 1;
+        skipBits(1);
+        return z;
+    }
+
+    public final int readBits(int i) {
+        int i2 = this.byteOffset;
+        int min = Math.min(i, 8 - this.bitOffset);
+        int i3 = i2 + 1;
+        int i4 = ((this.data[i2] & 255) >> this.bitOffset) & (255 >> (8 - min));
+        while (min < i) {
+            i4 |= (this.data[i3] & 255) << min;
+            min += 8;
+            i3++;
+        }
+        int i5 = i4 & ((-1) >>> (32 - i));
+        skipBits(i);
+        return i5;
+    }
+
+    public final void skipBits(int i) {
+        int i2 = i / 8;
+        int i3 = this.byteOffset + i2;
+        this.byteOffset = i3;
+        int i4 = this.bitOffset + (i - (i2 * 8));
+        this.bitOffset = i4;
+        if (i4 > 7) {
+            this.byteOffset = i3 + 1;
+            this.bitOffset = i4 - 8;
+        }
+        assertValidOffset();
+    }
+
+    public final void setPosition(int i) {
+        int i2 = i / 8;
+        this.byteOffset = i2;
+        this.bitOffset = i - (i2 * 8);
+        assertValidOffset();
+    }
+
+    private void assertValidOffset() {
+        int i;
+        int i2 = this.byteOffset;
+        Assertions.checkState(i2 >= 0 && (i2 < (i = this.byteLimit) || (i2 == i && this.bitOffset == 0)));
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/VorbisReader.java

@@ -0,0 +1,128 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.VorbisUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.IOException;
+import java.util.ArrayList;
+
+/* loaded from: classes4.dex */
+final class VorbisReader extends StreamReader {
+    private VorbisUtil.CommentHeader commentHeader;
+    private int previousPacketBlockSize;
+    private boolean seenFirstAudioPacket;
+    private VorbisUtil.VorbisIdHeader vorbisIdHeader;
+    private VorbisSetup vorbisSetup;
+
+    public static int readBits(byte b, int i, int i2) {
+        return (b >> i2) & (255 >>> (8 - i));
+    }
+
+    public static boolean verifyBitstreamType(ParsableByteArray parsableByteArray) {
+        try {
+            return VorbisUtil.verifyVorbisHeaderCapturePattern(1, parsableByteArray, true);
+        } catch (ParserException unused) {
+            return false;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final void reset(boolean z) {
+        super.reset(z);
+        if (z) {
+            this.vorbisSetup = null;
+            this.vorbisIdHeader = null;
+            this.commentHeader = null;
+        }
+        this.previousPacketBlockSize = 0;
+        this.seenFirstAudioPacket = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final void onSeekEnd(long j) {
+        super.onSeekEnd(j);
+        this.seenFirstAudioPacket = j != 0;
+        VorbisUtil.VorbisIdHeader vorbisIdHeader = this.vorbisIdHeader;
+        this.previousPacketBlockSize = vorbisIdHeader != null ? vorbisIdHeader.blockSize0 : 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final long preparePayload(ParsableByteArray parsableByteArray) {
+        byte b = parsableByteArray.data[0];
+        if ((b & 1) == 1) {
+            return -1L;
+        }
+        int decodeBlockSize = decodeBlockSize(b, this.vorbisSetup);
+        long j = this.seenFirstAudioPacket ? (this.previousPacketBlockSize + decodeBlockSize) / 4 : 0;
+        appendNumberOfSamples(parsableByteArray, j);
+        this.seenFirstAudioPacket = true;
+        this.previousPacketBlockSize = decodeBlockSize;
+        return j;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.StreamReader
+    public final boolean readHeaders(ParsableByteArray parsableByteArray, long j, StreamReader.SetupData setupData) throws IOException, InterruptedException {
+        if (this.vorbisSetup != null) {
+            return false;
+        }
+        VorbisSetup readSetupHeaders = readSetupHeaders(parsableByteArray);
+        this.vorbisSetup = readSetupHeaders;
+        if (readSetupHeaders == null) {
+            return true;
+        }
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(this.vorbisSetup.idHeader.data);
+        arrayList.add(this.vorbisSetup.setupHeaderData);
+        VorbisUtil.VorbisIdHeader vorbisIdHeader = this.vorbisSetup.idHeader;
+        setupData.format = Format.createAudioSampleFormat(null, MimeTypes.AUDIO_VORBIS, null, vorbisIdHeader.bitrateNominal, -1, vorbisIdHeader.channels, (int) vorbisIdHeader.sampleRate, arrayList, null, 0, null);
+        return true;
+    }
+
+    public final VorbisSetup readSetupHeaders(ParsableByteArray parsableByteArray) throws IOException {
+        if (this.vorbisIdHeader == null) {
+            this.vorbisIdHeader = VorbisUtil.readVorbisIdentificationHeader(parsableByteArray);
+            return null;
+        }
+        if (this.commentHeader == null) {
+            this.commentHeader = VorbisUtil.readVorbisCommentHeader(parsableByteArray);
+            return null;
+        }
+        byte[] bArr = new byte[parsableByteArray.limit()];
+        System.arraycopy(parsableByteArray.data, 0, bArr, 0, parsableByteArray.limit());
+        return new VorbisSetup(this.vorbisIdHeader, this.commentHeader, bArr, VorbisUtil.readVorbisModes(parsableByteArray, this.vorbisIdHeader.channels), VorbisUtil.iLog(r5.length - 1));
+    }
+
+    public static void appendNumberOfSamples(ParsableByteArray parsableByteArray, long j) {
+        parsableByteArray.setLimit(parsableByteArray.limit() + 4);
+        parsableByteArray.data[parsableByteArray.limit() - 4] = (byte) (j & 255);
+        parsableByteArray.data[parsableByteArray.limit() - 3] = (byte) ((j >>> 8) & 255);
+        parsableByteArray.data[parsableByteArray.limit() - 2] = (byte) ((j >>> 16) & 255);
+        parsableByteArray.data[parsableByteArray.limit() - 1] = (byte) ((j >>> 24) & 255);
+    }
+
+    private static int decodeBlockSize(byte b, VorbisSetup vorbisSetup) {
+        if (!vorbisSetup.modes[readBits(b, vorbisSetup.iLogModes, 1)].blockFlag) {
+            return vorbisSetup.idHeader.blockSize0;
+        }
+        return vorbisSetup.idHeader.blockSize1;
+    }
+
+    public static final class VorbisSetup {
+        public final VorbisUtil.CommentHeader commentHeader;
+        public final int iLogModes;
+        public final VorbisUtil.VorbisIdHeader idHeader;
+        public final VorbisUtil.Mode[] modes;
+        public final byte[] setupHeaderData;
+
+        public VorbisSetup(VorbisUtil.VorbisIdHeader vorbisIdHeader, VorbisUtil.CommentHeader commentHeader, byte[] bArr, VorbisUtil.Mode[] modeArr, int i) {
+            this.idHeader = vorbisIdHeader;
+            this.commentHeader = commentHeader;
+            this.setupHeaderData = bArr;
+            this.modes = modeArr;
+            this.iLogModes = i;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ogg/VorbisUtil.java

@@ -0,0 +1,347 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+final class VorbisUtil {
+    private static final String TAG = "VorbisUtil";
+
+    public static int iLog(int i) {
+        int i2 = 0;
+        while (i > 0) {
+            i2++;
+            i >>>= 1;
+        }
+        return i2;
+    }
+
+    public static VorbisIdHeader readVorbisIdentificationHeader(ParsableByteArray parsableByteArray) throws ParserException {
+        verifyVorbisHeaderCapturePattern(1, parsableByteArray, false);
+        long readLittleEndianUnsignedInt = parsableByteArray.readLittleEndianUnsignedInt();
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        long readLittleEndianUnsignedInt2 = parsableByteArray.readLittleEndianUnsignedInt();
+        int readLittleEndianInt = parsableByteArray.readLittleEndianInt();
+        int readLittleEndianInt2 = parsableByteArray.readLittleEndianInt();
+        int readLittleEndianInt3 = parsableByteArray.readLittleEndianInt();
+        int readUnsignedByte2 = parsableByteArray.readUnsignedByte();
+        return new VorbisIdHeader(readLittleEndianUnsignedInt, readUnsignedByte, readLittleEndianUnsignedInt2, readLittleEndianInt, readLittleEndianInt2, readLittleEndianInt3, (int) Math.pow(2.0d, readUnsignedByte2 & 15), (int) Math.pow(2.0d, (readUnsignedByte2 & PsExtractor.VIDEO_STREAM_MASK) >> 4), (parsableByteArray.readUnsignedByte() & 1) > 0, Arrays.copyOf(parsableByteArray.data, parsableByteArray.limit()));
+    }
+
+    public static CommentHeader readVorbisCommentHeader(ParsableByteArray parsableByteArray) throws ParserException {
+        verifyVorbisHeaderCapturePattern(3, parsableByteArray, false);
+        String readString = parsableByteArray.readString((int) parsableByteArray.readLittleEndianUnsignedInt());
+        int length = readString.length();
+        long readLittleEndianUnsignedInt = parsableByteArray.readLittleEndianUnsignedInt();
+        String[] strArr = new String[(int) readLittleEndianUnsignedInt];
+        int i = length + 15;
+        for (int i2 = 0; i2 < readLittleEndianUnsignedInt; i2++) {
+            String readString2 = parsableByteArray.readString((int) parsableByteArray.readLittleEndianUnsignedInt());
+            strArr[i2] = readString2;
+            i = i + 4 + readString2.length();
+        }
+        if ((parsableByteArray.readUnsignedByte() & 1) == 0) {
+            throw new ParserException("framing bit expected to be set");
+        }
+        return new CommentHeader(readString, strArr, i + 1);
+    }
+
+    public static boolean verifyVorbisHeaderCapturePattern(int i, ParsableByteArray parsableByteArray, boolean z) throws ParserException {
+        if (parsableByteArray.bytesLeft() < 7) {
+            if (z) {
+                return false;
+            }
+            throw new ParserException("too short header: " + parsableByteArray.bytesLeft());
+        }
+        if (parsableByteArray.readUnsignedByte() != i) {
+            if (z) {
+                return false;
+            }
+            throw new ParserException("expected header type " + Integer.toHexString(i));
+        }
+        if (parsableByteArray.readUnsignedByte() == 118 && parsableByteArray.readUnsignedByte() == 111 && parsableByteArray.readUnsignedByte() == 114 && parsableByteArray.readUnsignedByte() == 98 && parsableByteArray.readUnsignedByte() == 105 && parsableByteArray.readUnsignedByte() == 115) {
+            return true;
+        }
+        if (z) {
+            return false;
+        }
+        throw new ParserException("expected characters 'vorbis'");
+    }
+
+    public static Mode[] readVorbisModes(ParsableByteArray parsableByteArray, int i) throws ParserException {
+        verifyVorbisHeaderCapturePattern(5, parsableByteArray, false);
+        int readUnsignedByte = parsableByteArray.readUnsignedByte() + 1;
+        VorbisBitArray vorbisBitArray = new VorbisBitArray(parsableByteArray.data);
+        vorbisBitArray.skipBits(parsableByteArray.getPosition() * 8);
+        for (int i2 = 0; i2 < readUnsignedByte; i2++) {
+            readBook(vorbisBitArray);
+        }
+        int readBits = vorbisBitArray.readBits(6) + 1;
+        for (int i3 = 0; i3 < readBits; i3++) {
+            if (vorbisBitArray.readBits(16) != 0) {
+                throw new ParserException("placeholder of time domain transforms not zeroed out");
+            }
+        }
+        readFloors(vorbisBitArray);
+        readResidues(vorbisBitArray);
+        readMappings(i, vorbisBitArray);
+        Mode[] readModes = readModes(vorbisBitArray);
+        if (vorbisBitArray.readBit()) {
+            return readModes;
+        }
+        throw new ParserException("framing bit after modes not set as expected");
+    }
+
+    private static Mode[] readModes(VorbisBitArray vorbisBitArray) {
+        int readBits = vorbisBitArray.readBits(6) + 1;
+        Mode[] modeArr = new Mode[readBits];
+        for (int i = 0; i < readBits; i++) {
+            modeArr[i] = new Mode(vorbisBitArray.readBit(), vorbisBitArray.readBits(16), vorbisBitArray.readBits(16), vorbisBitArray.readBits(8));
+        }
+        return modeArr;
+    }
+
+    private static void readMappings(int i, VorbisBitArray vorbisBitArray) throws ParserException {
+        int readBits = vorbisBitArray.readBits(6) + 1;
+        for (int i2 = 0; i2 < readBits; i2++) {
+            int readBits2 = vorbisBitArray.readBits(16);
+            if (readBits2 == 0) {
+                int readBits3 = vorbisBitArray.readBit() ? vorbisBitArray.readBits(4) + 1 : 1;
+                if (vorbisBitArray.readBit()) {
+                    int readBits4 = vorbisBitArray.readBits(8) + 1;
+                    for (int i3 = 0; i3 < readBits4; i3++) {
+                        int i4 = i - 1;
+                        vorbisBitArray.skipBits(iLog(i4));
+                        vorbisBitArray.skipBits(iLog(i4));
+                    }
+                }
+                if (vorbisBitArray.readBits(2) != 0) {
+                    throw new ParserException("to reserved bits must be zero after mapping coupling steps");
+                }
+                if (readBits3 > 1) {
+                    for (int i5 = 0; i5 < i; i5++) {
+                        vorbisBitArray.skipBits(4);
+                    }
+                }
+                for (int i6 = 0; i6 < readBits3; i6++) {
+                    vorbisBitArray.skipBits(8);
+                    vorbisBitArray.skipBits(8);
+                    vorbisBitArray.skipBits(8);
+                }
+            } else {
+                Log.e(TAG, "mapping type other than 0 not supported: " + readBits2);
+            }
+        }
+    }
+
+    private static void readResidues(VorbisBitArray vorbisBitArray) throws ParserException {
+        int readBits = vorbisBitArray.readBits(6) + 1;
+        for (int i = 0; i < readBits; i++) {
+            if (vorbisBitArray.readBits(16) > 2) {
+                throw new ParserException("residueType greater than 2 is not decodable");
+            }
+            vorbisBitArray.skipBits(24);
+            vorbisBitArray.skipBits(24);
+            vorbisBitArray.skipBits(24);
+            int readBits2 = vorbisBitArray.readBits(6) + 1;
+            vorbisBitArray.skipBits(8);
+            int[] iArr = new int[readBits2];
+            for (int i2 = 0; i2 < readBits2; i2++) {
+                iArr[i2] = ((vorbisBitArray.readBit() ? vorbisBitArray.readBits(5) : 0) * 8) + vorbisBitArray.readBits(3);
+            }
+            for (int i3 = 0; i3 < readBits2; i3++) {
+                for (int i4 = 0; i4 < 8; i4++) {
+                    if ((iArr[i3] & (1 << i4)) != 0) {
+                        vorbisBitArray.skipBits(8);
+                    }
+                }
+            }
+        }
+    }
+
+    private static void readFloors(VorbisBitArray vorbisBitArray) throws ParserException {
+        int readBits = vorbisBitArray.readBits(6) + 1;
+        for (int i = 0; i < readBits; i++) {
+            int readBits2 = vorbisBitArray.readBits(16);
+            if (readBits2 == 0) {
+                vorbisBitArray.skipBits(8);
+                vorbisBitArray.skipBits(16);
+                vorbisBitArray.skipBits(16);
+                vorbisBitArray.skipBits(6);
+                vorbisBitArray.skipBits(8);
+                int readBits3 = vorbisBitArray.readBits(4) + 1;
+                for (int i2 = 0; i2 < readBits3; i2++) {
+                    vorbisBitArray.skipBits(8);
+                }
+            } else if (readBits2 == 1) {
+                int readBits4 = vorbisBitArray.readBits(5);
+                int[] iArr = new int[readBits4];
+                int i3 = -1;
+                for (int i4 = 0; i4 < readBits4; i4++) {
+                    int readBits5 = vorbisBitArray.readBits(4);
+                    iArr[i4] = readBits5;
+                    if (readBits5 > i3) {
+                        i3 = readBits5;
+                    }
+                }
+                int i5 = i3 + 1;
+                int[] iArr2 = new int[i5];
+                for (int i6 = 0; i6 < i5; i6++) {
+                    iArr2[i6] = vorbisBitArray.readBits(3) + 1;
+                    int readBits6 = vorbisBitArray.readBits(2);
+                    if (readBits6 > 0) {
+                        vorbisBitArray.skipBits(8);
+                    }
+                    for (int i7 = 0; i7 < (1 << readBits6); i7++) {
+                        vorbisBitArray.skipBits(8);
+                    }
+                }
+                vorbisBitArray.skipBits(2);
+                int readBits7 = vorbisBitArray.readBits(4);
+                int i8 = 0;
+                int i9 = 0;
+                for (int i10 = 0; i10 < readBits4; i10++) {
+                    i8 += iArr2[iArr[i10]];
+                    while (i9 < i8) {
+                        vorbisBitArray.skipBits(readBits7);
+                        i9++;
+                    }
+                }
+            } else {
+                throw new ParserException("floor type greater than 1 not decodable: " + readBits2);
+            }
+        }
+    }
+
+    private static CodeBook readBook(VorbisBitArray vorbisBitArray) throws ParserException {
+        if (vorbisBitArray.readBits(24) != 5653314) {
+            throw new ParserException("expected code book to start with [0x56, 0x43, 0x42] at " + vorbisBitArray.getPosition());
+        }
+        int readBits = vorbisBitArray.readBits(16);
+        int readBits2 = vorbisBitArray.readBits(24);
+        long[] jArr = new long[readBits2];
+        boolean readBit = vorbisBitArray.readBit();
+        long j = 0;
+        if (!readBit) {
+            boolean readBit2 = vorbisBitArray.readBit();
+            for (int i = 0; i < readBits2; i++) {
+                if (readBit2 && !vorbisBitArray.readBit()) {
+                    jArr[i] = 0;
+                } else {
+                    jArr[i] = vorbisBitArray.readBits(5) + 1;
+                }
+            }
+        } else {
+            int readBits3 = vorbisBitArray.readBits(5) + 1;
+            int i2 = 0;
+            while (i2 < readBits2) {
+                int readBits4 = vorbisBitArray.readBits(iLog(readBits2 - i2));
+                for (int i3 = 0; i3 < readBits4 && i2 < readBits2; i3++) {
+                    jArr[i2] = readBits3;
+                    i2++;
+                }
+                readBits3++;
+            }
+        }
+        int readBits5 = vorbisBitArray.readBits(4);
+        if (readBits5 > 2) {
+            throw new ParserException("lookup type greater than 2 not decodable: " + readBits5);
+        }
+        if (readBits5 == 1 || readBits5 == 2) {
+            vorbisBitArray.skipBits(32);
+            vorbisBitArray.skipBits(32);
+            int readBits6 = vorbisBitArray.readBits(4) + 1;
+            vorbisBitArray.skipBits(1);
+            if (readBits5 != 1) {
+                j = readBits2 * readBits;
+            } else if (readBits != 0) {
+                j = mapType1QuantValues(readBits2, readBits);
+            }
+            vorbisBitArray.skipBits((int) (j * readBits6));
+        }
+        return new CodeBook(readBits, readBits2, jArr, readBits5, readBit);
+    }
+
+    private static long mapType1QuantValues(long j, long j2) {
+        return (long) Math.floor(Math.pow(j, 1.0d / j2));
+    }
+
+    private VorbisUtil() {
+    }
+
+    public static final class CodeBook {
+        public final int dimensions;
+        public final int entries;
+        public final boolean isOrdered;
+        public final long[] lengthMap;
+        public final int lookupType;
+
+        public CodeBook(int i, int i2, long[] jArr, int i3, boolean z) {
+            this.dimensions = i;
+            this.entries = i2;
+            this.lengthMap = jArr;
+            this.lookupType = i3;
+            this.isOrdered = z;
+        }
+    }
+
+    public static final class CommentHeader {
+        public final String[] comments;
+        public final int length;
+        public final String vendor;
+
+        public CommentHeader(String str, String[] strArr, int i) {
+            this.vendor = str;
+            this.comments = strArr;
+            this.length = i;
+        }
+    }
+
+    public static final class VorbisIdHeader {
+        public final int bitrateMax;
+        public final int bitrateMin;
+        public final int bitrateNominal;
+        public final int blockSize0;
+        public final int blockSize1;
+        public final int channels;
+        public final byte[] data;
+        public final boolean framingFlag;
+        public final long sampleRate;
+        public final long version;
+
+        public VorbisIdHeader(long j, int i, long j2, int i2, int i3, int i4, int i5, int i6, boolean z, byte[] bArr) {
+            this.version = j;
+            this.channels = i;
+            this.sampleRate = j2;
+            this.bitrateMax = i2;
+            this.bitrateNominal = i3;
+            this.bitrateMin = i4;
+            this.blockSize0 = i5;
+            this.blockSize1 = i6;
+            this.framingFlag = z;
+            this.data = bArr;
+        }
+
+        public final int getApproximateBitrate() {
+            int i = this.bitrateNominal;
+            return i == 0 ? (this.bitrateMin + this.bitrateMax) / 2 : i;
+        }
+    }
+
+    public static final class Mode {
+        public final boolean blockFlag;
+        public final int mapping;
+        public final int transformType;
+        public final int windowType;
+
+        public Mode(boolean z, int i, int i2, int i3) {
+            this.blockFlag = z;
+            this.windowType = i;
+            this.transformType = i2;
+            this.mapping = i3;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/rawcc/RawCcExtractor.java

@@ -0,0 +1,136 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.rawcc;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class RawCcExtractor implements Extractor {
+    private static final int HEADER_ID = Util.getIntegerCodeForString("RCC\u0001");
+    private static final int HEADER_SIZE = 8;
+    private static final int SCRATCH_SIZE = 9;
+    private static final int STATE_READING_HEADER = 0;
+    private static final int STATE_READING_SAMPLES = 2;
+    private static final int STATE_READING_TIMESTAMP_AND_COUNT = 1;
+    private static final int TIMESTAMP_SIZE_V0 = 4;
+    private static final int TIMESTAMP_SIZE_V1 = 8;
+    private final Format format;
+    private int remainingSampleCount;
+    private int sampleBytesWritten;
+    private long timestampUs;
+    private TrackOutput trackOutput;
+    private int version;
+    private final ParsableByteArray dataScratch = new ParsableByteArray(9);
+    private int parserState = 0;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.parserState = 0;
+    }
+
+    public RawCcExtractor(Format format) {
+        this.format = format;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        extractorOutput.seekMap(new SeekMap.Unseekable(C.TIME_UNSET));
+        this.trackOutput = extractorOutput.track(0, 3);
+        extractorOutput.endTracks();
+        this.trackOutput.format(this.format);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        this.dataScratch.reset();
+        extractorInput.peekFully(this.dataScratch.data, 0, 8);
+        return this.dataScratch.readInt() == HEADER_ID;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        while (true) {
+            int i = this.parserState;
+            if (i != 0) {
+                if (i != 1) {
+                    if (i == 2) {
+                        parseSamples(extractorInput);
+                        this.parserState = 1;
+                        return 0;
+                    }
+                    throw new IllegalStateException();
+                }
+                if (!parseTimestampAndSampleCount(extractorInput)) {
+                    this.parserState = 0;
+                    return -1;
+                }
+                this.parserState = 2;
+            } else {
+                if (!parseHeader(extractorInput)) {
+                    return -1;
+                }
+                this.parserState = 1;
+            }
+        }
+    }
+
+    private boolean parseHeader(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        this.dataScratch.reset();
+        if (!extractorInput.readFully(this.dataScratch.data, 0, 8, true)) {
+            return false;
+        }
+        if (this.dataScratch.readInt() != HEADER_ID) {
+            throw new IOException("Input not RawCC");
+        }
+        this.version = this.dataScratch.readUnsignedByte();
+        return true;
+    }
+
+    private boolean parseTimestampAndSampleCount(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        this.dataScratch.reset();
+        int i = this.version;
+        if (i == 0) {
+            if (!extractorInput.readFully(this.dataScratch.data, 0, 5, true)) {
+                return false;
+            }
+            this.timestampUs = (this.dataScratch.readUnsignedInt() * 1000) / 45;
+        } else if (i == 1) {
+            if (!extractorInput.readFully(this.dataScratch.data, 0, 9, true)) {
+                return false;
+            }
+            this.timestampUs = this.dataScratch.readLong();
+        } else {
+            throw new ParserException("Unsupported version number: " + this.version);
+        }
+        this.remainingSampleCount = this.dataScratch.readUnsignedByte();
+        this.sampleBytesWritten = 0;
+        return true;
+    }
+
+    private void parseSamples(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        while (this.remainingSampleCount > 0) {
+            this.dataScratch.reset();
+            extractorInput.readFully(this.dataScratch.data, 0, 3);
+            this.trackOutput.sampleData(this.dataScratch, 3);
+            this.sampleBytesWritten += 3;
+            this.remainingSampleCount--;
+        }
+        int i = this.sampleBytesWritten;
+        if (i > 0) {
+            this.trackOutput.sampleMetadata(this.timestampUs, 1, i, 0, null);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/Ac3Extractor.java

@@ -0,0 +1,119 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.Ac3Util;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class Ac3Extractor implements Extractor {
+    private static final int AC3_SYNC_WORD = 2935;
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.Ac3Extractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new Ac3Extractor()};
+        }
+    };
+    private static final int ID3_TAG = Util.getIntegerCodeForString("ID3");
+    private static final int MAX_SNIFF_BYTES = 8192;
+    private static final int MAX_SYNC_FRAME_SIZE = 2786;
+    private final long firstSampleTimestampUs;
+    private final Ac3Reader reader;
+    private final ParsableByteArray sampleData;
+    private boolean startedPacket;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    public Ac3Extractor() {
+        this(0L);
+    }
+
+    public Ac3Extractor(long j) {
+        this.firstSampleTimestampUs = j;
+        this.reader = new Ac3Reader();
+        this.sampleData = new ParsableByteArray(MAX_SYNC_FRAME_SIZE);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        ParsableByteArray parsableByteArray = new ParsableByteArray(10);
+        int i = 0;
+        while (true) {
+            extractorInput.peekFully(parsableByteArray.data, 0, 10);
+            parsableByteArray.setPosition(0);
+            if (parsableByteArray.readUnsignedInt24() != ID3_TAG) {
+                break;
+            }
+            parsableByteArray.skipBytes(3);
+            int readSynchSafeInt = parsableByteArray.readSynchSafeInt();
+            i += readSynchSafeInt + 10;
+            extractorInput.advancePeekPosition(readSynchSafeInt);
+        }
+        extractorInput.resetPeekPosition();
+        extractorInput.advancePeekPosition(i);
+        int i2 = 0;
+        int i3 = i;
+        while (true) {
+            extractorInput.peekFully(parsableByteArray.data, 0, 5);
+            parsableByteArray.setPosition(0);
+            if (parsableByteArray.readUnsignedShort() != AC3_SYNC_WORD) {
+                extractorInput.resetPeekPosition();
+                i3++;
+                if (i3 - i >= 8192) {
+                    return false;
+                }
+                extractorInput.advancePeekPosition(i3);
+                i2 = 0;
+            } else {
+                i2++;
+                if (i2 >= 4) {
+                    return true;
+                }
+                int parseAc3SyncframeSize = Ac3Util.parseAc3SyncframeSize(parsableByteArray.data);
+                if (parseAc3SyncframeSize == -1) {
+                    return false;
+                }
+                extractorInput.advancePeekPosition(parseAc3SyncframeSize - 5);
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        this.reader.createTracks(extractorOutput, new TsPayloadReader.TrackIdGenerator(0, 1));
+        extractorOutput.endTracks();
+        extractorOutput.seekMap(new SeekMap.Unseekable(C.TIME_UNSET));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.startedPacket = false;
+        this.reader.seek();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        int read = extractorInput.read(this.sampleData.data, 0, MAX_SYNC_FRAME_SIZE);
+        if (read == -1) {
+            return -1;
+        }
+        this.sampleData.setPosition(0);
+        this.sampleData.setLimit(read);
+        if (!this.startedPacket) {
+            this.reader.packetStarted(this.firstSampleTimestampUs, true);
+            this.startedPacket = true;
+        }
+        this.reader.consume(this.sampleData);
+        return 0;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/Ac3Reader.java

@@ -0,0 +1,144 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.Ac3Util;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class Ac3Reader implements ElementaryStreamReader {
+    private static final int HEADER_SIZE = 128;
+    private static final int STATE_FINDING_SYNC = 0;
+    private static final int STATE_READING_HEADER = 1;
+    private static final int STATE_READING_SAMPLE = 2;
+    private int bytesRead;
+    private Format format;
+    private final ParsableBitArray headerScratchBits;
+    private final ParsableByteArray headerScratchBytes;
+    private final String language;
+    private boolean lastByteWas0B;
+    private TrackOutput output;
+    private long sampleDurationUs;
+    private int sampleSize;
+    private int state;
+    private long timeUs;
+    private String trackFormatId;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        this.timeUs = j;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        this.state = 0;
+        this.bytesRead = 0;
+        this.lastByteWas0B = false;
+    }
+
+    public Ac3Reader() {
+        this(null);
+    }
+
+    public Ac3Reader(String str) {
+        ParsableBitArray parsableBitArray = new ParsableBitArray(new byte[128]);
+        this.headerScratchBits = parsableBitArray;
+        this.headerScratchBytes = new ParsableByteArray(parsableBitArray.data);
+        this.state = 0;
+        this.language = str;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        this.trackFormatId = trackIdGenerator.getFormatId();
+        this.output = extractorOutput.track(trackIdGenerator.getTrackId(), 1);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        while (parsableByteArray.bytesLeft() > 0) {
+            int i = this.state;
+            if (i != 0) {
+                if (i != 1) {
+                    if (i == 2) {
+                        int min = Math.min(parsableByteArray.bytesLeft(), this.sampleSize - this.bytesRead);
+                        this.output.sampleData(parsableByteArray, min);
+                        int i2 = this.bytesRead + min;
+                        this.bytesRead = i2;
+                        int i3 = this.sampleSize;
+                        if (i2 == i3) {
+                            this.output.sampleMetadata(this.timeUs, 1, i3, 0, null);
+                            this.timeUs += this.sampleDurationUs;
+                            this.state = 0;
+                        }
+                    }
+                } else if (continueRead(parsableByteArray, this.headerScratchBytes.data, 128)) {
+                    parseHeader();
+                    this.headerScratchBytes.setPosition(0);
+                    this.output.sampleData(this.headerScratchBytes, 128);
+                    this.state = 2;
+                }
+            } else if (skipToNextSync(parsableByteArray)) {
+                this.state = 1;
+                byte[] bArr = this.headerScratchBytes.data;
+                bArr[0] = Ascii.VT;
+                bArr[1] = 119;
+                this.bytesRead = 2;
+            }
+        }
+    }
+
+    private boolean continueRead(ParsableByteArray parsableByteArray, byte[] bArr, int i) {
+        int min = Math.min(parsableByteArray.bytesLeft(), i - this.bytesRead);
+        parsableByteArray.readBytes(bArr, this.bytesRead, min);
+        int i2 = this.bytesRead + min;
+        this.bytesRead = i2;
+        return i2 == i;
+    }
+
+    private boolean skipToNextSync(ParsableByteArray parsableByteArray) {
+        while (true) {
+            if (parsableByteArray.bytesLeft() <= 0) {
+                return false;
+            }
+            if (!this.lastByteWas0B) {
+                this.lastByteWas0B = parsableByteArray.readUnsignedByte() == 11;
+            } else {
+                int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                if (readUnsignedByte == 119) {
+                    this.lastByteWas0B = false;
+                    return true;
+                }
+                this.lastByteWas0B = readUnsignedByte == 11;
+            }
+        }
+    }
+
+    private void parseHeader() {
+        this.headerScratchBits.setPosition(0);
+        Ac3Util.SyncFrameInfo parseAc3SyncframeInfo = Ac3Util.parseAc3SyncframeInfo(this.headerScratchBits);
+        Format format = this.format;
+        if (format == null || parseAc3SyncframeInfo.channelCount != format.channelCount || parseAc3SyncframeInfo.sampleRate != format.sampleRate || parseAc3SyncframeInfo.mimeType != format.sampleMimeType) {
+            Format createAudioSampleFormat = Format.createAudioSampleFormat(this.trackFormatId, parseAc3SyncframeInfo.mimeType, null, -1, -1, parseAc3SyncframeInfo.channelCount, parseAc3SyncframeInfo.sampleRate, null, null, 0, this.language);
+            this.format = createAudioSampleFormat;
+            this.output.format(createAudioSampleFormat);
+        }
+        this.sampleSize = parseAc3SyncframeInfo.frameSize;
+        this.sampleDurationUs = (parseAc3SyncframeInfo.sampleCount * 1000000) / this.format.sampleRate;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/AdtsExtractor.java

@@ -0,0 +1,124 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class AdtsExtractor implements Extractor {
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.AdtsExtractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new AdtsExtractor()};
+        }
+    };
+    private static final int ID3_TAG = Util.getIntegerCodeForString("ID3");
+    private static final int MAX_PACKET_SIZE = 200;
+    private static final int MAX_SNIFF_BYTES = 8192;
+    private final long firstSampleTimestampUs;
+    private final ParsableByteArray packetBuffer;
+    private final AdtsReader reader;
+    private boolean startedPacket;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    public AdtsExtractor() {
+        this(0L);
+    }
+
+    public AdtsExtractor(long j) {
+        this.firstSampleTimestampUs = j;
+        this.reader = new AdtsReader(true);
+        this.packetBuffer = new ParsableByteArray(200);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        ParsableByteArray parsableByteArray = new ParsableByteArray(10);
+        ParsableBitArray parsableBitArray = new ParsableBitArray(parsableByteArray.data);
+        int i = 0;
+        while (true) {
+            extractorInput.peekFully(parsableByteArray.data, 0, 10);
+            parsableByteArray.setPosition(0);
+            if (parsableByteArray.readUnsignedInt24() != ID3_TAG) {
+                break;
+            }
+            parsableByteArray.skipBytes(3);
+            int readSynchSafeInt = parsableByteArray.readSynchSafeInt();
+            i += readSynchSafeInt + 10;
+            extractorInput.advancePeekPosition(readSynchSafeInt);
+        }
+        extractorInput.resetPeekPosition();
+        extractorInput.advancePeekPosition(i);
+        int i2 = 0;
+        int i3 = 0;
+        int i4 = i;
+        while (true) {
+            extractorInput.peekFully(parsableByteArray.data, 0, 2);
+            parsableByteArray.setPosition(0);
+            if ((parsableByteArray.readUnsignedShort() & 65526) != 65520) {
+                extractorInput.resetPeekPosition();
+                i4++;
+                if (i4 - i >= 8192) {
+                    return false;
+                }
+                extractorInput.advancePeekPosition(i4);
+                i2 = 0;
+                i3 = 0;
+            } else {
+                i2++;
+                if (i2 >= 4 && i3 > 188) {
+                    return true;
+                }
+                extractorInput.peekFully(parsableByteArray.data, 0, 4);
+                parsableBitArray.setPosition(14);
+                int readBits = parsableBitArray.readBits(13);
+                if (readBits <= 6) {
+                    return false;
+                }
+                extractorInput.advancePeekPosition(readBits - 6);
+                i3 += readBits;
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        this.reader.createTracks(extractorOutput, new TsPayloadReader.TrackIdGenerator(0, 1));
+        extractorOutput.endTracks();
+        extractorOutput.seekMap(new SeekMap.Unseekable(C.TIME_UNSET));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.startedPacket = false;
+        this.reader.seek();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        int read = extractorInput.read(this.packetBuffer.data, 0, 200);
+        if (read == -1) {
+            return -1;
+        }
+        this.packetBuffer.setPosition(0);
+        this.packetBuffer.setLimit(read);
+        if (!this.startedPacket) {
+            this.reader.packetStarted(this.firstSampleTimestampUs, true);
+            this.startedPacket = true;
+        }
+        this.reader.consume(this.packetBuffer);
+        return 0;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/AdtsReader.java

@@ -0,0 +1,230 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.Log;
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.DummyTrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.CodecSpecificDataUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.Arrays;
+import java.util.Collections;
+
+/* loaded from: classes4.dex */
+public final class AdtsReader implements ElementaryStreamReader {
+    private static final int CRC_SIZE = 2;
+    private static final int HEADER_SIZE = 5;
+    private static final int ID3_HEADER_SIZE = 10;
+    private static final byte[] ID3_IDENTIFIER = {73, 68, 51};
+    private static final int ID3_SIZE_OFFSET = 6;
+    private static final int MATCH_STATE_FF = 512;
+    private static final int MATCH_STATE_I = 768;
+    private static final int MATCH_STATE_ID = 1024;
+    private static final int MATCH_STATE_START = 256;
+    private static final int MATCH_STATE_VALUE_SHIFT = 8;
+    private static final int STATE_FINDING_SAMPLE = 0;
+    private static final int STATE_READING_ADTS_HEADER = 2;
+    private static final int STATE_READING_ID3_HEADER = 1;
+    private static final int STATE_READING_SAMPLE = 3;
+    private static final String TAG = "AdtsReader";
+    private final ParsableBitArray adtsScratch;
+    private int bytesRead;
+    private TrackOutput currentOutput;
+    private long currentSampleDuration;
+    private final boolean exposeId3;
+    private String formatId;
+    private boolean hasCrc;
+    private boolean hasOutputFormat;
+    private final ParsableByteArray id3HeaderBuffer;
+    private TrackOutput id3Output;
+    private final String language;
+    private int matchState;
+    private TrackOutput output;
+    private long sampleDurationUs;
+    private int sampleSize;
+    private int state;
+    private long timeUs;
+
+    private void setFindingSampleState() {
+        this.state = 0;
+        this.bytesRead = 0;
+        this.matchState = 256;
+    }
+
+    private void setReadingAdtsHeaderState() {
+        this.state = 2;
+        this.bytesRead = 0;
+    }
+
+    private void setReadingSampleState(TrackOutput trackOutput, long j, int i, int i2) {
+        this.state = 3;
+        this.bytesRead = i;
+        this.currentOutput = trackOutput;
+        this.currentSampleDuration = j;
+        this.sampleSize = i2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        this.timeUs = j;
+    }
+
+    public AdtsReader(boolean z) {
+        this(z, null);
+    }
+
+    public AdtsReader(boolean z, String str) {
+        this.adtsScratch = new ParsableBitArray(new byte[7]);
+        this.id3HeaderBuffer = new ParsableByteArray(Arrays.copyOf(ID3_IDENTIFIER, 10));
+        setFindingSampleState();
+        this.exposeId3 = z;
+        this.language = str;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        setFindingSampleState();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        this.formatId = trackIdGenerator.getFormatId();
+        this.output = extractorOutput.track(trackIdGenerator.getTrackId(), 1);
+        if (this.exposeId3) {
+            trackIdGenerator.generateNewId();
+            TrackOutput track = extractorOutput.track(trackIdGenerator.getTrackId(), 4);
+            this.id3Output = track;
+            track.format(Format.createSampleFormat(trackIdGenerator.getFormatId(), MimeTypes.APPLICATION_ID3, null, -1, null));
+            return;
+        }
+        this.id3Output = new DummyTrackOutput();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) throws ParserException {
+        while (parsableByteArray.bytesLeft() > 0) {
+            int i = this.state;
+            if (i == 0) {
+                findNextSample(parsableByteArray);
+            } else if (i != 1) {
+                if (i == 2) {
+                    if (continueRead(parsableByteArray, this.adtsScratch.data, this.hasCrc ? 7 : 5)) {
+                        parseAdtsHeader();
+                    }
+                } else if (i == 3) {
+                    readSample(parsableByteArray);
+                }
+            } else if (continueRead(parsableByteArray, this.id3HeaderBuffer.data, 10)) {
+                parseId3Header();
+            }
+        }
+    }
+
+    private boolean continueRead(ParsableByteArray parsableByteArray, byte[] bArr, int i) {
+        int min = Math.min(parsableByteArray.bytesLeft(), i - this.bytesRead);
+        parsableByteArray.readBytes(bArr, this.bytesRead, min);
+        int i2 = this.bytesRead + min;
+        this.bytesRead = i2;
+        return i2 == i;
+    }
+
+    private void setReadingId3HeaderState() {
+        this.state = 1;
+        this.bytesRead = ID3_IDENTIFIER.length;
+        this.sampleSize = 0;
+        this.id3HeaderBuffer.setPosition(0);
+    }
+
+    private void findNextSample(ParsableByteArray parsableByteArray) {
+        byte[] bArr = parsableByteArray.data;
+        int position = parsableByteArray.getPosition();
+        int limit = parsableByteArray.limit();
+        while (position < limit) {
+            int i = position + 1;
+            byte b = bArr[position];
+            int i2 = b & 255;
+            int i3 = this.matchState;
+            if (i3 == 512 && i2 >= 240 && i2 != 255) {
+                this.hasCrc = (b & 1) == 0;
+                setReadingAdtsHeaderState();
+                parsableByteArray.setPosition(i);
+                return;
+            }
+            int i4 = i3 | i2;
+            if (i4 == 329) {
+                this.matchState = MATCH_STATE_I;
+            } else if (i4 == 511) {
+                this.matchState = 512;
+            } else if (i4 == 836) {
+                this.matchState = 1024;
+            } else if (i4 == 1075) {
+                setReadingId3HeaderState();
+                parsableByteArray.setPosition(i);
+                return;
+            } else if (i3 != 256) {
+                this.matchState = 256;
+            }
+            position = i;
+        }
+        parsableByteArray.setPosition(position);
+    }
+
+    private void parseId3Header() {
+        this.id3Output.sampleData(this.id3HeaderBuffer, 10);
+        this.id3HeaderBuffer.setPosition(6);
+        setReadingSampleState(this.id3Output, 0L, 10, this.id3HeaderBuffer.readSynchSafeInt() + 10);
+    }
+
+    private void parseAdtsHeader() throws ParserException {
+        this.adtsScratch.setPosition(0);
+        if (!this.hasOutputFormat) {
+            int i = 2;
+            int readBits = this.adtsScratch.readBits(2) + 1;
+            if (readBits != 2) {
+                Log.w(TAG, "Detected audio object type: " + readBits + ", but assuming AAC LC.");
+            } else {
+                i = readBits;
+            }
+            int readBits2 = this.adtsScratch.readBits(4);
+            this.adtsScratch.skipBits(1);
+            byte[] buildAacAudioSpecificConfig = CodecSpecificDataUtil.buildAacAudioSpecificConfig(i, readBits2, this.adtsScratch.readBits(3));
+            Pair<Integer, Integer> parseAacAudioSpecificConfig = CodecSpecificDataUtil.parseAacAudioSpecificConfig(buildAacAudioSpecificConfig);
+            Format createAudioSampleFormat = Format.createAudioSampleFormat(this.formatId, MimeTypes.AUDIO_AAC, null, -1, -1, ((Integer) parseAacAudioSpecificConfig.second).intValue(), ((Integer) parseAacAudioSpecificConfig.first).intValue(), Collections.singletonList(buildAacAudioSpecificConfig), null, 0, this.language);
+            this.sampleDurationUs = 1024000000 / createAudioSampleFormat.sampleRate;
+            this.output.format(createAudioSampleFormat);
+            this.hasOutputFormat = true;
+        } else {
+            this.adtsScratch.skipBits(10);
+        }
+        this.adtsScratch.skipBits(4);
+        int readBits3 = this.adtsScratch.readBits(13);
+        int i2 = readBits3 - 7;
+        if (this.hasCrc) {
+            i2 = readBits3 - 9;
+        }
+        setReadingSampleState(this.output, this.sampleDurationUs, 0, i2);
+    }
+
+    private void readSample(ParsableByteArray parsableByteArray) {
+        int min = Math.min(parsableByteArray.bytesLeft(), this.sampleSize - this.bytesRead);
+        this.currentOutput.sampleData(parsableByteArray, min);
+        int i = this.bytesRead + min;
+        this.bytesRead = i;
+        int i2 = this.sampleSize;
+        if (i == i2) {
+            this.currentOutput.sampleMetadata(this.timeUs, 1, i2, 0, null);
+            this.timeUs += this.currentSampleDuration;
+            setFindingSampleState();
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/DefaultTsPayloadReaderFactory.java

@@ -0,0 +1,142 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.SparseArray;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class DefaultTsPayloadReaderFactory implements TsPayloadReader.Factory {
+    private static final int DESCRIPTOR_TAG_CAPTION_SERVICE = 134;
+    public static final int FLAG_ALLOW_NON_IDR_KEYFRAMES = 1;
+    public static final int FLAG_DETECT_ACCESS_UNITS = 8;
+    public static final int FLAG_IGNORE_AAC_STREAM = 2;
+    public static final int FLAG_IGNORE_H264_STREAM = 4;
+    public static final int FLAG_IGNORE_SPLICE_INFO_STREAM = 16;
+    public static final int FLAG_OVERRIDE_CAPTION_DESCRIPTORS = 32;
+    private final List<Format> closedCaptionFormats;
+    private final int flags;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Flags {
+    }
+
+    private boolean isSet(int i) {
+        return (i & this.flags) != 0;
+    }
+
+    public DefaultTsPayloadReaderFactory() {
+        this(0);
+    }
+
+    public DefaultTsPayloadReaderFactory(int i) {
+        this(i, Collections.emptyList());
+    }
+
+    public DefaultTsPayloadReaderFactory(int i, List<Format> list) {
+        this.flags = i;
+        if (!isSet(32) && list.isEmpty()) {
+            list = Collections.singletonList(Format.createTextSampleFormat(null, MimeTypes.APPLICATION_CEA608, 0, null));
+        }
+        this.closedCaptionFormats = list;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader.Factory
+    public final SparseArray<TsPayloadReader> createInitialPayloadReaders() {
+        return new SparseArray<>();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader.Factory
+    public final TsPayloadReader createPayloadReader(int i, TsPayloadReader.EsInfo esInfo) {
+        if (i == 2) {
+            return new PesReader(new H262Reader());
+        }
+        if (i == 3 || i == 4) {
+            return new PesReader(new MpegAudioReader(esInfo.language));
+        }
+        if (i == 15) {
+            if (isSet(2)) {
+                return null;
+            }
+            return new PesReader(new AdtsReader(false, esInfo.language));
+        }
+        if (i == 17) {
+            if (isSet(2)) {
+                return null;
+            }
+            return new PesReader(new LatmReader(esInfo.language));
+        }
+        if (i == 21) {
+            return new PesReader(new Id3Reader());
+        }
+        if (i == 27) {
+            if (isSet(4)) {
+                return null;
+            }
+            return new PesReader(new H264Reader(buildSeiReader(esInfo), isSet(1), isSet(8)));
+        }
+        if (i == 36) {
+            return new PesReader(new H265Reader(buildSeiReader(esInfo)));
+        }
+        if (i != 89) {
+            if (i != 138) {
+                if (i != 129) {
+                    if (i != 130) {
+                        if (i == 134) {
+                            if (isSet(16)) {
+                                return null;
+                            }
+                            return new SectionReader(new SpliceInfoSectionReader());
+                        }
+                        if (i != 135) {
+                            return null;
+                        }
+                    }
+                }
+                return new PesReader(new Ac3Reader(esInfo.language));
+            }
+            return new PesReader(new DtsReader(esInfo.language));
+        }
+        return new PesReader(new DvbSubtitleReader(esInfo.dvbSubtitleInfos));
+    }
+
+    private SeiReader buildSeiReader(TsPayloadReader.EsInfo esInfo) {
+        int i;
+        String str;
+        if (isSet(32)) {
+            return new SeiReader(this.closedCaptionFormats);
+        }
+        ParsableByteArray parsableByteArray = new ParsableByteArray(esInfo.descriptorBytes);
+        List<Format> list = this.closedCaptionFormats;
+        while (parsableByteArray.bytesLeft() > 0) {
+            int readUnsignedByte = parsableByteArray.readUnsignedByte();
+            int position = parsableByteArray.getPosition() + parsableByteArray.readUnsignedByte();
+            if (readUnsignedByte == 134) {
+                list = new ArrayList<>();
+                int readUnsignedByte2 = parsableByteArray.readUnsignedByte() & 31;
+                for (int i2 = 0; i2 < readUnsignedByte2; i2++) {
+                    String readString = parsableByteArray.readString(3);
+                    int readUnsignedByte3 = parsableByteArray.readUnsignedByte();
+                    if ((readUnsignedByte3 & 128) != 0) {
+                        i = readUnsignedByte3 & 63;
+                        str = MimeTypes.APPLICATION_CEA708;
+                    } else {
+                        i = 1;
+                        str = MimeTypes.APPLICATION_CEA608;
+                    }
+                    list.add(Format.createTextSampleFormat((String) null, str, (String) null, -1, 0, readString, i, (DrmInitData) null));
+                    parsableByteArray.skipBytes(2);
+                }
+            }
+            parsableByteArray.setPosition(position);
+        }
+        return new SeiReader(list);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/DtsReader.java

@@ -0,0 +1,124 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.DtsUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+
+/* loaded from: classes4.dex */
+public final class DtsReader implements ElementaryStreamReader {
+    private static final int HEADER_SIZE = 18;
+    private static final int STATE_FINDING_SYNC = 0;
+    private static final int STATE_READING_HEADER = 1;
+    private static final int STATE_READING_SAMPLE = 2;
+    private int bytesRead;
+    private Format format;
+    private String formatId;
+    private final String language;
+    private TrackOutput output;
+    private long sampleDurationUs;
+    private int sampleSize;
+    private int syncBytes;
+    private long timeUs;
+    private final ParsableByteArray headerScratchBytes = new ParsableByteArray(new byte[18]);
+    private int state = 0;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        this.timeUs = j;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        this.state = 0;
+        this.bytesRead = 0;
+        this.syncBytes = 0;
+    }
+
+    public DtsReader(String str) {
+        this.language = str;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        this.formatId = trackIdGenerator.getFormatId();
+        this.output = extractorOutput.track(trackIdGenerator.getTrackId(), 1);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        while (parsableByteArray.bytesLeft() > 0) {
+            int i = this.state;
+            if (i != 0) {
+                if (i != 1) {
+                    if (i == 2) {
+                        int min = Math.min(parsableByteArray.bytesLeft(), this.sampleSize - this.bytesRead);
+                        this.output.sampleData(parsableByteArray, min);
+                        int i2 = this.bytesRead + min;
+                        this.bytesRead = i2;
+                        int i3 = this.sampleSize;
+                        if (i2 == i3) {
+                            this.output.sampleMetadata(this.timeUs, 1, i3, 0, null);
+                            this.timeUs += this.sampleDurationUs;
+                            this.state = 0;
+                        }
+                    }
+                } else if (continueRead(parsableByteArray, this.headerScratchBytes.data, 18)) {
+                    parseHeader();
+                    this.headerScratchBytes.setPosition(0);
+                    this.output.sampleData(this.headerScratchBytes, 18);
+                    this.state = 2;
+                }
+            } else if (skipToNextSync(parsableByteArray)) {
+                this.state = 1;
+            }
+        }
+    }
+
+    private boolean continueRead(ParsableByteArray parsableByteArray, byte[] bArr, int i) {
+        int min = Math.min(parsableByteArray.bytesLeft(), i - this.bytesRead);
+        parsableByteArray.readBytes(bArr, this.bytesRead, min);
+        int i2 = this.bytesRead + min;
+        this.bytesRead = i2;
+        return i2 == i;
+    }
+
+    private boolean skipToNextSync(ParsableByteArray parsableByteArray) {
+        while (parsableByteArray.bytesLeft() > 0) {
+            int i = this.syncBytes << 8;
+            this.syncBytes = i;
+            int readUnsignedByte = i | parsableByteArray.readUnsignedByte();
+            this.syncBytes = readUnsignedByte;
+            if (DtsUtil.isSyncWord(readUnsignedByte)) {
+                byte[] bArr = this.headerScratchBytes.data;
+                int i2 = this.syncBytes;
+                bArr[0] = (byte) ((i2 >> 24) & 255);
+                bArr[1] = (byte) ((i2 >> 16) & 255);
+                bArr[2] = (byte) ((i2 >> 8) & 255);
+                bArr[3] = (byte) (i2 & 255);
+                this.bytesRead = 4;
+                this.syncBytes = 0;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void parseHeader() {
+        byte[] bArr = this.headerScratchBytes.data;
+        if (this.format == null) {
+            Format parseDtsFormat = DtsUtil.parseDtsFormat(bArr, this.formatId, this.language, null);
+            this.format = parseDtsFormat;
+            this.output.format(parseDtsFormat);
+        }
+        this.sampleSize = DtsUtil.getDtsFrameSize(bArr);
+        this.sampleDurationUs = (int) ((DtsUtil.parseDtsAudioSampleCount(bArr) * 1000000) / this.format.sampleRate);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/DvbSubtitleReader.java

@@ -0,0 +1,89 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class DvbSubtitleReader implements ElementaryStreamReader {
+    private int bytesToCheck;
+    private final TrackOutput[] outputs;
+    private int sampleBytesWritten;
+    private long sampleTimeUs;
+    private final List<TsPayloadReader.DvbSubtitleInfo> subtitleInfos;
+    private boolean writingSample;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        if (z) {
+            this.writingSample = true;
+            this.sampleTimeUs = j;
+            this.sampleBytesWritten = 0;
+            this.bytesToCheck = 2;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        this.writingSample = false;
+    }
+
+    public DvbSubtitleReader(List<TsPayloadReader.DvbSubtitleInfo> list) {
+        this.subtitleInfos = list;
+        this.outputs = new TrackOutput[list.size()];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        for (int i = 0; i < this.outputs.length; i++) {
+            TsPayloadReader.DvbSubtitleInfo dvbSubtitleInfo = this.subtitleInfos.get(i);
+            trackIdGenerator.generateNewId();
+            TrackOutput track = extractorOutput.track(trackIdGenerator.getTrackId(), 3);
+            track.format(Format.createImageSampleFormat(trackIdGenerator.getFormatId(), MimeTypes.APPLICATION_DVBSUBS, null, -1, 0, Collections.singletonList(dvbSubtitleInfo.initializationData), dvbSubtitleInfo.language, null));
+            this.outputs[i] = track;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+        if (this.writingSample) {
+            for (TrackOutput trackOutput : this.outputs) {
+                trackOutput.sampleMetadata(this.sampleTimeUs, 1, this.sampleBytesWritten, 0, null);
+            }
+            this.writingSample = false;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        if (this.writingSample) {
+            if (this.bytesToCheck != 2 || checkNextByte(parsableByteArray, 32)) {
+                if (this.bytesToCheck != 1 || checkNextByte(parsableByteArray, 0)) {
+                    int position = parsableByteArray.getPosition();
+                    int bytesLeft = parsableByteArray.bytesLeft();
+                    for (TrackOutput trackOutput : this.outputs) {
+                        parsableByteArray.setPosition(position);
+                        trackOutput.sampleData(parsableByteArray, bytesLeft);
+                    }
+                    this.sampleBytesWritten += bytesLeft;
+                }
+            }
+        }
+    }
+
+    private boolean checkNextByte(ParsableByteArray parsableByteArray, int i) {
+        if (parsableByteArray.bytesLeft() == 0) {
+            return false;
+        }
+        if (parsableByteArray.readUnsignedByte() != i) {
+            this.writingSample = false;
+        }
+        this.bytesToCheck--;
+        return this.writingSample;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/ElementaryStreamReader.java

@@ -0,0 +1,19 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+
+/* loaded from: classes4.dex */
+public interface ElementaryStreamReader {
+    void consume(ParsableByteArray parsableByteArray) throws ParserException;
+
+    void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator);
+
+    void packetFinished();
+
+    void packetStarted(long j, boolean z);
+
+    void seek();
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/H262Reader.java

@@ -0,0 +1,273 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.NalUnitUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class H262Reader implements ElementaryStreamReader {
+    private static final double[] FRAME_RATE_VALUES = {23.976023976023978d, 24.0d, 25.0d, 29.97002997002997d, 30.0d, 50.0d, 59.94005994005994d, 60.0d};
+    private static final int START_EXTENSION = 181;
+    private static final int START_GROUP = 184;
+    private static final int START_PICTURE = 0;
+    private static final int START_SEQUENCE_HEADER = 179;
+    private String formatId;
+    private long frameDurationUs;
+    private boolean hasOutputFormat;
+    private TrackOutput output;
+    private long pesTimeUs;
+    private boolean sampleHasPicture;
+    private boolean sampleIsKeyframe;
+    private long samplePosition;
+    private long sampleTimeUs;
+    private boolean startedFirstSample;
+    private long totalBytesWritten;
+    private final boolean[] prefixFlags = new boolean[4];
+    private final CsdBuffer csdBuffer = new CsdBuffer(128);
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        this.pesTimeUs = j;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        NalUnitUtil.clearPrefixFlags(this.prefixFlags);
+        this.csdBuffer.reset();
+        this.totalBytesWritten = 0L;
+        this.startedFirstSample = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        this.formatId = trackIdGenerator.getFormatId();
+        this.output = extractorOutput.track(trackIdGenerator.getTrackId(), 2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        boolean z;
+        boolean z2;
+        int position = parsableByteArray.getPosition();
+        int limit = parsableByteArray.limit();
+        byte[] bArr = parsableByteArray.data;
+        this.totalBytesWritten += parsableByteArray.bytesLeft();
+        this.output.sampleData(parsableByteArray, parsableByteArray.bytesLeft());
+        while (true) {
+            int findNalUnit = NalUnitUtil.findNalUnit(bArr, position, limit, this.prefixFlags);
+            if (findNalUnit == limit) {
+                break;
+            }
+            int i = findNalUnit + 3;
+            int i2 = parsableByteArray.data[i] & 255;
+            if (!this.hasOutputFormat) {
+                int i3 = findNalUnit - position;
+                if (i3 > 0) {
+                    this.csdBuffer.onData(bArr, position, findNalUnit);
+                }
+                if (this.csdBuffer.onStartCode(i2, i3 < 0 ? -i3 : 0)) {
+                    Pair<Format, Long> parseCsdBuffer = parseCsdBuffer(this.csdBuffer, this.formatId);
+                    this.output.format((Format) parseCsdBuffer.first);
+                    this.frameDurationUs = ((Long) parseCsdBuffer.second).longValue();
+                    this.hasOutputFormat = true;
+                }
+            }
+            if (i2 == 0 || i2 == START_SEQUENCE_HEADER) {
+                int i4 = limit - findNalUnit;
+                if (this.startedFirstSample && this.sampleHasPicture && this.hasOutputFormat) {
+                    this.output.sampleMetadata(this.sampleTimeUs, this.sampleIsKeyframe ? 1 : 0, ((int) (this.totalBytesWritten - this.samplePosition)) - i4, i4, null);
+                }
+                boolean z3 = this.startedFirstSample;
+                if (!z3 || this.sampleHasPicture) {
+                    this.samplePosition = this.totalBytesWritten - i4;
+                    long j = this.pesTimeUs;
+                    if (j == C.TIME_UNSET) {
+                        j = z3 ? this.sampleTimeUs + this.frameDurationUs : 0L;
+                    }
+                    this.sampleTimeUs = j;
+                    z = false;
+                    this.sampleIsKeyframe = false;
+                    this.pesTimeUs = C.TIME_UNSET;
+                    z2 = true;
+                    this.startedFirstSample = true;
+                } else {
+                    z = false;
+                    z2 = true;
+                }
+                this.sampleHasPicture = i2 == 0 ? z2 : z;
+            } else if (i2 == START_GROUP) {
+                this.sampleIsKeyframe = true;
+            }
+            position = i;
+        }
+        if (this.hasOutputFormat) {
+            return;
+        }
+        this.csdBuffer.onData(bArr, position, limit);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x0067  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static android.util.Pair<com.mbridge.msdk.playercommon.exoplayer2.Format, java.lang.Long> parseCsdBuffer(com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.H262Reader.CsdBuffer r20, java.lang.String r21) {
+        /*
+            r0 = r20
+            byte[] r1 = r0.data
+            int r2 = r0.length
+            byte[] r1 = java.util.Arrays.copyOf(r1, r2)
+            r2 = 4
+            r3 = r1[r2]
+            r3 = r3 & 255(0xff, float:3.57E-43)
+            r4 = 5
+            r5 = r1[r4]
+            r6 = r5 & 255(0xff, float:3.57E-43)
+            r7 = 6
+            r7 = r1[r7]
+            r7 = r7 & 255(0xff, float:3.57E-43)
+            int r3 = r3 << r2
+            int r6 = r6 >> r2
+            r13 = r3 | r6
+            r3 = r5 & 15
+            int r3 = r3 << 8
+            r14 = r3 | r7
+            r3 = 7
+            r5 = r1[r3]
+            r5 = r5 & 240(0xf0, float:3.36E-43)
+            int r5 = r5 >> r2
+            r6 = 2
+            if (r5 == r6) goto L44
+            r6 = 3
+            if (r5 == r6) goto L3e
+            if (r5 == r2) goto L36
+            r2 = 1065353216(0x3f800000, float:1.0)
+        L33:
+            r18 = r2
+            goto L4a
+        L36:
+            int r2 = r14 * 121
+            float r2 = (float) r2
+            int r5 = r13 * 100
+        L3b:
+            float r5 = (float) r5
+            float r2 = r2 / r5
+            goto L33
+        L3e:
+            int r2 = r14 * 16
+            float r2 = (float) r2
+            int r5 = r13 * 9
+            goto L3b
+        L44:
+            int r2 = r14 * 4
+            float r2 = (float) r2
+            int r5 = r13 * 3
+            goto L3b
+        L4a:
+            java.lang.String r9 = "video/mpeg2"
+            r10 = 0
+            r11 = -1
+            r12 = -1
+            r15 = -1082130432(0xffffffffbf800000, float:-1.0)
+            java.util.List r16 = java.util.Collections.singletonList(r1)
+            r17 = -1
+            r19 = 0
+            r8 = r21
+            com.mbridge.msdk.playercommon.exoplayer2.Format r2 = com.mbridge.msdk.playercommon.exoplayer2.Format.createVideoSampleFormat(r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19)
+            r3 = r1[r3]
+            r3 = r3 & 15
+            int r3 = r3 + (-1)
+            if (r3 < 0) goto L8c
+            double[] r5 = com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.H262Reader.FRAME_RATE_VALUES
+            int r6 = r5.length
+            if (r3 >= r6) goto L8c
+            r6 = r5[r3]
+            int r0 = r0.sequenceExtensionPosition
+            int r0 = r0 + 9
+            r0 = r1[r0]
+            r1 = r0 & 96
+            int r1 = r1 >> r4
+            r0 = r0 & 31
+            if (r1 == r0) goto L84
+            double r3 = (double) r1
+            r8 = 4607182418800017408(0x3ff0000000000000, double:1.0)
+            double r3 = r3 + r8
+            int r0 = r0 + 1
+            double r0 = (double) r0
+            double r3 = r3 / r0
+            double r6 = r6 * r3
+        L84:
+            r0 = 4696837146684686336(0x412e848000000000, double:1000000.0)
+            double r0 = r0 / r6
+            long r0 = (long) r0
+            goto L8e
+        L8c:
+            r0 = 0
+        L8e:
+            java.lang.Long r0 = java.lang.Long.valueOf(r0)
+            android.util.Pair r0 = android.util.Pair.create(r2, r0)
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.H262Reader.parseCsdBuffer(com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.H262Reader$CsdBuffer, java.lang.String):android.util.Pair");
+    }
+
+    public static final class CsdBuffer {
+        private static final byte[] START_CODE = {0, 0, 1};
+        public byte[] data;
+        private boolean isFilling;
+        public int length;
+        public int sequenceExtensionPosition;
+
+        public final void reset() {
+            this.isFilling = false;
+            this.length = 0;
+            this.sequenceExtensionPosition = 0;
+        }
+
+        public CsdBuffer(int i) {
+            this.data = new byte[i];
+        }
+
+        public final boolean onStartCode(int i, int i2) {
+            if (this.isFilling) {
+                int i3 = this.length - i2;
+                this.length = i3;
+                if (this.sequenceExtensionPosition != 0 || i != H262Reader.START_EXTENSION) {
+                    this.isFilling = false;
+                    return true;
+                }
+                this.sequenceExtensionPosition = i3;
+            } else if (i == H262Reader.START_SEQUENCE_HEADER) {
+                this.isFilling = true;
+            }
+            byte[] bArr = START_CODE;
+            onData(bArr, 0, bArr.length);
+            return false;
+        }
+
+        public final void onData(byte[] bArr, int i, int i2) {
+            if (this.isFilling) {
+                int i3 = i2 - i;
+                byte[] bArr2 = this.data;
+                int length = bArr2.length;
+                int i4 = this.length;
+                if (length < i4 + i3) {
+                    this.data = Arrays.copyOf(bArr2, (i4 + i3) * 2);
+                }
+                System.arraycopy(bArr, i, this.data, this.length, i3);
+                this.length += i3;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/H264Reader.java

@@ -0,0 +1,359 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.SparseArray;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.NalUnitUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableNalUnitBitArray;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class H264Reader implements ElementaryStreamReader {
+    private static final int NAL_UNIT_TYPE_PPS = 8;
+    private static final int NAL_UNIT_TYPE_SEI = 6;
+    private static final int NAL_UNIT_TYPE_SPS = 7;
+    private final boolean allowNonIdrKeyframes;
+    private final boolean detectAccessUnits;
+    private String formatId;
+    private boolean hasOutputFormat;
+    private TrackOutput output;
+    private long pesTimeUs;
+    private SampleReader sampleReader;
+    private final SeiReader seiReader;
+    private long totalBytesWritten;
+    private final boolean[] prefixFlags = new boolean[3];
+    private final NalUnitTargetBuffer sps = new NalUnitTargetBuffer(7, 128);
+    private final NalUnitTargetBuffer pps = new NalUnitTargetBuffer(8, 128);
+    private final NalUnitTargetBuffer sei = new NalUnitTargetBuffer(6, 128);
+    private final ParsableByteArray seiWrapper = new ParsableByteArray();
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        this.pesTimeUs = j;
+    }
+
+    public H264Reader(SeiReader seiReader, boolean z, boolean z2) {
+        this.seiReader = seiReader;
+        this.allowNonIdrKeyframes = z;
+        this.detectAccessUnits = z2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        NalUnitUtil.clearPrefixFlags(this.prefixFlags);
+        this.sps.reset();
+        this.pps.reset();
+        this.sei.reset();
+        this.sampleReader.reset();
+        this.totalBytesWritten = 0L;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        this.formatId = trackIdGenerator.getFormatId();
+        TrackOutput track = extractorOutput.track(trackIdGenerator.getTrackId(), 2);
+        this.output = track;
+        this.sampleReader = new SampleReader(track, this.allowNonIdrKeyframes, this.detectAccessUnits);
+        this.seiReader.createTracks(extractorOutput, trackIdGenerator);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        int position = parsableByteArray.getPosition();
+        int limit = parsableByteArray.limit();
+        byte[] bArr = parsableByteArray.data;
+        this.totalBytesWritten += parsableByteArray.bytesLeft();
+        this.output.sampleData(parsableByteArray, parsableByteArray.bytesLeft());
+        while (true) {
+            int findNalUnit = NalUnitUtil.findNalUnit(bArr, position, limit, this.prefixFlags);
+            if (findNalUnit == limit) {
+                nalUnitData(bArr, position, limit);
+                return;
+            }
+            int nalUnitType = NalUnitUtil.getNalUnitType(bArr, findNalUnit);
+            int i = findNalUnit - position;
+            if (i > 0) {
+                nalUnitData(bArr, position, findNalUnit);
+            }
+            int i2 = limit - findNalUnit;
+            long j = this.totalBytesWritten - i2;
+            endNalUnit(j, i2, i < 0 ? -i : 0, this.pesTimeUs);
+            startNalUnit(j, nalUnitType, this.pesTimeUs);
+            position = findNalUnit + 3;
+        }
+    }
+
+    private void startNalUnit(long j, int i, long j2) {
+        if (!this.hasOutputFormat || this.sampleReader.needsSpsPps()) {
+            this.sps.startNalUnit(i);
+            this.pps.startNalUnit(i);
+        }
+        this.sei.startNalUnit(i);
+        this.sampleReader.startNalUnit(j, i, j2);
+    }
+
+    private void nalUnitData(byte[] bArr, int i, int i2) {
+        if (!this.hasOutputFormat || this.sampleReader.needsSpsPps()) {
+            this.sps.appendToNalUnit(bArr, i, i2);
+            this.pps.appendToNalUnit(bArr, i, i2);
+        }
+        this.sei.appendToNalUnit(bArr, i, i2);
+        this.sampleReader.appendToNalUnit(bArr, i, i2);
+    }
+
+    private void endNalUnit(long j, int i, int i2, long j2) {
+        if (!this.hasOutputFormat || this.sampleReader.needsSpsPps()) {
+            this.sps.endNalUnit(i2);
+            this.pps.endNalUnit(i2);
+            if (!this.hasOutputFormat) {
+                if (this.sps.isCompleted() && this.pps.isCompleted()) {
+                    ArrayList arrayList = new ArrayList();
+                    NalUnitTargetBuffer nalUnitTargetBuffer = this.sps;
+                    arrayList.add(Arrays.copyOf(nalUnitTargetBuffer.nalData, nalUnitTargetBuffer.nalLength));
+                    NalUnitTargetBuffer nalUnitTargetBuffer2 = this.pps;
+                    arrayList.add(Arrays.copyOf(nalUnitTargetBuffer2.nalData, nalUnitTargetBuffer2.nalLength));
+                    NalUnitTargetBuffer nalUnitTargetBuffer3 = this.sps;
+                    NalUnitUtil.SpsData parseSpsNalUnit = NalUnitUtil.parseSpsNalUnit(nalUnitTargetBuffer3.nalData, 3, nalUnitTargetBuffer3.nalLength);
+                    NalUnitTargetBuffer nalUnitTargetBuffer4 = this.pps;
+                    NalUnitUtil.PpsData parsePpsNalUnit = NalUnitUtil.parsePpsNalUnit(nalUnitTargetBuffer4.nalData, 3, nalUnitTargetBuffer4.nalLength);
+                    this.output.format(Format.createVideoSampleFormat(this.formatId, "video/avc", null, -1, -1, parseSpsNalUnit.width, parseSpsNalUnit.height, -1.0f, arrayList, -1, parseSpsNalUnit.pixelWidthAspectRatio, null));
+                    this.hasOutputFormat = true;
+                    this.sampleReader.putSps(parseSpsNalUnit);
+                    this.sampleReader.putPps(parsePpsNalUnit);
+                    this.sps.reset();
+                    this.pps.reset();
+                }
+            } else if (this.sps.isCompleted()) {
+                NalUnitTargetBuffer nalUnitTargetBuffer5 = this.sps;
+                this.sampleReader.putSps(NalUnitUtil.parseSpsNalUnit(nalUnitTargetBuffer5.nalData, 3, nalUnitTargetBuffer5.nalLength));
+                this.sps.reset();
+            } else if (this.pps.isCompleted()) {
+                NalUnitTargetBuffer nalUnitTargetBuffer6 = this.pps;
+                this.sampleReader.putPps(NalUnitUtil.parsePpsNalUnit(nalUnitTargetBuffer6.nalData, 3, nalUnitTargetBuffer6.nalLength));
+                this.pps.reset();
+            }
+        }
+        if (this.sei.endNalUnit(i2)) {
+            NalUnitTargetBuffer nalUnitTargetBuffer7 = this.sei;
+            this.seiWrapper.reset(this.sei.nalData, NalUnitUtil.unescapeStream(nalUnitTargetBuffer7.nalData, nalUnitTargetBuffer7.nalLength));
+            this.seiWrapper.setPosition(4);
+            this.seiReader.consume(j2, this.seiWrapper);
+        }
+        this.sampleReader.endNalUnit(j, i);
+    }
+
+    public static final class SampleReader {
+        private static final int DEFAULT_BUFFER_SIZE = 128;
+        private static final int NAL_UNIT_TYPE_AUD = 9;
+        private static final int NAL_UNIT_TYPE_IDR = 5;
+        private static final int NAL_UNIT_TYPE_NON_IDR = 1;
+        private static final int NAL_UNIT_TYPE_PARTITION_A = 2;
+        private final boolean allowNonIdrKeyframes;
+        private final ParsableNalUnitBitArray bitArray;
+        private byte[] buffer;
+        private int bufferLength;
+        private final boolean detectAccessUnits;
+        private boolean isFilling;
+        private long nalUnitStartPosition;
+        private long nalUnitTimeUs;
+        private int nalUnitType;
+        private final TrackOutput output;
+        private SliceHeaderData previousSliceHeader;
+        private boolean readingSample;
+        private boolean sampleIsKeyframe;
+        private long samplePosition;
+        private long sampleTimeUs;
+        private SliceHeaderData sliceHeader;
+        private final SparseArray<NalUnitUtil.SpsData> sps = new SparseArray<>();
+        private final SparseArray<NalUnitUtil.PpsData> pps = new SparseArray<>();
+
+        public final boolean needsSpsPps() {
+            return this.detectAccessUnits;
+        }
+
+        public SampleReader(TrackOutput trackOutput, boolean z, boolean z2) {
+            this.output = trackOutput;
+            this.allowNonIdrKeyframes = z;
+            this.detectAccessUnits = z2;
+            this.previousSliceHeader = new SliceHeaderData();
+            this.sliceHeader = new SliceHeaderData();
+            byte[] bArr = new byte[128];
+            this.buffer = bArr;
+            this.bitArray = new ParsableNalUnitBitArray(bArr, 0, 0);
+            reset();
+        }
+
+        public final void putSps(NalUnitUtil.SpsData spsData) {
+            this.sps.append(spsData.seqParameterSetId, spsData);
+        }
+
+        public final void putPps(NalUnitUtil.PpsData ppsData) {
+            this.pps.append(ppsData.picParameterSetId, ppsData);
+        }
+
+        public final void reset() {
+            this.isFilling = false;
+            this.readingSample = false;
+            this.sliceHeader.clear();
+        }
+
+        public final void startNalUnit(long j, int i, long j2) {
+            this.nalUnitType = i;
+            this.nalUnitTimeUs = j2;
+            this.nalUnitStartPosition = j;
+            if (!this.allowNonIdrKeyframes || i != 1) {
+                if (!this.detectAccessUnits) {
+                    return;
+                }
+                if (i != 5 && i != 1 && i != 2) {
+                    return;
+                }
+            }
+            SliceHeaderData sliceHeaderData = this.previousSliceHeader;
+            this.previousSliceHeader = this.sliceHeader;
+            this.sliceHeader = sliceHeaderData;
+            sliceHeaderData.clear();
+            this.bufferLength = 0;
+            this.isFilling = true;
+        }
+
+        /* JADX WARN: Removed duplicated region for block: B:50:0x0100  */
+        /* JADX WARN: Removed duplicated region for block: B:52:0x0107  */
+        /* JADX WARN: Removed duplicated region for block: B:58:0x011f  */
+        /* JADX WARN: Removed duplicated region for block: B:73:0x0157  */
+        /* JADX WARN: Removed duplicated region for block: B:88:0x0119  */
+        /* JADX WARN: Removed duplicated region for block: B:89:0x0103  */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final void appendToNalUnit(byte[] r24, int r25, int r26) {
+            /*
+                Method dump skipped, instructions count: 416
+                To view this dump add '--comments-level debug' option
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.H264Reader.SampleReader.appendToNalUnit(byte[], int, int):void");
+        }
+
+        public final void endNalUnit(long j, int i) {
+            boolean z = false;
+            if (this.nalUnitType == 9 || (this.detectAccessUnits && this.sliceHeader.isFirstVclNalUnitOfPicture(this.previousSliceHeader))) {
+                if (this.readingSample) {
+                    outputSample(i + ((int) (j - this.nalUnitStartPosition)));
+                }
+                this.samplePosition = this.nalUnitStartPosition;
+                this.sampleTimeUs = this.nalUnitTimeUs;
+                this.sampleIsKeyframe = false;
+                this.readingSample = true;
+            }
+            boolean z2 = this.sampleIsKeyframe;
+            int i2 = this.nalUnitType;
+            if (i2 == 5 || (this.allowNonIdrKeyframes && i2 == 1 && this.sliceHeader.isISlice())) {
+                z = true;
+            }
+            this.sampleIsKeyframe = z2 | z;
+        }
+
+        private void outputSample(int i) {
+            boolean z = this.sampleIsKeyframe;
+            this.output.sampleMetadata(this.sampleTimeUs, z ? 1 : 0, (int) (this.nalUnitStartPosition - this.samplePosition), i, null);
+        }
+
+        public static final class SliceHeaderData {
+            private static final int SLICE_TYPE_ALL_I = 7;
+            private static final int SLICE_TYPE_I = 2;
+            private boolean bottomFieldFlag;
+            private boolean bottomFieldFlagPresent;
+            private int deltaPicOrderCnt0;
+            private int deltaPicOrderCnt1;
+            private int deltaPicOrderCntBottom;
+            private boolean fieldPicFlag;
+            private int frameNum;
+            private boolean hasSliceType;
+            private boolean idrPicFlag;
+            private int idrPicId;
+            private boolean isComplete;
+            private int nalRefIdc;
+            private int picOrderCntLsb;
+            private int picParameterSetId;
+            private int sliceType;
+            private NalUnitUtil.SpsData spsData;
+
+            private SliceHeaderData() {
+            }
+
+            public final void clear() {
+                this.hasSliceType = false;
+                this.isComplete = false;
+            }
+
+            public final boolean isISlice() {
+                int i;
+                return this.hasSliceType && ((i = this.sliceType) == 7 || i == 2);
+            }
+
+            public final void setAll(NalUnitUtil.SpsData spsData, int i, int i2, int i3, int i4, boolean z, boolean z2, boolean z3, boolean z4, int i5, int i6, int i7, int i8, int i9) {
+                this.spsData = spsData;
+                this.nalRefIdc = i;
+                this.sliceType = i2;
+                this.frameNum = i3;
+                this.picParameterSetId = i4;
+                this.fieldPicFlag = z;
+                this.bottomFieldFlagPresent = z2;
+                this.bottomFieldFlag = z3;
+                this.idrPicFlag = z4;
+                this.idrPicId = i5;
+                this.picOrderCntLsb = i6;
+                this.deltaPicOrderCntBottom = i7;
+                this.deltaPicOrderCnt0 = i8;
+                this.deltaPicOrderCnt1 = i9;
+                this.isComplete = true;
+                this.hasSliceType = true;
+            }
+
+            public final void setSliceType(int i) {
+                this.sliceType = i;
+                this.hasSliceType = true;
+            }
+
+            /* JADX INFO: Access modifiers changed from: private */
+            public boolean isFirstVclNalUnitOfPicture(SliceHeaderData sliceHeaderData) {
+                boolean z;
+                boolean z2;
+                if (this.isComplete) {
+                    if (!sliceHeaderData.isComplete || this.frameNum != sliceHeaderData.frameNum || this.picParameterSetId != sliceHeaderData.picParameterSetId || this.fieldPicFlag != sliceHeaderData.fieldPicFlag) {
+                        return true;
+                    }
+                    if (this.bottomFieldFlagPresent && sliceHeaderData.bottomFieldFlagPresent && this.bottomFieldFlag != sliceHeaderData.bottomFieldFlag) {
+                        return true;
+                    }
+                    int i = this.nalRefIdc;
+                    int i2 = sliceHeaderData.nalRefIdc;
+                    if (i != i2 && (i == 0 || i2 == 0)) {
+                        return true;
+                    }
+                    int i3 = this.spsData.picOrderCountType;
+                    if (i3 == 0 && sliceHeaderData.spsData.picOrderCountType == 0 && (this.picOrderCntLsb != sliceHeaderData.picOrderCntLsb || this.deltaPicOrderCntBottom != sliceHeaderData.deltaPicOrderCntBottom)) {
+                        return true;
+                    }
+                    if ((i3 == 1 && sliceHeaderData.spsData.picOrderCountType == 1 && (this.deltaPicOrderCnt0 != sliceHeaderData.deltaPicOrderCnt0 || this.deltaPicOrderCnt1 != sliceHeaderData.deltaPicOrderCnt1)) || (z = this.idrPicFlag) != (z2 = sliceHeaderData.idrPicFlag)) {
+                        return true;
+                    }
+                    if (z && z2 && this.idrPicId != sliceHeaderData.idrPicId) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/H265Reader.java

@@ -0,0 +1,388 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.NalUnitUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableNalUnitBitArray;
+import java.util.Collections;
+import kotlin.jvm.internal.ByteCompanionObject;
+
+/* loaded from: classes4.dex */
+public final class H265Reader implements ElementaryStreamReader {
+    private static final int BLA_W_LP = 16;
+    private static final int CRA_NUT = 21;
+    private static final int PPS_NUT = 34;
+    private static final int PREFIX_SEI_NUT = 39;
+    private static final int RASL_R = 9;
+    private static final int SPS_NUT = 33;
+    private static final int SUFFIX_SEI_NUT = 40;
+    private static final String TAG = "H265Reader";
+    private static final int VPS_NUT = 32;
+    private String formatId;
+    private boolean hasOutputFormat;
+    private TrackOutput output;
+    private long pesTimeUs;
+    private SampleReader sampleReader;
+    private final SeiReader seiReader;
+    private long totalBytesWritten;
+    private final boolean[] prefixFlags = new boolean[3];
+    private final NalUnitTargetBuffer vps = new NalUnitTargetBuffer(32, 128);
+    private final NalUnitTargetBuffer sps = new NalUnitTargetBuffer(33, 128);
+    private final NalUnitTargetBuffer pps = new NalUnitTargetBuffer(34, 128);
+    private final NalUnitTargetBuffer prefixSei = new NalUnitTargetBuffer(39, 128);
+    private final NalUnitTargetBuffer suffixSei = new NalUnitTargetBuffer(40, 128);
+    private final ParsableByteArray seiWrapper = new ParsableByteArray();
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        this.pesTimeUs = j;
+    }
+
+    public H265Reader(SeiReader seiReader) {
+        this.seiReader = seiReader;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        NalUnitUtil.clearPrefixFlags(this.prefixFlags);
+        this.vps.reset();
+        this.sps.reset();
+        this.pps.reset();
+        this.prefixSei.reset();
+        this.suffixSei.reset();
+        this.sampleReader.reset();
+        this.totalBytesWritten = 0L;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        this.formatId = trackIdGenerator.getFormatId();
+        TrackOutput track = extractorOutput.track(trackIdGenerator.getTrackId(), 2);
+        this.output = track;
+        this.sampleReader = new SampleReader(track);
+        this.seiReader.createTracks(extractorOutput, trackIdGenerator);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        while (parsableByteArray.bytesLeft() > 0) {
+            int position = parsableByteArray.getPosition();
+            int limit = parsableByteArray.limit();
+            byte[] bArr = parsableByteArray.data;
+            this.totalBytesWritten += parsableByteArray.bytesLeft();
+            this.output.sampleData(parsableByteArray, parsableByteArray.bytesLeft());
+            while (position < limit) {
+                int findNalUnit = NalUnitUtil.findNalUnit(bArr, position, limit, this.prefixFlags);
+                if (findNalUnit == limit) {
+                    nalUnitData(bArr, position, limit);
+                    return;
+                }
+                int h265NalUnitType = NalUnitUtil.getH265NalUnitType(bArr, findNalUnit);
+                int i = findNalUnit - position;
+                if (i > 0) {
+                    nalUnitData(bArr, position, findNalUnit);
+                }
+                int i2 = limit - findNalUnit;
+                long j = this.totalBytesWritten - i2;
+                endNalUnit(j, i2, i < 0 ? -i : 0, this.pesTimeUs);
+                startNalUnit(j, i2, h265NalUnitType, this.pesTimeUs);
+                position = findNalUnit + 3;
+            }
+        }
+    }
+
+    private void startNalUnit(long j, int i, int i2, long j2) {
+        if (this.hasOutputFormat) {
+            this.sampleReader.startNalUnit(j, i, i2, j2);
+        } else {
+            this.vps.startNalUnit(i2);
+            this.sps.startNalUnit(i2);
+            this.pps.startNalUnit(i2);
+        }
+        this.prefixSei.startNalUnit(i2);
+        this.suffixSei.startNalUnit(i2);
+    }
+
+    private void nalUnitData(byte[] bArr, int i, int i2) {
+        if (this.hasOutputFormat) {
+            this.sampleReader.readNalUnitData(bArr, i, i2);
+        } else {
+            this.vps.appendToNalUnit(bArr, i, i2);
+            this.sps.appendToNalUnit(bArr, i, i2);
+            this.pps.appendToNalUnit(bArr, i, i2);
+        }
+        this.prefixSei.appendToNalUnit(bArr, i, i2);
+        this.suffixSei.appendToNalUnit(bArr, i, i2);
+    }
+
+    private void endNalUnit(long j, int i, int i2, long j2) {
+        if (this.hasOutputFormat) {
+            this.sampleReader.endNalUnit(j, i);
+        } else {
+            this.vps.endNalUnit(i2);
+            this.sps.endNalUnit(i2);
+            this.pps.endNalUnit(i2);
+            if (this.vps.isCompleted() && this.sps.isCompleted() && this.pps.isCompleted()) {
+                this.output.format(parseMediaFormat(this.formatId, this.vps, this.sps, this.pps));
+                this.hasOutputFormat = true;
+            }
+        }
+        if (this.prefixSei.endNalUnit(i2)) {
+            NalUnitTargetBuffer nalUnitTargetBuffer = this.prefixSei;
+            this.seiWrapper.reset(this.prefixSei.nalData, NalUnitUtil.unescapeStream(nalUnitTargetBuffer.nalData, nalUnitTargetBuffer.nalLength));
+            this.seiWrapper.skipBytes(5);
+            this.seiReader.consume(j2, this.seiWrapper);
+        }
+        if (this.suffixSei.endNalUnit(i2)) {
+            NalUnitTargetBuffer nalUnitTargetBuffer2 = this.suffixSei;
+            this.seiWrapper.reset(this.suffixSei.nalData, NalUnitUtil.unescapeStream(nalUnitTargetBuffer2.nalData, nalUnitTargetBuffer2.nalLength));
+            this.seiWrapper.skipBytes(5);
+            this.seiReader.consume(j2, this.seiWrapper);
+        }
+    }
+
+    private static Format parseMediaFormat(String str, NalUnitTargetBuffer nalUnitTargetBuffer, NalUnitTargetBuffer nalUnitTargetBuffer2, NalUnitTargetBuffer nalUnitTargetBuffer3) {
+        float f;
+        int i = nalUnitTargetBuffer.nalLength;
+        byte[] bArr = new byte[nalUnitTargetBuffer2.nalLength + i + nalUnitTargetBuffer3.nalLength];
+        System.arraycopy(nalUnitTargetBuffer.nalData, 0, bArr, 0, i);
+        System.arraycopy(nalUnitTargetBuffer2.nalData, 0, bArr, nalUnitTargetBuffer.nalLength, nalUnitTargetBuffer2.nalLength);
+        System.arraycopy(nalUnitTargetBuffer3.nalData, 0, bArr, nalUnitTargetBuffer.nalLength + nalUnitTargetBuffer2.nalLength, nalUnitTargetBuffer3.nalLength);
+        ParsableNalUnitBitArray parsableNalUnitBitArray = new ParsableNalUnitBitArray(nalUnitTargetBuffer2.nalData, 0, nalUnitTargetBuffer2.nalLength);
+        parsableNalUnitBitArray.skipBits(44);
+        int readBits = parsableNalUnitBitArray.readBits(3);
+        parsableNalUnitBitArray.skipBit();
+        parsableNalUnitBitArray.skipBits(88);
+        parsableNalUnitBitArray.skipBits(8);
+        int i2 = 0;
+        for (int i3 = 0; i3 < readBits; i3++) {
+            if (parsableNalUnitBitArray.readBit()) {
+                i2 += 89;
+            }
+            if (parsableNalUnitBitArray.readBit()) {
+                i2 += 8;
+            }
+        }
+        parsableNalUnitBitArray.skipBits(i2);
+        if (readBits > 0) {
+            parsableNalUnitBitArray.skipBits((8 - readBits) * 2);
+        }
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        int readUnsignedExpGolombCodedInt = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        if (readUnsignedExpGolombCodedInt == 3) {
+            parsableNalUnitBitArray.skipBit();
+        }
+        int readUnsignedExpGolombCodedInt2 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        int readUnsignedExpGolombCodedInt3 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        if (parsableNalUnitBitArray.readBit()) {
+            int readUnsignedExpGolombCodedInt4 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+            int readUnsignedExpGolombCodedInt5 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+            int readUnsignedExpGolombCodedInt6 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+            int readUnsignedExpGolombCodedInt7 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+            readUnsignedExpGolombCodedInt2 -= ((readUnsignedExpGolombCodedInt == 1 || readUnsignedExpGolombCodedInt == 2) ? 2 : 1) * (readUnsignedExpGolombCodedInt4 + readUnsignedExpGolombCodedInt5);
+            readUnsignedExpGolombCodedInt3 -= (readUnsignedExpGolombCodedInt == 1 ? 2 : 1) * (readUnsignedExpGolombCodedInt6 + readUnsignedExpGolombCodedInt7);
+        }
+        int i4 = readUnsignedExpGolombCodedInt2;
+        int i5 = readUnsignedExpGolombCodedInt3;
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        int readUnsignedExpGolombCodedInt8 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        for (int i6 = parsableNalUnitBitArray.readBit() ? 0 : readBits; i6 <= readBits; i6++) {
+            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        }
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        if (parsableNalUnitBitArray.readBit() && parsableNalUnitBitArray.readBit()) {
+            skipScalingList(parsableNalUnitBitArray);
+        }
+        parsableNalUnitBitArray.skipBits(2);
+        if (parsableNalUnitBitArray.readBit()) {
+            parsableNalUnitBitArray.skipBits(8);
+            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+            parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+            parsableNalUnitBitArray.skipBit();
+        }
+        skipShortTermRefPicSets(parsableNalUnitBitArray);
+        if (parsableNalUnitBitArray.readBit()) {
+            for (int i7 = 0; i7 < parsableNalUnitBitArray.readUnsignedExpGolombCodedInt(); i7++) {
+                parsableNalUnitBitArray.skipBits(readUnsignedExpGolombCodedInt8 + 5);
+            }
+        }
+        parsableNalUnitBitArray.skipBits(2);
+        float f2 = 1.0f;
+        if (parsableNalUnitBitArray.readBit() && parsableNalUnitBitArray.readBit()) {
+            int readBits2 = parsableNalUnitBitArray.readBits(8);
+            if (readBits2 == 255) {
+                int readBits3 = parsableNalUnitBitArray.readBits(16);
+                int readBits4 = parsableNalUnitBitArray.readBits(16);
+                if (readBits3 != 0 && readBits4 != 0) {
+                    f2 = readBits3 / readBits4;
+                }
+            } else {
+                float[] fArr = NalUnitUtil.ASPECT_RATIO_IDC_VALUES;
+                if (readBits2 < fArr.length) {
+                    f = fArr[readBits2];
+                    return Format.createVideoSampleFormat(str, "video/hevc", null, -1, -1, i4, i5, -1.0f, Collections.singletonList(bArr), -1, f, null);
+                }
+                Log.w(TAG, "Unexpected aspect_ratio_idc value: " + readBits2);
+            }
+        }
+        f = f2;
+        return Format.createVideoSampleFormat(str, "video/hevc", null, -1, -1, i4, i5, -1.0f, Collections.singletonList(bArr), -1, f, null);
+    }
+
+    private static void skipScalingList(ParsableNalUnitBitArray parsableNalUnitBitArray) {
+        for (int i = 0; i < 4; i++) {
+            int i2 = 0;
+            while (i2 < 6) {
+                int i3 = 1;
+                if (!parsableNalUnitBitArray.readBit()) {
+                    parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+                } else {
+                    int min = Math.min(64, 1 << ((i << 1) + 4));
+                    if (i > 1) {
+                        parsableNalUnitBitArray.readSignedExpGolombCodedInt();
+                    }
+                    for (int i4 = 0; i4 < min; i4++) {
+                        parsableNalUnitBitArray.readSignedExpGolombCodedInt();
+                    }
+                }
+                if (i == 3) {
+                    i3 = 3;
+                }
+                i2 += i3;
+            }
+        }
+    }
+
+    private static void skipShortTermRefPicSets(ParsableNalUnitBitArray parsableNalUnitBitArray) {
+        int readUnsignedExpGolombCodedInt = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+        boolean z = false;
+        int i = 0;
+        for (int i2 = 0; i2 < readUnsignedExpGolombCodedInt; i2++) {
+            if (i2 != 0) {
+                z = parsableNalUnitBitArray.readBit();
+            }
+            if (z) {
+                parsableNalUnitBitArray.skipBit();
+                parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+                for (int i3 = 0; i3 <= i; i3++) {
+                    if (parsableNalUnitBitArray.readBit()) {
+                        parsableNalUnitBitArray.skipBit();
+                    }
+                }
+            } else {
+                int readUnsignedExpGolombCodedInt2 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+                int readUnsignedExpGolombCodedInt3 = parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+                int i4 = readUnsignedExpGolombCodedInt2 + readUnsignedExpGolombCodedInt3;
+                for (int i5 = 0; i5 < readUnsignedExpGolombCodedInt2; i5++) {
+                    parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+                    parsableNalUnitBitArray.skipBit();
+                }
+                for (int i6 = 0; i6 < readUnsignedExpGolombCodedInt3; i6++) {
+                    parsableNalUnitBitArray.readUnsignedExpGolombCodedInt();
+                    parsableNalUnitBitArray.skipBit();
+                }
+                i = i4;
+            }
+        }
+    }
+
+    public static final class SampleReader {
+        private static final int FIRST_SLICE_FLAG_OFFSET = 2;
+        private boolean isFirstParameterSet;
+        private boolean isFirstSlice;
+        private boolean lookingForFirstSliceFlag;
+        private int nalUnitBytesRead;
+        private boolean nalUnitHasKeyframeData;
+        private long nalUnitStartPosition;
+        private long nalUnitTimeUs;
+        private final TrackOutput output;
+        private boolean readingSample;
+        private boolean sampleIsKeyframe;
+        private long samplePosition;
+        private long sampleTimeUs;
+        private boolean writingParameterSets;
+
+        public final void reset() {
+            this.lookingForFirstSliceFlag = false;
+            this.isFirstSlice = false;
+            this.isFirstParameterSet = false;
+            this.readingSample = false;
+            this.writingParameterSets = false;
+        }
+
+        public SampleReader(TrackOutput trackOutput) {
+            this.output = trackOutput;
+        }
+
+        public final void startNalUnit(long j, int i, int i2, long j2) {
+            this.isFirstSlice = false;
+            this.isFirstParameterSet = false;
+            this.nalUnitTimeUs = j2;
+            this.nalUnitBytesRead = 0;
+            this.nalUnitStartPosition = j;
+            if (i2 >= 32) {
+                if (!this.writingParameterSets && this.readingSample) {
+                    outputSample(i);
+                    this.readingSample = false;
+                }
+                if (i2 <= 34) {
+                    this.isFirstParameterSet = !this.writingParameterSets;
+                    this.writingParameterSets = true;
+                }
+            }
+            boolean z = i2 >= 16 && i2 <= 21;
+            this.nalUnitHasKeyframeData = z;
+            this.lookingForFirstSliceFlag = z || i2 <= 9;
+        }
+
+        public final void readNalUnitData(byte[] bArr, int i, int i2) {
+            if (this.lookingForFirstSliceFlag) {
+                int i3 = this.nalUnitBytesRead;
+                int i4 = (i + 2) - i3;
+                if (i4 >= i2) {
+                    this.nalUnitBytesRead = i3 + (i2 - i);
+                } else {
+                    this.isFirstSlice = (bArr[i4] & ByteCompanionObject.MIN_VALUE) != 0;
+                    this.lookingForFirstSliceFlag = false;
+                }
+            }
+        }
+
+        public final void endNalUnit(long j, int i) {
+            if (this.writingParameterSets && this.isFirstSlice) {
+                this.sampleIsKeyframe = this.nalUnitHasKeyframeData;
+                this.writingParameterSets = false;
+            } else if (this.isFirstParameterSet || this.isFirstSlice) {
+                if (this.readingSample) {
+                    outputSample(i + ((int) (j - this.nalUnitStartPosition)));
+                }
+                this.samplePosition = this.nalUnitStartPosition;
+                this.sampleTimeUs = this.nalUnitTimeUs;
+                this.readingSample = true;
+                this.sampleIsKeyframe = this.nalUnitHasKeyframeData;
+            }
+        }
+
+        private void outputSample(int i) {
+            boolean z = this.sampleIsKeyframe;
+            this.output.sampleMetadata(this.sampleTimeUs, z ? 1 : 0, (int) (this.nalUnitStartPosition - this.samplePosition), i, null);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/Id3Reader.java

@@ -0,0 +1,79 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+
+/* loaded from: classes4.dex */
+public final class Id3Reader implements ElementaryStreamReader {
+    private static final int ID3_HEADER_SIZE = 10;
+    private static final String TAG = "Id3Reader";
+    private final ParsableByteArray id3Header = new ParsableByteArray(10);
+    private TrackOutput output;
+    private int sampleBytesRead;
+    private int sampleSize;
+    private long sampleTimeUs;
+    private boolean writingSample;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        if (z) {
+            this.writingSample = true;
+            this.sampleTimeUs = j;
+            this.sampleSize = 0;
+            this.sampleBytesRead = 0;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        this.writingSample = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        TrackOutput track = extractorOutput.track(trackIdGenerator.getTrackId(), 4);
+        this.output = track;
+        track.format(Format.createSampleFormat(trackIdGenerator.getFormatId(), MimeTypes.APPLICATION_ID3, null, -1, null));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        if (this.writingSample) {
+            int bytesLeft = parsableByteArray.bytesLeft();
+            int i = this.sampleBytesRead;
+            if (i < 10) {
+                int min = Math.min(bytesLeft, 10 - i);
+                System.arraycopy(parsableByteArray.data, parsableByteArray.getPosition(), this.id3Header.data, this.sampleBytesRead, min);
+                if (this.sampleBytesRead + min == 10) {
+                    this.id3Header.setPosition(0);
+                    if (73 != this.id3Header.readUnsignedByte() || 68 != this.id3Header.readUnsignedByte() || 51 != this.id3Header.readUnsignedByte()) {
+                        Log.w(TAG, "Discarding invalid ID3 tag");
+                        this.writingSample = false;
+                        return;
+                    } else {
+                        this.id3Header.skipBytes(3);
+                        this.sampleSize = this.id3Header.readSynchSafeInt() + 10;
+                    }
+                }
+            }
+            int min2 = Math.min(bytesLeft, this.sampleSize - this.sampleBytesRead);
+            this.output.sampleData(parsableByteArray, min2);
+            this.sampleBytesRead += min2;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+        int i;
+        if (this.writingSample && (i = this.sampleSize) != 0 && this.sampleBytesRead == i) {
+            this.output.sampleMetadata(this.sampleTimeUs, 1, i, 0, null);
+            this.writingSample = false;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/LatmReader.java

@@ -0,0 +1,248 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.CodecSpecificDataUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.Collections;
+
+/* loaded from: classes4.dex */
+public final class LatmReader implements ElementaryStreamReader {
+    private static final int INITIAL_BUFFER_SIZE = 1024;
+    private static final int STATE_FINDING_SYNC_1 = 0;
+    private static final int STATE_FINDING_SYNC_2 = 1;
+    private static final int STATE_READING_HEADER = 2;
+    private static final int STATE_READING_SAMPLE = 3;
+    private static final int SYNC_BYTE_FIRST = 86;
+    private static final int SYNC_BYTE_SECOND = 224;
+    private int audioMuxVersionA;
+    private int bytesRead;
+    private int channelCount;
+    private Format format;
+    private String formatId;
+    private int frameLengthType;
+    private final String language;
+    private int numSubframes;
+    private long otherDataLenBits;
+    private boolean otherDataPresent;
+    private TrackOutput output;
+    private final ParsableBitArray sampleBitArray;
+    private final ParsableByteArray sampleDataBuffer;
+    private long sampleDurationUs;
+    private int sampleRateHz;
+    private int sampleSize;
+    private int secondHeaderByte;
+    private int state;
+    private boolean streamMuxRead;
+    private long timeUs;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        this.timeUs = j;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        this.state = 0;
+        this.streamMuxRead = false;
+    }
+
+    public LatmReader(@Nullable String str) {
+        this.language = str;
+        ParsableByteArray parsableByteArray = new ParsableByteArray(1024);
+        this.sampleDataBuffer = parsableByteArray;
+        this.sampleBitArray = new ParsableBitArray(parsableByteArray.data);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        this.output = extractorOutput.track(trackIdGenerator.getTrackId(), 1);
+        this.formatId = trackIdGenerator.getFormatId();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) throws ParserException {
+        while (parsableByteArray.bytesLeft() > 0) {
+            int i = this.state;
+            if (i != 0) {
+                if (i == 1) {
+                    int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                    if ((readUnsignedByte & 224) == 224) {
+                        this.secondHeaderByte = readUnsignedByte;
+                        this.state = 2;
+                    } else if (readUnsignedByte != SYNC_BYTE_FIRST) {
+                        this.state = 0;
+                    }
+                } else if (i == 2) {
+                    int readUnsignedByte2 = ((this.secondHeaderByte & (-225)) << 8) | parsableByteArray.readUnsignedByte();
+                    this.sampleSize = readUnsignedByte2;
+                    if (readUnsignedByte2 > this.sampleDataBuffer.data.length) {
+                        resetBufferForSize(readUnsignedByte2);
+                    }
+                    this.bytesRead = 0;
+                    this.state = 3;
+                } else if (i == 3) {
+                    int min = Math.min(parsableByteArray.bytesLeft(), this.sampleSize - this.bytesRead);
+                    parsableByteArray.readBytes(this.sampleBitArray.data, this.bytesRead, min);
+                    int i2 = this.bytesRead + min;
+                    this.bytesRead = i2;
+                    if (i2 == this.sampleSize) {
+                        this.sampleBitArray.setPosition(0);
+                        parseAudioMuxElement(this.sampleBitArray);
+                        this.state = 0;
+                    }
+                }
+            } else if (parsableByteArray.readUnsignedByte() == SYNC_BYTE_FIRST) {
+                this.state = 1;
+            }
+        }
+    }
+
+    private void parseAudioMuxElement(ParsableBitArray parsableBitArray) throws ParserException {
+        if (!parsableBitArray.readBit()) {
+            this.streamMuxRead = true;
+            parseStreamMuxConfig(parsableBitArray);
+        } else if (!this.streamMuxRead) {
+            return;
+        }
+        if (this.audioMuxVersionA != 0) {
+            throw new ParserException();
+        }
+        if (this.numSubframes != 0) {
+            throw new ParserException();
+        }
+        parsePayloadMux(parsableBitArray, parsePayloadLengthInfo(parsableBitArray));
+        if (this.otherDataPresent) {
+            parsableBitArray.skipBits((int) this.otherDataLenBits);
+        }
+    }
+
+    private void parseStreamMuxConfig(ParsableBitArray parsableBitArray) throws ParserException {
+        boolean readBit;
+        int readBits = parsableBitArray.readBits(1);
+        int readBits2 = readBits == 1 ? parsableBitArray.readBits(1) : 0;
+        this.audioMuxVersionA = readBits2;
+        if (readBits2 == 0) {
+            if (readBits == 1) {
+                latmGetValue(parsableBitArray);
+            }
+            if (!parsableBitArray.readBit()) {
+                throw new ParserException();
+            }
+            this.numSubframes = parsableBitArray.readBits(6);
+            int readBits3 = parsableBitArray.readBits(4);
+            int readBits4 = parsableBitArray.readBits(3);
+            if (readBits3 != 0 || readBits4 != 0) {
+                throw new ParserException();
+            }
+            if (readBits == 0) {
+                int position = parsableBitArray.getPosition();
+                int parseAudioSpecificConfig = parseAudioSpecificConfig(parsableBitArray);
+                parsableBitArray.setPosition(position);
+                byte[] bArr = new byte[(parseAudioSpecificConfig + 7) / 8];
+                parsableBitArray.readBits(bArr, 0, parseAudioSpecificConfig);
+                Format createAudioSampleFormat = Format.createAudioSampleFormat(this.formatId, MimeTypes.AUDIO_AAC, null, -1, -1, this.channelCount, this.sampleRateHz, Collections.singletonList(bArr), null, 0, this.language);
+                if (!createAudioSampleFormat.equals(this.format)) {
+                    this.format = createAudioSampleFormat;
+                    this.sampleDurationUs = 1024000000 / createAudioSampleFormat.sampleRate;
+                    this.output.format(createAudioSampleFormat);
+                }
+            } else {
+                parsableBitArray.skipBits(((int) latmGetValue(parsableBitArray)) - parseAudioSpecificConfig(parsableBitArray));
+            }
+            parseFrameLength(parsableBitArray);
+            boolean readBit2 = parsableBitArray.readBit();
+            this.otherDataPresent = readBit2;
+            this.otherDataLenBits = 0L;
+            if (readBit2) {
+                if (readBits == 1) {
+                    this.otherDataLenBits = latmGetValue(parsableBitArray);
+                } else {
+                    do {
+                        readBit = parsableBitArray.readBit();
+                        this.otherDataLenBits = (this.otherDataLenBits << 8) + parsableBitArray.readBits(8);
+                    } while (readBit);
+                }
+            }
+            if (parsableBitArray.readBit()) {
+                parsableBitArray.skipBits(8);
+                return;
+            }
+            return;
+        }
+        throw new ParserException();
+    }
+
+    private void parseFrameLength(ParsableBitArray parsableBitArray) {
+        int readBits = parsableBitArray.readBits(3);
+        this.frameLengthType = readBits;
+        if (readBits == 0) {
+            parsableBitArray.skipBits(8);
+            return;
+        }
+        if (readBits == 1) {
+            parsableBitArray.skipBits(9);
+            return;
+        }
+        if (readBits == 3 || readBits == 4 || readBits == 5) {
+            parsableBitArray.skipBits(6);
+        } else if (readBits == 6 || readBits == 7) {
+            parsableBitArray.skipBits(1);
+        }
+    }
+
+    private int parseAudioSpecificConfig(ParsableBitArray parsableBitArray) throws ParserException {
+        int bitsLeft = parsableBitArray.bitsLeft();
+        Pair<Integer, Integer> parseAacAudioSpecificConfig = CodecSpecificDataUtil.parseAacAudioSpecificConfig(parsableBitArray, true);
+        this.sampleRateHz = ((Integer) parseAacAudioSpecificConfig.first).intValue();
+        this.channelCount = ((Integer) parseAacAudioSpecificConfig.second).intValue();
+        return bitsLeft - parsableBitArray.bitsLeft();
+    }
+
+    private int parsePayloadLengthInfo(ParsableBitArray parsableBitArray) throws ParserException {
+        int readBits;
+        if (this.frameLengthType != 0) {
+            throw new ParserException();
+        }
+        int i = 0;
+        do {
+            readBits = parsableBitArray.readBits(8);
+            i += readBits;
+        } while (readBits == 255);
+        return i;
+    }
+
+    private void parsePayloadMux(ParsableBitArray parsableBitArray, int i) {
+        int position = parsableBitArray.getPosition();
+        if ((position & 7) == 0) {
+            this.sampleDataBuffer.setPosition(position >> 3);
+        } else {
+            parsableBitArray.readBits(this.sampleDataBuffer.data, 0, i * 8);
+            this.sampleDataBuffer.setPosition(0);
+        }
+        this.output.sampleData(this.sampleDataBuffer, i);
+        this.output.sampleMetadata(this.timeUs, 1, i, 0, null);
+        this.timeUs += this.sampleDurationUs;
+    }
+
+    private void resetBufferForSize(int i) {
+        this.sampleDataBuffer.reset(i);
+        this.sampleBitArray.reset(this.sampleDataBuffer.data);
+    }
+
+    private static long latmGetValue(ParsableBitArray parsableBitArray) {
+        return parsableBitArray.readBits((parsableBitArray.readBits(2) + 1) * 8);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/MpegAudioReader.java

@@ -0,0 +1,140 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.MpegAudioHeader;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+
+/* loaded from: classes4.dex */
+public final class MpegAudioReader implements ElementaryStreamReader {
+    private static final int HEADER_SIZE = 4;
+    private static final int STATE_FINDING_HEADER = 0;
+    private static final int STATE_READING_FRAME = 2;
+    private static final int STATE_READING_HEADER = 1;
+    private String formatId;
+    private int frameBytesRead;
+    private long frameDurationUs;
+    private int frameSize;
+    private boolean hasOutputFormat;
+    private final MpegAudioHeader header;
+    private final ParsableByteArray headerScratch;
+    private final String language;
+    private boolean lastByteWasFF;
+    private TrackOutput output;
+    private int state;
+    private long timeUs;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetFinished() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void packetStarted(long j, boolean z) {
+        this.timeUs = j;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void seek() {
+        this.state = 0;
+        this.frameBytesRead = 0;
+        this.lastByteWasFF = false;
+    }
+
+    public MpegAudioReader() {
+        this(null);
+    }
+
+    public MpegAudioReader(String str) {
+        this.state = 0;
+        ParsableByteArray parsableByteArray = new ParsableByteArray(4);
+        this.headerScratch = parsableByteArray;
+        parsableByteArray.data[0] = -1;
+        this.header = new MpegAudioHeader();
+        this.language = str;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        trackIdGenerator.generateNewId();
+        this.formatId = trackIdGenerator.getFormatId();
+        this.output = extractorOutput.track(trackIdGenerator.getTrackId(), 1);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.ElementaryStreamReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        while (parsableByteArray.bytesLeft() > 0) {
+            int i = this.state;
+            if (i == 0) {
+                findHeader(parsableByteArray);
+            } else if (i == 1) {
+                readHeaderRemainder(parsableByteArray);
+            } else if (i == 2) {
+                readFrameRemainder(parsableByteArray);
+            }
+        }
+    }
+
+    private void findHeader(ParsableByteArray parsableByteArray) {
+        byte[] bArr = parsableByteArray.data;
+        int limit = parsableByteArray.limit();
+        for (int position = parsableByteArray.getPosition(); position < limit; position++) {
+            byte b = bArr[position];
+            boolean z = (b & 255) == 255;
+            boolean z2 = this.lastByteWasFF && (b & 224) == 224;
+            this.lastByteWasFF = z;
+            if (z2) {
+                parsableByteArray.setPosition(position + 1);
+                this.lastByteWasFF = false;
+                this.headerScratch.data[1] = bArr[position];
+                this.frameBytesRead = 2;
+                this.state = 1;
+                return;
+            }
+        }
+        parsableByteArray.setPosition(limit);
+    }
+
+    private void readHeaderRemainder(ParsableByteArray parsableByteArray) {
+        int min = Math.min(parsableByteArray.bytesLeft(), 4 - this.frameBytesRead);
+        parsableByteArray.readBytes(this.headerScratch.data, this.frameBytesRead, min);
+        int i = this.frameBytesRead + min;
+        this.frameBytesRead = i;
+        if (i < 4) {
+            return;
+        }
+        this.headerScratch.setPosition(0);
+        if (!MpegAudioHeader.populateHeader(this.headerScratch.readInt(), this.header)) {
+            this.frameBytesRead = 0;
+            this.state = 1;
+            return;
+        }
+        MpegAudioHeader mpegAudioHeader = this.header;
+        this.frameSize = mpegAudioHeader.frameSize;
+        if (!this.hasOutputFormat) {
+            int i2 = mpegAudioHeader.sampleRate;
+            this.frameDurationUs = (mpegAudioHeader.samplesPerFrame * 1000000) / i2;
+            this.output.format(Format.createAudioSampleFormat(this.formatId, mpegAudioHeader.mimeType, null, -1, 4096, mpegAudioHeader.channels, i2, null, null, 0, this.language));
+            this.hasOutputFormat = true;
+        }
+        this.headerScratch.setPosition(0);
+        this.output.sampleData(this.headerScratch, 4);
+        this.state = 2;
+    }
+
+    private void readFrameRemainder(ParsableByteArray parsableByteArray) {
+        int min = Math.min(parsableByteArray.bytesLeft(), this.frameSize - this.frameBytesRead);
+        this.output.sampleData(parsableByteArray, min);
+        int i = this.frameBytesRead + min;
+        this.frameBytesRead = i;
+        int i2 = this.frameSize;
+        if (i < i2) {
+            return;
+        }
+        this.output.sampleMetadata(this.timeUs, 1, i2, 0, null);
+        this.timeUs += this.frameDurationUs;
+        this.frameBytesRead = 0;
+        this.state = 0;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/NalUnitTargetBuffer.java

@@ -0,0 +1,63 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+final class NalUnitTargetBuffer {
+    private boolean isCompleted;
+    private boolean isFilling;
+    public byte[] nalData;
+    public int nalLength;
+    private final int targetType;
+
+    public final boolean endNalUnit(int i) {
+        if (!this.isFilling) {
+            return false;
+        }
+        this.nalLength -= i;
+        this.isFilling = false;
+        this.isCompleted = true;
+        return true;
+    }
+
+    public final boolean isCompleted() {
+        return this.isCompleted;
+    }
+
+    public final void reset() {
+        this.isFilling = false;
+        this.isCompleted = false;
+    }
+
+    public NalUnitTargetBuffer(int i, int i2) {
+        this.targetType = i;
+        byte[] bArr = new byte[i2 + 3];
+        this.nalData = bArr;
+        bArr[2] = 1;
+    }
+
+    public final void startNalUnit(int i) {
+        Assertions.checkState(!this.isFilling);
+        boolean z = i == this.targetType;
+        this.isFilling = z;
+        if (z) {
+            this.nalLength = 3;
+            this.isCompleted = false;
+        }
+    }
+
+    public final void appendToNalUnit(byte[] bArr, int i, int i2) {
+        if (this.isFilling) {
+            int i3 = i2 - i;
+            byte[] bArr2 = this.nalData;
+            int length = bArr2.length;
+            int i4 = this.nalLength;
+            if (length < i4 + i3) {
+                this.nalData = Arrays.copyOf(bArr2, (i4 + i3) * 2);
+            }
+            System.arraycopy(bArr, i, this.nalData, this.nalLength, i3);
+            this.nalLength += i3;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/PesReader.java

@@ -0,0 +1,171 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+
+/* loaded from: classes4.dex */
+public final class PesReader implements TsPayloadReader {
+    private static final int HEADER_SIZE = 9;
+    private static final int MAX_HEADER_EXTENSION_SIZE = 10;
+    private static final int PES_SCRATCH_SIZE = 10;
+    private static final int STATE_FINDING_HEADER = 0;
+    private static final int STATE_READING_BODY = 3;
+    private static final int STATE_READING_HEADER = 1;
+    private static final int STATE_READING_HEADER_EXTENSION = 2;
+    private static final String TAG = "PesReader";
+    private int bytesRead;
+    private boolean dataAlignmentIndicator;
+    private boolean dtsFlag;
+    private int extendedHeaderLength;
+    private int payloadSize;
+    private boolean ptsFlag;
+    private final ElementaryStreamReader reader;
+    private boolean seenFirstDts;
+    private long timeUs;
+    private TimestampAdjuster timestampAdjuster;
+    private final ParsableBitArray pesScratch = new ParsableBitArray(new byte[10]);
+    private int state = 0;
+
+    private void setState(int i) {
+        this.state = i;
+        this.bytesRead = 0;
+    }
+
+    public PesReader(ElementaryStreamReader elementaryStreamReader) {
+        this.reader = elementaryStreamReader;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader
+    public final void init(TimestampAdjuster timestampAdjuster, ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        this.timestampAdjuster = timestampAdjuster;
+        this.reader.createTracks(extractorOutput, trackIdGenerator);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader
+    public final void seek() {
+        this.state = 0;
+        this.bytesRead = 0;
+        this.seenFirstDts = false;
+        this.reader.seek();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader
+    public final void consume(ParsableByteArray parsableByteArray, boolean z) throws ParserException {
+        if (z) {
+            int i = this.state;
+            if (i == 2) {
+                Log.w(TAG, "Unexpected start indicator reading extended header");
+            } else if (i == 3) {
+                if (this.payloadSize != -1) {
+                    Log.w(TAG, "Unexpected start indicator: expected " + this.payloadSize + " more bytes");
+                }
+                this.reader.packetFinished();
+            }
+            setState(1);
+        }
+        while (parsableByteArray.bytesLeft() > 0) {
+            int i2 = this.state;
+            if (i2 != 0) {
+                if (i2 != 1) {
+                    if (i2 == 2) {
+                        if (continueRead(parsableByteArray, this.pesScratch.data, Math.min(10, this.extendedHeaderLength)) && continueRead(parsableByteArray, null, this.extendedHeaderLength)) {
+                            parseHeaderExtension();
+                            this.reader.packetStarted(this.timeUs, this.dataAlignmentIndicator);
+                            setState(3);
+                        }
+                    } else if (i2 == 3) {
+                        int bytesLeft = parsableByteArray.bytesLeft();
+                        int i3 = this.payloadSize;
+                        int i4 = i3 != -1 ? bytesLeft - i3 : 0;
+                        if (i4 > 0) {
+                            bytesLeft -= i4;
+                            parsableByteArray.setLimit(parsableByteArray.getPosition() + bytesLeft);
+                        }
+                        this.reader.consume(parsableByteArray);
+                        int i5 = this.payloadSize;
+                        if (i5 != -1) {
+                            int i6 = i5 - bytesLeft;
+                            this.payloadSize = i6;
+                            if (i6 == 0) {
+                                this.reader.packetFinished();
+                                setState(1);
+                            }
+                        }
+                    }
+                } else if (continueRead(parsableByteArray, this.pesScratch.data, 9)) {
+                    setState(parseHeader() ? 2 : 0);
+                }
+            } else {
+                parsableByteArray.skipBytes(parsableByteArray.bytesLeft());
+            }
+        }
+    }
+
+    private boolean continueRead(ParsableByteArray parsableByteArray, byte[] bArr, int i) {
+        int min = Math.min(parsableByteArray.bytesLeft(), i - this.bytesRead);
+        if (min <= 0) {
+            return true;
+        }
+        if (bArr == null) {
+            parsableByteArray.skipBytes(min);
+        } else {
+            parsableByteArray.readBytes(bArr, this.bytesRead, min);
+        }
+        int i2 = this.bytesRead + min;
+        this.bytesRead = i2;
+        return i2 == i;
+    }
+
+    private boolean parseHeader() {
+        this.pesScratch.setPosition(0);
+        int readBits = this.pesScratch.readBits(24);
+        if (readBits != 1) {
+            Log.w(TAG, "Unexpected start code prefix: " + readBits);
+            this.payloadSize = -1;
+            return false;
+        }
+        this.pesScratch.skipBits(8);
+        int readBits2 = this.pesScratch.readBits(16);
+        this.pesScratch.skipBits(5);
+        this.dataAlignmentIndicator = this.pesScratch.readBit();
+        this.pesScratch.skipBits(2);
+        this.ptsFlag = this.pesScratch.readBit();
+        this.dtsFlag = this.pesScratch.readBit();
+        this.pesScratch.skipBits(6);
+        int readBits3 = this.pesScratch.readBits(8);
+        this.extendedHeaderLength = readBits3;
+        if (readBits2 == 0) {
+            this.payloadSize = -1;
+        } else {
+            this.payloadSize = (readBits2 - 3) - readBits3;
+        }
+        return true;
+    }
+
+    private void parseHeaderExtension() {
+        this.pesScratch.setPosition(0);
+        this.timeUs = C.TIME_UNSET;
+        if (this.ptsFlag) {
+            this.pesScratch.skipBits(4);
+            this.pesScratch.skipBits(1);
+            this.pesScratch.skipBits(1);
+            long readBits = (this.pesScratch.readBits(3) << 30) | (this.pesScratch.readBits(15) << 15) | this.pesScratch.readBits(15);
+            this.pesScratch.skipBits(1);
+            if (!this.seenFirstDts && this.dtsFlag) {
+                this.pesScratch.skipBits(4);
+                this.pesScratch.skipBits(1);
+                this.pesScratch.skipBits(1);
+                this.pesScratch.skipBits(1);
+                this.timestampAdjuster.adjustTsTimestamp((this.pesScratch.readBits(3) << 30) | (this.pesScratch.readBits(15) << 15) | this.pesScratch.readBits(15));
+                this.seenFirstDts = true;
+            }
+            this.timeUs = this.timestampAdjuster.adjustTsTimestamp(readBits);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/PsExtractor.java

@@ -0,0 +1,221 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.SparseArray;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class PsExtractor implements Extractor {
+    public static final int AUDIO_STREAM = 192;
+    public static final int AUDIO_STREAM_MASK = 224;
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new PsExtractor()};
+        }
+    };
+    private static final long MAX_SEARCH_LENGTH = 1048576;
+    private static final long MAX_SEARCH_LENGTH_AFTER_AUDIO_AND_VIDEO_FOUND = 8192;
+    private static final int MAX_STREAM_ID_PLUS_ONE = 256;
+    private static final int MPEG_PROGRAM_END_CODE = 441;
+    private static final int PACKET_START_CODE_PREFIX = 1;
+    private static final int PACK_START_CODE = 442;
+    public static final int PRIVATE_STREAM_1 = 189;
+    private static final int SYSTEM_HEADER_START_CODE = 443;
+    public static final int VIDEO_STREAM = 224;
+    public static final int VIDEO_STREAM_MASK = 240;
+    private boolean foundAllTracks;
+    private boolean foundAudioTrack;
+    private boolean foundVideoTrack;
+    private long lastTrackPosition;
+    private ExtractorOutput output;
+    private final ParsableByteArray psPacketBuffer;
+    private final SparseArray<PesReader> psPayloadReaders;
+    private final TimestampAdjuster timestampAdjuster;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    public PsExtractor() {
+        this(new TimestampAdjuster(0L));
+    }
+
+    public PsExtractor(TimestampAdjuster timestampAdjuster) {
+        this.timestampAdjuster = timestampAdjuster;
+        this.psPacketBuffer = new ParsableByteArray(4096);
+        this.psPayloadReaders = new SparseArray<>();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        byte[] bArr = new byte[14];
+        extractorInput.peekFully(bArr, 0, 14);
+        if (PACK_START_CODE != (((bArr[0] & 255) << 24) | ((bArr[1] & 255) << 16) | ((bArr[2] & 255) << 8) | (bArr[3] & 255)) || (bArr[4] & 196) != 68 || (bArr[6] & 4) != 4 || (bArr[8] & 4) != 4 || (bArr[9] & 1) != 1 || (bArr[12] & 3) != 3) {
+            return false;
+        }
+        extractorInput.advancePeekPosition(bArr[13] & 7);
+        extractorInput.peekFully(bArr, 0, 3);
+        return 1 == ((((bArr[0] & 255) << 16) | ((bArr[1] & 255) << 8)) | (bArr[2] & 255));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        this.output = extractorOutput;
+        extractorOutput.seekMap(new SeekMap.Unseekable(C.TIME_UNSET));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.timestampAdjuster.reset();
+        for (int i = 0; i < this.psPayloadReaders.size(); i++) {
+            this.psPayloadReaders.valueAt(i).seek();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        ElementaryStreamReader elementaryStreamReader;
+        if (!extractorInput.peekFully(this.psPacketBuffer.data, 0, 4, true)) {
+            return -1;
+        }
+        this.psPacketBuffer.setPosition(0);
+        int readInt = this.psPacketBuffer.readInt();
+        if (readInt == MPEG_PROGRAM_END_CODE) {
+            return -1;
+        }
+        if (readInt == PACK_START_CODE) {
+            extractorInput.peekFully(this.psPacketBuffer.data, 0, 10);
+            this.psPacketBuffer.setPosition(9);
+            extractorInput.skipFully((this.psPacketBuffer.readUnsignedByte() & 7) + 14);
+            return 0;
+        }
+        if (readInt == 443) {
+            extractorInput.peekFully(this.psPacketBuffer.data, 0, 2);
+            this.psPacketBuffer.setPosition(0);
+            extractorInput.skipFully(this.psPacketBuffer.readUnsignedShort() + 6);
+            return 0;
+        }
+        if (((readInt & (-256)) >> 8) != 1) {
+            extractorInput.skipFully(1);
+            return 0;
+        }
+        int i = readInt & 255;
+        PesReader pesReader = this.psPayloadReaders.get(i);
+        if (!this.foundAllTracks) {
+            if (pesReader == null) {
+                if (i == 189) {
+                    elementaryStreamReader = new Ac3Reader();
+                    this.foundAudioTrack = true;
+                    this.lastTrackPosition = extractorInput.getPosition();
+                } else if ((readInt & 224) == 192) {
+                    elementaryStreamReader = new MpegAudioReader();
+                    this.foundAudioTrack = true;
+                    this.lastTrackPosition = extractorInput.getPosition();
+                } else if ((readInt & VIDEO_STREAM_MASK) == 224) {
+                    elementaryStreamReader = new H262Reader();
+                    this.foundVideoTrack = true;
+                    this.lastTrackPosition = extractorInput.getPosition();
+                } else {
+                    elementaryStreamReader = null;
+                }
+                if (elementaryStreamReader != null) {
+                    elementaryStreamReader.createTracks(this.output, new TsPayloadReader.TrackIdGenerator(i, 256));
+                    pesReader = new PesReader(elementaryStreamReader, this.timestampAdjuster);
+                    this.psPayloadReaders.put(i, pesReader);
+                }
+            }
+            if (extractorInput.getPosition() > ((this.foundAudioTrack && this.foundVideoTrack) ? this.lastTrackPosition + 8192 : 1048576L)) {
+                this.foundAllTracks = true;
+                this.output.endTracks();
+            }
+        }
+        extractorInput.peekFully(this.psPacketBuffer.data, 0, 2);
+        this.psPacketBuffer.setPosition(0);
+        int readUnsignedShort = this.psPacketBuffer.readUnsignedShort() + 6;
+        if (pesReader == null) {
+            extractorInput.skipFully(readUnsignedShort);
+        } else {
+            this.psPacketBuffer.reset(readUnsignedShort);
+            extractorInput.readFully(this.psPacketBuffer.data, 0, readUnsignedShort);
+            this.psPacketBuffer.setPosition(6);
+            pesReader.consume(this.psPacketBuffer);
+            ParsableByteArray parsableByteArray = this.psPacketBuffer;
+            parsableByteArray.setLimit(parsableByteArray.capacity());
+        }
+        return 0;
+    }
+
+    public static final class PesReader {
+        private static final int PES_SCRATCH_SIZE = 64;
+        private boolean dtsFlag;
+        private int extendedHeaderLength;
+        private final ElementaryStreamReader pesPayloadReader;
+        private final ParsableBitArray pesScratch = new ParsableBitArray(new byte[64]);
+        private boolean ptsFlag;
+        private boolean seenFirstDts;
+        private long timeUs;
+        private final TimestampAdjuster timestampAdjuster;
+
+        public PesReader(ElementaryStreamReader elementaryStreamReader, TimestampAdjuster timestampAdjuster) {
+            this.pesPayloadReader = elementaryStreamReader;
+            this.timestampAdjuster = timestampAdjuster;
+        }
+
+        public final void seek() {
+            this.seenFirstDts = false;
+            this.pesPayloadReader.seek();
+        }
+
+        public final void consume(ParsableByteArray parsableByteArray) throws ParserException {
+            parsableByteArray.readBytes(this.pesScratch.data, 0, 3);
+            this.pesScratch.setPosition(0);
+            parseHeader();
+            parsableByteArray.readBytes(this.pesScratch.data, 0, this.extendedHeaderLength);
+            this.pesScratch.setPosition(0);
+            parseHeaderExtension();
+            this.pesPayloadReader.packetStarted(this.timeUs, true);
+            this.pesPayloadReader.consume(parsableByteArray);
+            this.pesPayloadReader.packetFinished();
+        }
+
+        private void parseHeader() {
+            this.pesScratch.skipBits(8);
+            this.ptsFlag = this.pesScratch.readBit();
+            this.dtsFlag = this.pesScratch.readBit();
+            this.pesScratch.skipBits(6);
+            this.extendedHeaderLength = this.pesScratch.readBits(8);
+        }
+
+        private void parseHeaderExtension() {
+            this.timeUs = 0L;
+            if (this.ptsFlag) {
+                this.pesScratch.skipBits(4);
+                this.pesScratch.skipBits(1);
+                this.pesScratch.skipBits(1);
+                long readBits = (this.pesScratch.readBits(3) << 30) | (this.pesScratch.readBits(15) << 15) | this.pesScratch.readBits(15);
+                this.pesScratch.skipBits(1);
+                if (!this.seenFirstDts && this.dtsFlag) {
+                    this.pesScratch.skipBits(4);
+                    this.pesScratch.skipBits(1);
+                    this.pesScratch.skipBits(1);
+                    this.pesScratch.skipBits(1);
+                    this.timestampAdjuster.adjustTsTimestamp((this.pesScratch.readBits(3) << 30) | (this.pesScratch.readBits(15) << 15) | this.pesScratch.readBits(15));
+                    this.seenFirstDts = true;
+                }
+                this.timeUs = this.timestampAdjuster.adjustTsTimestamp(readBits);
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/SectionPayloadReader.java

@@ -0,0 +1,13 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+
+/* loaded from: classes4.dex */
+public interface SectionPayloadReader {
+    void consume(ParsableByteArray parsableByteArray);
+
+    void init(TimestampAdjuster timestampAdjuster, ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/SectionReader.java

@@ -0,0 +1,102 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public final class SectionReader implements TsPayloadReader {
+    private static final int DEFAULT_SECTION_BUFFER_LENGTH = 32;
+    private static final int MAX_SECTION_LENGTH = 4098;
+    private static final int SECTION_HEADER_LENGTH = 3;
+    private int bytesRead;
+    private final SectionPayloadReader reader;
+    private final ParsableByteArray sectionData = new ParsableByteArray(32);
+    private boolean sectionSyntaxIndicator;
+    private int totalSectionLength;
+    private boolean waitingForPayloadStart;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader
+    public final void seek() {
+        this.waitingForPayloadStart = true;
+    }
+
+    public SectionReader(SectionPayloadReader sectionPayloadReader) {
+        this.reader = sectionPayloadReader;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader
+    public final void init(TimestampAdjuster timestampAdjuster, ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        this.reader.init(timestampAdjuster, extractorOutput, trackIdGenerator);
+        this.waitingForPayloadStart = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader
+    public final void consume(ParsableByteArray parsableByteArray, boolean z) {
+        int position = z ? parsableByteArray.getPosition() + parsableByteArray.readUnsignedByte() : -1;
+        if (this.waitingForPayloadStart) {
+            if (!z) {
+                return;
+            }
+            this.waitingForPayloadStart = false;
+            parsableByteArray.setPosition(position);
+            this.bytesRead = 0;
+        }
+        while (parsableByteArray.bytesLeft() > 0) {
+            int i = this.bytesRead;
+            if (i < 3) {
+                if (i == 0) {
+                    int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                    parsableByteArray.setPosition(parsableByteArray.getPosition() - 1);
+                    if (readUnsignedByte == 255) {
+                        this.waitingForPayloadStart = true;
+                        return;
+                    }
+                }
+                int min = Math.min(parsableByteArray.bytesLeft(), 3 - this.bytesRead);
+                parsableByteArray.readBytes(this.sectionData.data, this.bytesRead, min);
+                int i2 = this.bytesRead + min;
+                this.bytesRead = i2;
+                if (i2 == 3) {
+                    this.sectionData.reset(3);
+                    this.sectionData.skipBytes(1);
+                    int readUnsignedByte2 = this.sectionData.readUnsignedByte();
+                    int readUnsignedByte3 = this.sectionData.readUnsignedByte();
+                    this.sectionSyntaxIndicator = (readUnsignedByte2 & 128) != 0;
+                    this.totalSectionLength = (((readUnsignedByte2 & 15) << 8) | readUnsignedByte3) + 3;
+                    int capacity = this.sectionData.capacity();
+                    int i3 = this.totalSectionLength;
+                    if (capacity < i3) {
+                        ParsableByteArray parsableByteArray2 = this.sectionData;
+                        byte[] bArr = parsableByteArray2.data;
+                        parsableByteArray2.reset(Math.min(4098, Math.max(i3, bArr.length * 2)));
+                        System.arraycopy(bArr, 0, this.sectionData.data, 0, 3);
+                    }
+                }
+            } else {
+                int min2 = Math.min(parsableByteArray.bytesLeft(), this.totalSectionLength - this.bytesRead);
+                parsableByteArray.readBytes(this.sectionData.data, this.bytesRead, min2);
+                int i4 = this.bytesRead + min2;
+                this.bytesRead = i4;
+                int i5 = this.totalSectionLength;
+                if (i4 != i5) {
+                    continue;
+                } else {
+                    if (this.sectionSyntaxIndicator) {
+                        if (Util.crc(this.sectionData.data, 0, i5, -1) != 0) {
+                            this.waitingForPayloadStart = true;
+                            return;
+                        }
+                        this.sectionData.reset(this.totalSectionLength - 4);
+                    } else {
+                        this.sectionData.reset(i5);
+                    }
+                    this.reader.consume(this.sectionData);
+                    this.bytesRead = 0;
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/SeiReader.java

@@ -0,0 +1,43 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+final class SeiReader {
+    private final List<Format> closedCaptionFormats;
+    private final TrackOutput[] outputs;
+
+    public SeiReader(List<Format> list) {
+        this.closedCaptionFormats = list;
+        this.outputs = new TrackOutput[list.size()];
+    }
+
+    public final void createTracks(ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        for (int i = 0; i < this.outputs.length; i++) {
+            trackIdGenerator.generateNewId();
+            TrackOutput track = extractorOutput.track(trackIdGenerator.getTrackId(), 3);
+            Format format = this.closedCaptionFormats.get(i);
+            String str = format.sampleMimeType;
+            Assertions.checkArgument(MimeTypes.APPLICATION_CEA608.equals(str) || MimeTypes.APPLICATION_CEA708.equals(str), "Invalid closed caption mime type provided: " + str);
+            String str2 = format.id;
+            if (str2 == null) {
+                str2 = trackIdGenerator.getFormatId();
+            }
+            track.format(Format.createTextSampleFormat(str2, str, (String) null, -1, format.selectionFlags, format.language, format.accessibilityChannel, (DrmInitData) null));
+            this.outputs[i] = track;
+        }
+    }
+
+    public final void consume(long j, ParsableByteArray parsableByteArray) {
+        CeaUtil.consume(j, parsableByteArray, this.outputs);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/SpliceInfoSectionReader.java

@@ -0,0 +1,40 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+
+/* loaded from: classes4.dex */
+public final class SpliceInfoSectionReader implements SectionPayloadReader {
+    private boolean formatDeclared;
+    private TrackOutput output;
+    private TimestampAdjuster timestampAdjuster;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.SectionPayloadReader
+    public final void init(TimestampAdjuster timestampAdjuster, ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        this.timestampAdjuster = timestampAdjuster;
+        trackIdGenerator.generateNewId();
+        TrackOutput track = extractorOutput.track(trackIdGenerator.getTrackId(), 4);
+        this.output = track;
+        track.format(Format.createSampleFormat(trackIdGenerator.getFormatId(), MimeTypes.APPLICATION_SCTE35, null, -1, null));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.SectionPayloadReader
+    public final void consume(ParsableByteArray parsableByteArray) {
+        if (!this.formatDeclared) {
+            if (this.timestampAdjuster.getTimestampOffsetUs() == C.TIME_UNSET) {
+                return;
+            }
+            this.output.format(Format.createSampleFormat(null, MimeTypes.APPLICATION_SCTE35, this.timestampAdjuster.getTimestampOffsetUs()));
+            this.formatDeclared = true;
+        }
+        int bytesLeft = parsableByteArray.bytesLeft();
+        this.output.sampleData(parsableByteArray, bytesLeft);
+        this.output.sampleMetadata(this.timestampAdjuster.getLastAdjustedTimestampUs(), 1, bytesLeft, 0, null);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/TsExtractor.java

@@ -0,0 +1,451 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.SparseArray;
+import android.util.SparseBooleanArray;
+import android.util.SparseIntArray;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsPayloadReader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class TsExtractor implements Extractor {
+    private static final int BUFFER_SIZE = 9400;
+    private static final int MAX_PID_PLUS_ONE = 8192;
+    public static final int MODE_HLS = 2;
+    public static final int MODE_MULTI_PMT = 0;
+    public static final int MODE_SINGLE_PMT = 1;
+    private static final int SNIFF_TS_PACKET_COUNT = 5;
+    private static final int TS_PACKET_SIZE = 188;
+    private static final int TS_PAT_PID = 0;
+    public static final int TS_STREAM_TYPE_AAC_ADTS = 15;
+    public static final int TS_STREAM_TYPE_AAC_LATM = 17;
+    public static final int TS_STREAM_TYPE_AC3 = 129;
+    public static final int TS_STREAM_TYPE_DTS = 138;
+    public static final int TS_STREAM_TYPE_DVBSUBS = 89;
+    public static final int TS_STREAM_TYPE_E_AC3 = 135;
+    public static final int TS_STREAM_TYPE_H262 = 2;
+    public static final int TS_STREAM_TYPE_H264 = 27;
+    public static final int TS_STREAM_TYPE_H265 = 36;
+    public static final int TS_STREAM_TYPE_HDMV_DTS = 130;
+    public static final int TS_STREAM_TYPE_ID3 = 21;
+    public static final int TS_STREAM_TYPE_MPA = 3;
+    public static final int TS_STREAM_TYPE_MPA_LSF = 4;
+    public static final int TS_STREAM_TYPE_SPLICE_INFO = 134;
+    private static final int TS_SYNC_BYTE = 71;
+    private int bytesSinceLastSync;
+    private final SparseIntArray continuityCounters;
+    private TsPayloadReader id3Reader;
+    private final int mode;
+    private ExtractorOutput output;
+    private final TsPayloadReader.Factory payloadReaderFactory;
+    private int remainingPmts;
+    private final List<TimestampAdjuster> timestampAdjusters;
+    private final SparseBooleanArray trackIds;
+    private boolean tracksEnded;
+    private final ParsableByteArray tsPacketBuffer;
+    private final SparseArray<TsPayloadReader> tsPayloadReaders;
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsExtractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new TsExtractor()};
+        }
+    };
+    private static final long AC3_FORMAT_IDENTIFIER = Util.getIntegerCodeForString("AC-3");
+    private static final long E_AC3_FORMAT_IDENTIFIER = Util.getIntegerCodeForString("EAC3");
+    private static final long HEVC_FORMAT_IDENTIFIER = Util.getIntegerCodeForString("HEVC");
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Mode {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    public static /* synthetic */ int access$108(TsExtractor tsExtractor) {
+        int i = tsExtractor.remainingPmts;
+        tsExtractor.remainingPmts = i + 1;
+        return i;
+    }
+
+    public TsExtractor() {
+        this(0);
+    }
+
+    public TsExtractor(int i) {
+        this(1, i);
+    }
+
+    public TsExtractor(int i, int i2) {
+        this(i, new TimestampAdjuster(0L), new DefaultTsPayloadReaderFactory(i2));
+    }
+
+    public TsExtractor(int i, TimestampAdjuster timestampAdjuster, TsPayloadReader.Factory factory) {
+        this.payloadReaderFactory = (TsPayloadReader.Factory) Assertions.checkNotNull(factory);
+        this.mode = i;
+        if (i == 1 || i == 2) {
+            this.timestampAdjusters = Collections.singletonList(timestampAdjuster);
+        } else {
+            ArrayList arrayList = new ArrayList();
+            this.timestampAdjusters = arrayList;
+            arrayList.add(timestampAdjuster);
+        }
+        this.tsPacketBuffer = new ParsableByteArray(new byte[BUFFER_SIZE], 0);
+        this.trackIds = new SparseBooleanArray();
+        this.tsPayloadReaders = new SparseArray<>();
+        this.continuityCounters = new SparseIntArray();
+        resetPayloadReaders();
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:11:0x0021, code lost:
+    
+        r1 = r1 + 1;
+     */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final boolean sniff(com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput r7) throws java.io.IOException, java.lang.InterruptedException {
+        /*
+            r6 = this;
+            com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray r0 = r6.tsPacketBuffer
+            byte[] r0 = r0.data
+            r1 = 940(0x3ac, float:1.317E-42)
+            r2 = 0
+            r7.peekFully(r0, r2, r1)
+            r1 = r2
+        Lb:
+            r3 = 188(0xbc, float:2.63E-43)
+            if (r1 >= r3) goto L27
+            r3 = r2
+        L10:
+            r4 = 5
+            if (r3 != r4) goto L18
+            r7.skipFully(r1)
+            r7 = 1
+            return r7
+        L18:
+            int r4 = r3 * 188
+            int r4 = r4 + r1
+            r4 = r0[r4]
+            r5 = 71
+            if (r4 == r5) goto L24
+            int r1 = r1 + 1
+            goto Lb
+        L24:
+            int r3 = r3 + 1
+            goto L10
+        L27:
+            return r2
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsExtractor.sniff(com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput):boolean");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        this.output = extractorOutput;
+        extractorOutput.seekMap(new SeekMap.Unseekable(C.TIME_UNSET));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        int size = this.timestampAdjusters.size();
+        for (int i = 0; i < size; i++) {
+            this.timestampAdjusters.get(i).reset();
+        }
+        this.tsPacketBuffer.reset();
+        this.continuityCounters.clear();
+        resetPayloadReaders();
+        this.bytesSinceLastSync = 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        ParsableByteArray parsableByteArray = this.tsPacketBuffer;
+        byte[] bArr = parsableByteArray.data;
+        if (9400 - parsableByteArray.getPosition() < TS_PACKET_SIZE) {
+            int bytesLeft = this.tsPacketBuffer.bytesLeft();
+            if (bytesLeft > 0) {
+                System.arraycopy(bArr, this.tsPacketBuffer.getPosition(), bArr, 0, bytesLeft);
+            }
+            this.tsPacketBuffer.reset(bArr, bytesLeft);
+        }
+        while (this.tsPacketBuffer.bytesLeft() < TS_PACKET_SIZE) {
+            int limit = this.tsPacketBuffer.limit();
+            int read = extractorInput.read(bArr, limit, 9400 - limit);
+            if (read == -1) {
+                return -1;
+            }
+            this.tsPacketBuffer.setLimit(limit + read);
+        }
+        int limit2 = this.tsPacketBuffer.limit();
+        int position = this.tsPacketBuffer.getPosition();
+        int i = position;
+        while (i < limit2 && bArr[i] != 71) {
+            i++;
+        }
+        this.tsPacketBuffer.setPosition(i);
+        int i2 = i + TS_PACKET_SIZE;
+        if (i2 > limit2) {
+            int i3 = this.bytesSinceLastSync + (i - position);
+            this.bytesSinceLastSync = i3;
+            if (this.mode != 2 || i3 <= 376) {
+                return 0;
+            }
+            throw new ParserException("Cannot find sync byte. Most likely not a Transport Stream.");
+        }
+        this.bytesSinceLastSync = 0;
+        int readInt = this.tsPacketBuffer.readInt();
+        if ((8388608 & readInt) != 0) {
+            this.tsPacketBuffer.setPosition(i2);
+            return 0;
+        }
+        boolean z = (4194304 & readInt) != 0;
+        int i4 = (2096896 & readInt) >> 8;
+        boolean z2 = (readInt & 32) != 0;
+        TsPayloadReader tsPayloadReader = (readInt & 16) != 0 ? this.tsPayloadReaders.get(i4) : null;
+        if (tsPayloadReader == null) {
+            this.tsPacketBuffer.setPosition(i2);
+            return 0;
+        }
+        if (this.mode != 2) {
+            int i5 = readInt & 15;
+            int i6 = this.continuityCounters.get(i4, i5 - 1);
+            this.continuityCounters.put(i4, i5);
+            if (i6 == i5) {
+                this.tsPacketBuffer.setPosition(i2);
+                return 0;
+            }
+            if (i5 != ((i6 + 1) & 15)) {
+                tsPayloadReader.seek();
+            }
+        }
+        if (z2) {
+            this.tsPacketBuffer.skipBytes(this.tsPacketBuffer.readUnsignedByte());
+        }
+        this.tsPacketBuffer.setLimit(i2);
+        tsPayloadReader.consume(this.tsPacketBuffer, z);
+        this.tsPacketBuffer.setLimit(limit2);
+        this.tsPacketBuffer.setPosition(i2);
+        return 0;
+    }
+
+    private void resetPayloadReaders() {
+        this.trackIds.clear();
+        this.tsPayloadReaders.clear();
+        SparseArray<TsPayloadReader> createInitialPayloadReaders = this.payloadReaderFactory.createInitialPayloadReaders();
+        int size = createInitialPayloadReaders.size();
+        for (int i = 0; i < size; i++) {
+            this.tsPayloadReaders.put(createInitialPayloadReaders.keyAt(i), createInitialPayloadReaders.valueAt(i));
+        }
+        this.tsPayloadReaders.put(0, new SectionReader(new PatReader()));
+        this.id3Reader = null;
+    }
+
+    public class PatReader implements SectionPayloadReader {
+        private final ParsableBitArray patScratch = new ParsableBitArray(new byte[4]);
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.SectionPayloadReader
+        public void init(TimestampAdjuster timestampAdjuster, ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        }
+
+        public PatReader() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.SectionPayloadReader
+        public void consume(ParsableByteArray parsableByteArray) {
+            if (parsableByteArray.readUnsignedByte() != 0) {
+                return;
+            }
+            parsableByteArray.skipBytes(7);
+            int bytesLeft = parsableByteArray.bytesLeft() / 4;
+            for (int i = 0; i < bytesLeft; i++) {
+                parsableByteArray.readBytes(this.patScratch, 4);
+                int readBits = this.patScratch.readBits(16);
+                this.patScratch.skipBits(3);
+                if (readBits == 0) {
+                    this.patScratch.skipBits(13);
+                } else {
+                    int readBits2 = this.patScratch.readBits(13);
+                    TsExtractor.this.tsPayloadReaders.put(readBits2, new SectionReader(TsExtractor.this.new PmtReader(readBits2)));
+                    TsExtractor.access$108(TsExtractor.this);
+                }
+            }
+            if (TsExtractor.this.mode != 2) {
+                TsExtractor.this.tsPayloadReaders.remove(0);
+            }
+        }
+    }
+
+    public class PmtReader implements SectionPayloadReader {
+        private static final int TS_PMT_DESC_AC3 = 106;
+        private static final int TS_PMT_DESC_DTS = 123;
+        private static final int TS_PMT_DESC_DVBSUBS = 89;
+        private static final int TS_PMT_DESC_EAC3 = 122;
+        private static final int TS_PMT_DESC_ISO639_LANG = 10;
+        private static final int TS_PMT_DESC_REGISTRATION = 5;
+        private final int pid;
+        private final ParsableBitArray pmtScratch = new ParsableBitArray(new byte[5]);
+        private final SparseArray<TsPayloadReader> trackIdToReaderScratch = new SparseArray<>();
+        private final SparseIntArray trackIdToPidScratch = new SparseIntArray();
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.SectionPayloadReader
+        public void init(TimestampAdjuster timestampAdjuster, ExtractorOutput extractorOutput, TsPayloadReader.TrackIdGenerator trackIdGenerator) {
+        }
+
+        public PmtReader(int i) {
+            this.pid = i;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.SectionPayloadReader
+        public void consume(ParsableByteArray parsableByteArray) {
+            TimestampAdjuster timestampAdjuster;
+            if (parsableByteArray.readUnsignedByte() != 2) {
+                return;
+            }
+            if (TsExtractor.this.mode == 1 || TsExtractor.this.mode == 2 || TsExtractor.this.remainingPmts == 1) {
+                timestampAdjuster = (TimestampAdjuster) TsExtractor.this.timestampAdjusters.get(0);
+            } else {
+                timestampAdjuster = new TimestampAdjuster(((TimestampAdjuster) TsExtractor.this.timestampAdjusters.get(0)).getFirstSampleTimestampUs());
+                TsExtractor.this.timestampAdjusters.add(timestampAdjuster);
+            }
+            parsableByteArray.skipBytes(2);
+            int readUnsignedShort = parsableByteArray.readUnsignedShort();
+            int i = 5;
+            parsableByteArray.skipBytes(5);
+            parsableByteArray.readBytes(this.pmtScratch, 2);
+            int i2 = 4;
+            this.pmtScratch.skipBits(4);
+            parsableByteArray.skipBytes(this.pmtScratch.readBits(12));
+            if (TsExtractor.this.mode == 2 && TsExtractor.this.id3Reader == null) {
+                TsPayloadReader.EsInfo esInfo = new TsPayloadReader.EsInfo(21, null, null, new byte[0]);
+                TsExtractor tsExtractor = TsExtractor.this;
+                tsExtractor.id3Reader = tsExtractor.payloadReaderFactory.createPayloadReader(21, esInfo);
+                TsExtractor.this.id3Reader.init(timestampAdjuster, TsExtractor.this.output, new TsPayloadReader.TrackIdGenerator(readUnsignedShort, 21, 8192));
+            }
+            this.trackIdToReaderScratch.clear();
+            this.trackIdToPidScratch.clear();
+            int bytesLeft = parsableByteArray.bytesLeft();
+            while (bytesLeft > 0) {
+                parsableByteArray.readBytes(this.pmtScratch, i);
+                int readBits = this.pmtScratch.readBits(8);
+                this.pmtScratch.skipBits(3);
+                int readBits2 = this.pmtScratch.readBits(13);
+                this.pmtScratch.skipBits(i2);
+                int readBits3 = this.pmtScratch.readBits(12);
+                TsPayloadReader.EsInfo readEsInfo = readEsInfo(parsableByteArray, readBits3);
+                if (readBits == 6) {
+                    readBits = readEsInfo.streamType;
+                }
+                bytesLeft -= readBits3 + 5;
+                int i3 = TsExtractor.this.mode == 2 ? readBits : readBits2;
+                if (!TsExtractor.this.trackIds.get(i3)) {
+                    TsPayloadReader createPayloadReader = (TsExtractor.this.mode == 2 && readBits == 21) ? TsExtractor.this.id3Reader : TsExtractor.this.payloadReaderFactory.createPayloadReader(readBits, readEsInfo);
+                    if (TsExtractor.this.mode != 2 || readBits2 < this.trackIdToPidScratch.get(i3, 8192)) {
+                        this.trackIdToPidScratch.put(i3, readBits2);
+                        this.trackIdToReaderScratch.put(i3, createPayloadReader);
+                    }
+                }
+                i = 5;
+                i2 = 4;
+            }
+            int size = this.trackIdToPidScratch.size();
+            for (int i4 = 0; i4 < size; i4++) {
+                int keyAt = this.trackIdToPidScratch.keyAt(i4);
+                TsExtractor.this.trackIds.put(keyAt, true);
+                TsPayloadReader valueAt = this.trackIdToReaderScratch.valueAt(i4);
+                if (valueAt != null) {
+                    if (valueAt != TsExtractor.this.id3Reader) {
+                        valueAt.init(timestampAdjuster, TsExtractor.this.output, new TsPayloadReader.TrackIdGenerator(readUnsignedShort, keyAt, 8192));
+                    }
+                    TsExtractor.this.tsPayloadReaders.put(this.trackIdToPidScratch.valueAt(i4), valueAt);
+                }
+            }
+            if (TsExtractor.this.mode == 2) {
+                if (TsExtractor.this.tracksEnded) {
+                    return;
+                }
+                TsExtractor.this.output.endTracks();
+                TsExtractor.this.remainingPmts = 0;
+                TsExtractor.this.tracksEnded = true;
+                return;
+            }
+            TsExtractor.this.tsPayloadReaders.remove(this.pid);
+            TsExtractor tsExtractor2 = TsExtractor.this;
+            tsExtractor2.remainingPmts = tsExtractor2.mode != 1 ? TsExtractor.this.remainingPmts - 1 : 0;
+            if (TsExtractor.this.remainingPmts == 0) {
+                TsExtractor.this.output.endTracks();
+                TsExtractor.this.tracksEnded = true;
+            }
+        }
+
+        private TsPayloadReader.EsInfo readEsInfo(ParsableByteArray parsableByteArray, int i) {
+            int position = parsableByteArray.getPosition();
+            int i2 = i + position;
+            int i3 = -1;
+            String str = null;
+            ArrayList arrayList = null;
+            while (parsableByteArray.getPosition() < i2) {
+                int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                int position2 = parsableByteArray.getPosition() + parsableByteArray.readUnsignedByte();
+                if (readUnsignedByte == 5) {
+                    long readUnsignedInt = parsableByteArray.readUnsignedInt();
+                    if (readUnsignedInt != TsExtractor.AC3_FORMAT_IDENTIFIER) {
+                        if (readUnsignedInt != TsExtractor.E_AC3_FORMAT_IDENTIFIER) {
+                            if (readUnsignedInt == TsExtractor.HEVC_FORMAT_IDENTIFIER) {
+                                i3 = 36;
+                            }
+                        }
+                        i3 = 135;
+                    }
+                    i3 = 129;
+                } else {
+                    if (readUnsignedByte != 106) {
+                        if (readUnsignedByte != 122) {
+                            if (readUnsignedByte == 123) {
+                                i3 = 138;
+                            } else if (readUnsignedByte == 10) {
+                                str = parsableByteArray.readString(3).trim();
+                            } else if (readUnsignedByte == 89) {
+                                ArrayList arrayList2 = new ArrayList();
+                                while (parsableByteArray.getPosition() < position2) {
+                                    String trim = parsableByteArray.readString(3).trim();
+                                    int readUnsignedByte2 = parsableByteArray.readUnsignedByte();
+                                    byte[] bArr = new byte[4];
+                                    parsableByteArray.readBytes(bArr, 0, 4);
+                                    arrayList2.add(new TsPayloadReader.DvbSubtitleInfo(trim, readUnsignedByte2, bArr));
+                                }
+                                arrayList = arrayList2;
+                                i3 = 89;
+                            }
+                        }
+                        i3 = 135;
+                    }
+                    i3 = 129;
+                }
+                parsableByteArray.skipBytes(position2 - parsableByteArray.getPosition());
+            }
+            parsableByteArray.setPosition(i2);
+            return new TsPayloadReader.EsInfo(i3, str, arrayList, Arrays.copyOfRange(parsableByteArray.data, position, i2));
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ts/TsPayloadReader.java

@@ -0,0 +1,105 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.ts;
+
+import android.util.SparseArray;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public interface TsPayloadReader {
+
+    public interface Factory {
+        SparseArray<TsPayloadReader> createInitialPayloadReaders();
+
+        TsPayloadReader createPayloadReader(int i, EsInfo esInfo);
+    }
+
+    void consume(ParsableByteArray parsableByteArray, boolean z) throws ParserException;
+
+    void init(TimestampAdjuster timestampAdjuster, ExtractorOutput extractorOutput, TrackIdGenerator trackIdGenerator);
+
+    void seek();
+
+    public static final class EsInfo {
+        public final byte[] descriptorBytes;
+        public final List<DvbSubtitleInfo> dvbSubtitleInfos;
+        public final String language;
+        public final int streamType;
+
+        public EsInfo(int i, String str, List<DvbSubtitleInfo> list, byte[] bArr) {
+            List<DvbSubtitleInfo> unmodifiableList;
+            this.streamType = i;
+            this.language = str;
+            if (list == null) {
+                unmodifiableList = Collections.emptyList();
+            } else {
+                unmodifiableList = Collections.unmodifiableList(list);
+            }
+            this.dvbSubtitleInfos = unmodifiableList;
+            this.descriptorBytes = bArr;
+        }
+    }
+
+    public static final class DvbSubtitleInfo {
+        public final byte[] initializationData;
+        public final String language;
+        public final int type;
+
+        public DvbSubtitleInfo(String str, int i, byte[] bArr) {
+            this.language = str;
+            this.type = i;
+            this.initializationData = bArr;
+        }
+    }
+
+    public static final class TrackIdGenerator {
+        private static final int ID_UNSET = Integer.MIN_VALUE;
+        private final int firstTrackId;
+        private String formatId;
+        private final String formatIdPrefix;
+        private int trackId;
+        private final int trackIdIncrement;
+
+        public TrackIdGenerator(int i, int i2) {
+            this(Integer.MIN_VALUE, i, i2);
+        }
+
+        public TrackIdGenerator(int i, int i2, int i3) {
+            String str;
+            if (i != Integer.MIN_VALUE) {
+                str = i + "/";
+            } else {
+                str = "";
+            }
+            this.formatIdPrefix = str;
+            this.firstTrackId = i2;
+            this.trackIdIncrement = i3;
+            this.trackId = Integer.MIN_VALUE;
+        }
+
+        public final void generateNewId() {
+            int i = this.trackId;
+            this.trackId = i == Integer.MIN_VALUE ? this.firstTrackId : i + this.trackIdIncrement;
+            this.formatId = this.formatIdPrefix + this.trackId;
+        }
+
+        public final int getTrackId() {
+            maybeThrowUninitializedError();
+            return this.trackId;
+        }
+
+        public final String getFormatId() {
+            maybeThrowUninitializedError();
+            return this.formatId;
+        }
+
+        private void maybeThrowUninitializedError() {
+            if (this.trackId == Integer.MIN_VALUE) {
+                throw new IllegalStateException("generateNewId() must be called before retrieving ids.");
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/wav/WavExtractor.java

@@ -0,0 +1,80 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.wav;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.PositionHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class WavExtractor implements Extractor {
+    public static final ExtractorsFactory FACTORY = new ExtractorsFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.extractor.wav.WavExtractor.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+        public Extractor[] createExtractors() {
+            return new Extractor[]{new WavExtractor()};
+        }
+    };
+    private static final int MAX_INPUT_SIZE = 32768;
+    private int bytesPerFrame;
+    private ExtractorOutput extractorOutput;
+    private int pendingBytes;
+    private TrackOutput trackOutput;
+    private WavHeader wavHeader;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void release() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void seek(long j, long j2) {
+        this.pendingBytes = 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException {
+        return WavHeaderReader.peek(extractorInput) != null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final void init(ExtractorOutput extractorOutput) {
+        this.extractorOutput = extractorOutput;
+        this.trackOutput = extractorOutput.track(0, 1);
+        this.wavHeader = null;
+        extractorOutput.endTracks();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor
+    public final int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException {
+        if (this.wavHeader == null) {
+            WavHeader peek = WavHeaderReader.peek(extractorInput);
+            this.wavHeader = peek;
+            if (peek == null) {
+                throw new ParserException("Unsupported or unrecognized wav header.");
+            }
+            this.trackOutput.format(Format.createAudioSampleFormat(null, MimeTypes.AUDIO_RAW, null, peek.getBitrate(), 32768, this.wavHeader.getNumChannels(), this.wavHeader.getSampleRateHz(), this.wavHeader.getEncoding(), null, null, 0, null));
+            this.bytesPerFrame = this.wavHeader.getBytesPerFrame();
+        }
+        if (!this.wavHeader.hasDataBounds()) {
+            WavHeaderReader.skipToData(extractorInput, this.wavHeader);
+            this.extractorOutput.seekMap(this.wavHeader);
+        }
+        int sampleData = this.trackOutput.sampleData(extractorInput, 32768 - this.pendingBytes, true);
+        if (sampleData != -1) {
+            this.pendingBytes += sampleData;
+        }
+        int i = this.pendingBytes / this.bytesPerFrame;
+        if (i > 0) {
+            long timeUs = this.wavHeader.getTimeUs(extractorInput.getPosition() - this.pendingBytes);
+            int i2 = i * this.bytesPerFrame;
+            int i3 = this.pendingBytes - i2;
+            this.pendingBytes = i3;
+            this.trackOutput.sampleMetadata(timeUs, 1, i2, i3, null);
+        }
+        return sampleData == -1 ? -1 : 0;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/wav/WavHeader.java

@@ -0,0 +1,87 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.wav;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekPoint;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+final class WavHeader implements SeekMap {
+    private final int averageBytesPerSecond;
+    private final int bitsPerSample;
+    private final int blockAlignment;
+    private long dataSize;
+    private long dataStartPosition;
+    private final int encoding;
+    private final int numChannels;
+    private final int sampleRateHz;
+
+    public final int getBitrate() {
+        return this.sampleRateHz * this.bitsPerSample * this.numChannels;
+    }
+
+    public final int getBytesPerFrame() {
+        return this.blockAlignment;
+    }
+
+    public final int getEncoding() {
+        return this.encoding;
+    }
+
+    public final int getNumChannels() {
+        return this.numChannels;
+    }
+
+    public final int getSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    public final boolean hasDataBounds() {
+        return (this.dataStartPosition == 0 || this.dataSize == 0) ? false : true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final boolean isSeekable() {
+        return true;
+    }
+
+    public final void setDataBounds(long j, long j2) {
+        this.dataStartPosition = j;
+        this.dataSize = j2;
+    }
+
+    public WavHeader(int i, int i2, int i3, int i4, int i5, int i6) {
+        this.numChannels = i;
+        this.sampleRateHz = i2;
+        this.averageBytesPerSecond = i3;
+        this.blockAlignment = i4;
+        this.bitsPerSample = i5;
+        this.encoding = i6;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final long getDurationUs() {
+        return ((this.dataSize / this.blockAlignment) * 1000000) / this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final SeekMap.SeekPoints getSeekPoints(long j) {
+        int i = this.blockAlignment;
+        long constrainValue = Util.constrainValue((((this.averageBytesPerSecond * j) / 1000000) / i) * i, 0L, this.dataSize - i);
+        long j2 = this.dataStartPosition + constrainValue;
+        long timeUs = getTimeUs(j2);
+        SeekPoint seekPoint = new SeekPoint(timeUs, j2);
+        if (timeUs < j) {
+            long j3 = this.dataSize;
+            int i2 = this.blockAlignment;
+            if (constrainValue != j3 - i2) {
+                long j4 = j2 + i2;
+                return new SeekMap.SeekPoints(seekPoint, new SeekPoint(getTimeUs(j4), j4));
+            }
+        }
+        return new SeekMap.SeekPoints(seekPoint);
+    }
+
+    public final long getTimeUs(long j) {
+        return (Math.max(0L, j - this.dataStartPosition) * 1000000) / this.averageBytesPerSecond;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/wav/WavHeaderReader.java

@@ -0,0 +1,73 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor.wav;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+final class WavHeaderReader {
+    private static final String TAG = "WavHeaderReader";
+    private static final int TYPE_FLOAT = 3;
+    private static final int TYPE_PCM = 1;
+    private static final int TYPE_WAVE_FORMAT_EXTENSIBLE = 65534;
+
+    /* JADX WARN: Removed duplicated region for block: B:30:0x00c2  */
+    /* JADX WARN: Removed duplicated region for block: B:32:0x00df  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static com.mbridge.msdk.playercommon.exoplayer2.extractor.wav.WavHeader peek(com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput r17) throws java.io.IOException, java.lang.InterruptedException {
+        /*
+            Method dump skipped, instructions count: 268
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.extractor.wav.WavHeaderReader.peek(com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput):com.mbridge.msdk.playercommon.exoplayer2.extractor.wav.WavHeader");
+    }
+
+    public static void skipToData(ExtractorInput extractorInput, WavHeader wavHeader) throws IOException, InterruptedException {
+        Assertions.checkNotNull(extractorInput);
+        Assertions.checkNotNull(wavHeader);
+        extractorInput.resetPeekPosition();
+        ParsableByteArray parsableByteArray = new ParsableByteArray(8);
+        ChunkHeader peek = ChunkHeader.peek(extractorInput, parsableByteArray);
+        while (peek.id != Util.getIntegerCodeForString("data")) {
+            Log.w(TAG, "Ignoring unknown WAV chunk: " + peek.id);
+            long j = peek.size + 8;
+            if (peek.id == Util.getIntegerCodeForString("RIFF")) {
+                j = 12;
+            }
+            if (j > 2147483647L) {
+                throw new ParserException("Chunk is too large (~2GB+) to skip; id: " + peek.id);
+            }
+            extractorInput.skipFully((int) j);
+            peek = ChunkHeader.peek(extractorInput, parsableByteArray);
+        }
+        extractorInput.skipFully(8);
+        wavHeader.setDataBounds(extractorInput.getPosition(), peek.size);
+    }
+
+    private WavHeaderReader() {
+    }
+
+    public static final class ChunkHeader {
+        public static final int SIZE_IN_BYTES = 8;
+        public final int id;
+        public final long size;
+
+        private ChunkHeader(int i, long j) {
+            this.id = i;
+            this.size = j;
+        }
+
+        public static ChunkHeader peek(ExtractorInput extractorInput, ParsableByteArray parsableByteArray) throws IOException, InterruptedException {
+            extractorInput.peekFully(parsableByteArray.data, 0, 8);
+            parsableByteArray.setPosition(0);
+            return new ChunkHeader(parsableByteArray.readInt(), parsableByteArray.readLittleEndianUnsignedInt());
+        }
+    }
+}