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/source/chunk/BaseMediaChunk.java

@@ -0,0 +1,30 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+
+/* loaded from: classes4.dex */
+public abstract class BaseMediaChunk extends MediaChunk {
+    private int[] firstSampleIndices;
+    private BaseMediaChunkOutput output;
+    public final long seekTimeUs;
+
+    public final BaseMediaChunkOutput getOutput() {
+        return this.output;
+    }
+
+    public BaseMediaChunk(DataSource dataSource, DataSpec dataSpec, Format format, int i, Object obj, long j, long j2, long j3, long j4) {
+        super(dataSource, dataSpec, format, i, obj, j, j2, j4);
+        this.seekTimeUs = j3;
+    }
+
+    public void init(BaseMediaChunkOutput baseMediaChunkOutput) {
+        this.output = baseMediaChunkOutput;
+        this.firstSampleIndices = baseMediaChunkOutput.getWriteIndices();
+    }
+
+    public final int getFirstSampleIndex(int i) {
+        return this.firstSampleIndices[i];
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/BaseMediaChunkOutput.java

@@ -0,0 +1,60 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.DummyTrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.source.SampleQueue;
+import com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkExtractorWrapper;
+
+/* loaded from: classes4.dex */
+public final class BaseMediaChunkOutput implements ChunkExtractorWrapper.TrackOutputProvider {
+    private static final String TAG = "BaseMediaChunkOutput";
+    private final SampleQueue[] sampleQueues;
+    private final int[] trackTypes;
+
+    public BaseMediaChunkOutput(int[] iArr, SampleQueue[] sampleQueueArr) {
+        this.trackTypes = iArr;
+        this.sampleQueues = sampleQueueArr;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkExtractorWrapper.TrackOutputProvider
+    public final TrackOutput track(int i, int i2) {
+        int i3 = 0;
+        while (true) {
+            int[] iArr = this.trackTypes;
+            if (i3 < iArr.length) {
+                if (i2 == iArr[i3]) {
+                    return this.sampleQueues[i3];
+                }
+                i3++;
+            } else {
+                Log.e(TAG, "Unmatched track of type: " + i2);
+                return new DummyTrackOutput();
+            }
+        }
+    }
+
+    public final int[] getWriteIndices() {
+        int[] iArr = new int[this.sampleQueues.length];
+        int i = 0;
+        while (true) {
+            SampleQueue[] sampleQueueArr = this.sampleQueues;
+            if (i >= sampleQueueArr.length) {
+                return iArr;
+            }
+            SampleQueue sampleQueue = sampleQueueArr[i];
+            if (sampleQueue != null) {
+                iArr[i] = sampleQueue.getWriteIndex();
+            }
+            i++;
+        }
+    }
+
+    public final void setSampleOffsetUs(long j) {
+        for (SampleQueue sampleQueue : this.sampleQueues) {
+            if (sampleQueue != null) {
+                sampleQueue.setSampleOffsetUs(j);
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/Chunk.java

@@ -0,0 +1,39 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public abstract class Chunk implements Loader.Loadable {
+    protected final DataSource dataSource;
+    public final DataSpec dataSpec;
+    public final long endTimeUs;
+    public final long startTimeUs;
+    public final Format trackFormat;
+
+    @Nullable
+    public final Object trackSelectionData;
+    public final int trackSelectionReason;
+    public final int type;
+
+    public abstract long bytesLoaded();
+
+    public final long getDurationUs() {
+        return this.endTimeUs - this.startTimeUs;
+    }
+
+    public Chunk(DataSource dataSource, DataSpec dataSpec, int i, Format format, int i2, @Nullable Object obj, long j, long j2) {
+        this.dataSource = (DataSource) Assertions.checkNotNull(dataSource);
+        this.dataSpec = (DataSpec) Assertions.checkNotNull(dataSpec);
+        this.type = i;
+        this.trackFormat = format;
+        this.trackSelectionReason = i2;
+        this.trackSelectionData = obj;
+        this.startTimeUs = j;
+        this.endTimeUs = j2;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/ChunkExtractorWrapper.java

@@ -0,0 +1,142 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import android.util.SparseArray;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.DummyTrackOutput;
+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.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class ChunkExtractorWrapper implements ExtractorOutput {
+    private final SparseArray<BindingTrackOutput> bindingTrackOutputs = new SparseArray<>();
+    public final Extractor extractor;
+    private boolean extractorInitialized;
+    private final Format primaryTrackManifestFormat;
+    private final int primaryTrackType;
+    private Format[] sampleFormats;
+    private SeekMap seekMap;
+    private TrackOutputProvider trackOutputProvider;
+
+    public interface TrackOutputProvider {
+        TrackOutput track(int i, int i2);
+    }
+
+    public final Format[] getSampleFormats() {
+        return this.sampleFormats;
+    }
+
+    public final SeekMap getSeekMap() {
+        return this.seekMap;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput
+    public final void seekMap(SeekMap seekMap) {
+        this.seekMap = seekMap;
+    }
+
+    public ChunkExtractorWrapper(Extractor extractor, int i, Format format) {
+        this.extractor = extractor;
+        this.primaryTrackType = i;
+        this.primaryTrackManifestFormat = format;
+    }
+
+    public final void init(TrackOutputProvider trackOutputProvider, long j) {
+        this.trackOutputProvider = trackOutputProvider;
+        if (!this.extractorInitialized) {
+            this.extractor.init(this);
+            if (j != C.TIME_UNSET) {
+                this.extractor.seek(0L, j);
+            }
+            this.extractorInitialized = true;
+            return;
+        }
+        Extractor extractor = this.extractor;
+        if (j == C.TIME_UNSET) {
+            j = 0;
+        }
+        extractor.seek(0L, j);
+        for (int i = 0; i < this.bindingTrackOutputs.size(); i++) {
+            this.bindingTrackOutputs.valueAt(i).bind(trackOutputProvider);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput
+    public final TrackOutput track(int i, int i2) {
+        BindingTrackOutput bindingTrackOutput = this.bindingTrackOutputs.get(i);
+        if (bindingTrackOutput == null) {
+            Assertions.checkState(this.sampleFormats == null);
+            bindingTrackOutput = new BindingTrackOutput(i, i2, i2 == this.primaryTrackType ? this.primaryTrackManifestFormat : null);
+            bindingTrackOutput.bind(this.trackOutputProvider);
+            this.bindingTrackOutputs.put(i, bindingTrackOutput);
+        }
+        return bindingTrackOutput;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorOutput
+    public final void endTracks() {
+        Format[] formatArr = new Format[this.bindingTrackOutputs.size()];
+        for (int i = 0; i < this.bindingTrackOutputs.size(); i++) {
+            formatArr[i] = this.bindingTrackOutputs.valueAt(i).sampleFormat;
+        }
+        this.sampleFormats = formatArr;
+    }
+
+    public static final class BindingTrackOutput implements TrackOutput {
+        private final int id;
+        private final Format manifestFormat;
+        public Format sampleFormat;
+        private TrackOutput trackOutput;
+        private final int type;
+
+        public BindingTrackOutput(int i, int i2, Format format) {
+            this.id = i;
+            this.type = i2;
+            this.manifestFormat = format;
+        }
+
+        public final void bind(TrackOutputProvider trackOutputProvider) {
+            if (trackOutputProvider == null) {
+                this.trackOutput = new DummyTrackOutput();
+                return;
+            }
+            TrackOutput track = trackOutputProvider.track(this.id, this.type);
+            this.trackOutput = track;
+            Format format = this.sampleFormat;
+            if (format != null) {
+                track.format(format);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+        public final void format(Format format) {
+            Format format2 = this.manifestFormat;
+            if (format2 != null) {
+                format = format.copyWithManifestFormatInfo(format2);
+            }
+            this.sampleFormat = format;
+            this.trackOutput.format(format);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+        public final int sampleData(ExtractorInput extractorInput, int i, boolean z) throws IOException, InterruptedException {
+            return this.trackOutput.sampleData(extractorInput, i, z);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+        public final void sampleData(ParsableByteArray parsableByteArray, int i) {
+            this.trackOutput.sampleData(parsableByteArray, i);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+        public final void sampleMetadata(long j, int i, int i2, int i3, TrackOutput.CryptoData cryptoData) {
+            this.trackOutput.sampleMetadata(j, i, i2, i3, cryptoData);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/ChunkHolder.java

@@ -0,0 +1,12 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+/* loaded from: classes4.dex */
+public final class ChunkHolder {
+    public Chunk chunk;
+    public boolean endOfStream;
+
+    public final void clear() {
+        this.chunk = null;
+        this.endOfStream = false;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/ChunkSampleStream.java

@@ -0,0 +1,612 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.FormatHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.SeekParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.source.SampleQueue;
+import com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream;
+import com.mbridge.msdk.playercommon.exoplayer2.source.SequenceableLoader;
+import com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.Allocator;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public class ChunkSampleStream<T extends ChunkSource> implements SampleStream, SequenceableLoader, Loader.Callback<Chunk>, Loader.ReleaseCallback {
+    private static final String TAG = "ChunkSampleStream";
+    private final SequenceableLoader.Callback<ChunkSampleStream<T>> callback;
+    private final T chunkSource;
+    long decodeOnlyUntilPositionUs;
+    private final SampleQueue[] embeddedSampleQueues;
+    private final Format[] embeddedTrackFormats;
+    private final int[] embeddedTrackTypes;
+    private final boolean[] embeddedTracksSelected;
+    private final MediaSourceEventListener.EventDispatcher eventDispatcher;
+    private long lastSeekPositionUs;
+    boolean loadingFinished;
+    private final BaseMediaChunkOutput mediaChunkOutput;
+    private final ArrayList<BaseMediaChunk> mediaChunks;
+    private final int minLoadableRetryCount;
+    private long pendingResetPositionUs;
+    private Format primaryDownstreamTrackFormat;
+    private final SampleQueue primarySampleQueue;
+    public final int primaryTrackType;
+    private final List<BaseMediaChunk> readOnlyMediaChunks;
+
+    @Nullable
+    private ReleaseCallback<T> releaseCallback;
+    private final Loader loader = new Loader("Loader:ChunkSampleStream");
+    private final ChunkHolder nextChunkHolder = new ChunkHolder();
+
+    public interface ReleaseCallback<T extends ChunkSource> {
+        void onSampleStreamReleased(ChunkSampleStream<T> chunkSampleStream);
+    }
+
+    public T getChunkSource() {
+        return this.chunkSource;
+    }
+
+    public boolean isPendingReset() {
+        return this.pendingResetPositionUs != C.TIME_UNSET;
+    }
+
+    public ChunkSampleStream(int i, int[] iArr, Format[] formatArr, T t, SequenceableLoader.Callback<ChunkSampleStream<T>> callback, Allocator allocator, long j, int i2, MediaSourceEventListener.EventDispatcher eventDispatcher) {
+        this.primaryTrackType = i;
+        this.embeddedTrackTypes = iArr;
+        this.embeddedTrackFormats = formatArr;
+        this.chunkSource = t;
+        this.callback = callback;
+        this.eventDispatcher = eventDispatcher;
+        this.minLoadableRetryCount = i2;
+        ArrayList<BaseMediaChunk> arrayList = new ArrayList<>();
+        this.mediaChunks = arrayList;
+        this.readOnlyMediaChunks = Collections.unmodifiableList(arrayList);
+        int i3 = 0;
+        int length = iArr == null ? 0 : iArr.length;
+        this.embeddedSampleQueues = new SampleQueue[length];
+        this.embeddedTracksSelected = new boolean[length];
+        int i4 = length + 1;
+        int[] iArr2 = new int[i4];
+        SampleQueue[] sampleQueueArr = new SampleQueue[i4];
+        SampleQueue sampleQueue = new SampleQueue(allocator);
+        this.primarySampleQueue = sampleQueue;
+        iArr2[0] = i;
+        sampleQueueArr[0] = sampleQueue;
+        while (i3 < length) {
+            SampleQueue sampleQueue2 = new SampleQueue(allocator);
+            this.embeddedSampleQueues[i3] = sampleQueue2;
+            int i5 = i3 + 1;
+            sampleQueueArr[i5] = sampleQueue2;
+            iArr2[i5] = iArr[i3];
+            i3 = i5;
+        }
+        this.mediaChunkOutput = new BaseMediaChunkOutput(iArr2, sampleQueueArr);
+        this.pendingResetPositionUs = j;
+        this.lastSeekPositionUs = j;
+    }
+
+    public void discardBuffer(long j, boolean z) {
+        int firstIndex = this.primarySampleQueue.getFirstIndex();
+        this.primarySampleQueue.discardTo(j, z, true);
+        int firstIndex2 = this.primarySampleQueue.getFirstIndex();
+        if (firstIndex2 <= firstIndex) {
+            return;
+        }
+        long firstTimestampUs = this.primarySampleQueue.getFirstTimestampUs();
+        int i = 0;
+        while (true) {
+            SampleQueue[] sampleQueueArr = this.embeddedSampleQueues;
+            if (i < sampleQueueArr.length) {
+                sampleQueueArr[i].discardTo(firstTimestampUs, z, this.embeddedTracksSelected[i]);
+                i++;
+            } else {
+                discardDownstreamMediaChunks(firstIndex2);
+                return;
+            }
+        }
+    }
+
+    public ChunkSampleStream<T>.EmbeddedSampleStream selectEmbeddedTrack(long j, int i) {
+        for (int i2 = 0; i2 < this.embeddedSampleQueues.length; i2++) {
+            if (this.embeddedTrackTypes[i2] == i) {
+                Assertions.checkState(!this.embeddedTracksSelected[i2]);
+                this.embeddedTracksSelected[i2] = true;
+                this.embeddedSampleQueues[i2].rewind();
+                this.embeddedSampleQueues[i2].advanceTo(j, true, true);
+                return new EmbeddedSampleStream(this, this.embeddedSampleQueues[i2], i2);
+            }
+        }
+        throw new IllegalStateException();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SequenceableLoader
+    public long getBufferedPositionUs() {
+        if (this.loadingFinished) {
+            return Long.MIN_VALUE;
+        }
+        if (isPendingReset()) {
+            return this.pendingResetPositionUs;
+        }
+        long j = this.lastSeekPositionUs;
+        BaseMediaChunk lastMediaChunk = getLastMediaChunk();
+        if (!lastMediaChunk.isLoadCompleted()) {
+            if (this.mediaChunks.size() > 1) {
+                lastMediaChunk = this.mediaChunks.get(r2.size() - 2);
+            } else {
+                lastMediaChunk = null;
+            }
+        }
+        if (lastMediaChunk != null) {
+            j = Math.max(j, lastMediaChunk.endTimeUs);
+        }
+        return Math.max(j, this.primarySampleQueue.getLargestQueuedTimestampUs());
+    }
+
+    public long getAdjustedSeekPositionUs(long j, SeekParameters seekParameters) {
+        return this.chunkSource.getAdjustedSeekPositionUs(j, seekParameters);
+    }
+
+    public void seekToUs(long j) {
+        BaseMediaChunk baseMediaChunk;
+        boolean z;
+        this.lastSeekPositionUs = j;
+        this.primarySampleQueue.rewind();
+        if (!isPendingReset()) {
+            for (int i = 0; i < this.mediaChunks.size(); i++) {
+                baseMediaChunk = this.mediaChunks.get(i);
+                long j2 = baseMediaChunk.startTimeUs;
+                if (j2 == j && baseMediaChunk.seekTimeUs == C.TIME_UNSET) {
+                    break;
+                } else {
+                    if (j2 > j) {
+                        break;
+                    }
+                }
+            }
+            baseMediaChunk = null;
+            if (baseMediaChunk != null) {
+                z = this.primarySampleQueue.setReadPosition(baseMediaChunk.getFirstSampleIndex(0));
+                this.decodeOnlyUntilPositionUs = Long.MIN_VALUE;
+            } else {
+                z = this.primarySampleQueue.advanceTo(j, true, (j > getNextLoadPositionUs() ? 1 : (j == getNextLoadPositionUs() ? 0 : -1)) < 0) != -1;
+                this.decodeOnlyUntilPositionUs = this.lastSeekPositionUs;
+            }
+            if (z) {
+                for (SampleQueue sampleQueue : this.embeddedSampleQueues) {
+                    sampleQueue.rewind();
+                    sampleQueue.advanceTo(j, true, false);
+                }
+                return;
+            }
+        }
+        this.pendingResetPositionUs = j;
+        this.loadingFinished = false;
+        this.mediaChunks.clear();
+        if (this.loader.isLoading()) {
+            this.loader.cancelLoading();
+            return;
+        }
+        this.primarySampleQueue.reset();
+        for (SampleQueue sampleQueue2 : this.embeddedSampleQueues) {
+            sampleQueue2.reset();
+        }
+    }
+
+    public void release() {
+        release(null);
+    }
+
+    public void release(@Nullable ReleaseCallback<T> releaseCallback) {
+        this.releaseCallback = releaseCallback;
+        this.primarySampleQueue.discardToEnd();
+        for (SampleQueue sampleQueue : this.embeddedSampleQueues) {
+            sampleQueue.discardToEnd();
+        }
+        this.loader.release(this);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.ReleaseCallback
+    public void onLoaderReleased() {
+        this.primarySampleQueue.reset();
+        for (SampleQueue sampleQueue : this.embeddedSampleQueues) {
+            sampleQueue.reset();
+        }
+        ReleaseCallback<T> releaseCallback = this.releaseCallback;
+        if (releaseCallback != null) {
+            releaseCallback.onSampleStreamReleased(this);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream
+    public boolean isReady() {
+        return this.loadingFinished || (!isPendingReset() && this.primarySampleQueue.hasNextSample());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream
+    public void maybeThrowError() throws IOException {
+        this.loader.maybeThrowError();
+        if (this.loader.isLoading()) {
+            return;
+        }
+        this.chunkSource.maybeThrowError();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream
+    public int readData(FormatHolder formatHolder, DecoderInputBuffer decoderInputBuffer, boolean z) {
+        if (isPendingReset()) {
+            return -3;
+        }
+        int read = this.primarySampleQueue.read(formatHolder, decoderInputBuffer, z, this.loadingFinished, this.decodeOnlyUntilPositionUs);
+        if (read == -4) {
+            maybeNotifyPrimaryTrackFormatChanged(this.primarySampleQueue.getReadIndex(), 1);
+        }
+        return read;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream
+    public int skipData(long j) {
+        int i = 0;
+        if (isPendingReset()) {
+            return 0;
+        }
+        if (this.loadingFinished && j > this.primarySampleQueue.getLargestQueuedTimestampUs()) {
+            i = this.primarySampleQueue.advanceToEnd();
+        } else {
+            int advanceTo = this.primarySampleQueue.advanceTo(j, true, true);
+            if (advanceTo != -1) {
+                i = advanceTo;
+            }
+        }
+        if (i > 0) {
+            maybeNotifyPrimaryTrackFormatChanged(this.primarySampleQueue.getReadIndex(), i);
+        }
+        return i;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Callback
+    public void onLoadCompleted(Chunk chunk, long j, long j2) {
+        this.chunkSource.onChunkLoadCompleted(chunk);
+        this.eventDispatcher.loadCompleted(chunk.dataSpec, chunk.type, this.primaryTrackType, chunk.trackFormat, chunk.trackSelectionReason, chunk.trackSelectionData, chunk.startTimeUs, chunk.endTimeUs, j, j2, chunk.bytesLoaded());
+        this.callback.onContinueLoadingRequested(this);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Callback
+    public void onLoadCanceled(Chunk chunk, long j, long j2, boolean z) {
+        this.eventDispatcher.loadCanceled(chunk.dataSpec, chunk.type, this.primaryTrackType, chunk.trackFormat, chunk.trackSelectionReason, chunk.trackSelectionData, chunk.startTimeUs, chunk.endTimeUs, j, j2, chunk.bytesLoaded());
+        if (z) {
+            return;
+        }
+        this.primarySampleQueue.reset();
+        for (SampleQueue sampleQueue : this.embeddedSampleQueues) {
+            sampleQueue.reset();
+        }
+        this.callback.onContinueLoadingRequested(this);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:22:0x007c  */
+    /* JADX WARN: Removed duplicated region for block: B:25:0x0083 A[RETURN] */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Callback
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public int onLoadError(com.mbridge.msdk.playercommon.exoplayer2.source.chunk.Chunk r24, long r25, long r27, java.io.IOException r29) {
+        /*
+            r23 = this;
+            r0 = r23
+            r1 = r24
+            long r17 = r24.bytesLoaded()
+            boolean r2 = r23.isMediaChunk(r24)
+            java.util.ArrayList<com.mbridge.msdk.playercommon.exoplayer2.source.chunk.BaseMediaChunk> r3 = r0.mediaChunks
+            int r3 = r3.size()
+            r4 = 1
+            int r3 = r3 - r4
+            r5 = 0
+            int r5 = (r17 > r5 ? 1 : (r17 == r5 ? 0 : -1))
+            r21 = 0
+            if (r5 == 0) goto L28
+            if (r2 == 0) goto L28
+            boolean r5 = r0.haveReadFromMediaChunk(r3)
+            if (r5 != 0) goto L25
+            goto L28
+        L25:
+            r5 = r21
+            goto L29
+        L28:
+            r5 = r4
+        L29:
+            T extends com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkSource r6 = r0.chunkSource
+            r15 = r29
+            boolean r6 = r6.onChunkLoadError(r1, r5, r15)
+            if (r6 == 0) goto L5b
+            if (r5 != 0) goto L3d
+            java.lang.String r2 = "ChunkSampleStream"
+            java.lang.String r3 = "Ignoring attempt to cancel non-cancelable load."
+            android.util.Log.w(r2, r3)
+            goto L5b
+        L3d:
+            if (r2 == 0) goto L58
+            com.mbridge.msdk.playercommon.exoplayer2.source.chunk.BaseMediaChunk r2 = r0.discardUpstreamMediaChunksFromIndex(r3)
+            if (r2 != r1) goto L47
+            r2 = r4
+            goto L49
+        L47:
+            r2 = r21
+        L49:
+            com.mbridge.msdk.playercommon.exoplayer2.util.Assertions.checkState(r2)
+            java.util.ArrayList<com.mbridge.msdk.playercommon.exoplayer2.source.chunk.BaseMediaChunk> r2 = r0.mediaChunks
+            boolean r2 = r2.isEmpty()
+            if (r2 == 0) goto L58
+            long r2 = r0.lastSeekPositionUs
+            r0.pendingResetPositionUs = r2
+        L58:
+            r22 = r4
+            goto L5d
+        L5b:
+            r22 = r21
+        L5d:
+            com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener$EventDispatcher r2 = r0.eventDispatcher
+            com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec r3 = r1.dataSpec
+            int r4 = r1.type
+            int r5 = r0.primaryTrackType
+            com.mbridge.msdk.playercommon.exoplayer2.Format r6 = r1.trackFormat
+            int r7 = r1.trackSelectionReason
+            java.lang.Object r8 = r1.trackSelectionData
+            long r9 = r1.startTimeUs
+            long r11 = r1.endTimeUs
+            r13 = r25
+            r15 = r27
+            r19 = r29
+            r20 = r22
+            r2.loadError(r3, r4, r5, r6, r7, r8, r9, r11, r13, r15, r17, r19, r20)
+            if (r22 == 0) goto L83
+            com.mbridge.msdk.playercommon.exoplayer2.source.SequenceableLoader$Callback<com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkSampleStream<T extends com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkSource>> r1 = r0.callback
+            r1.onContinueLoadingRequested(r0)
+            r1 = 2
+            return r1
+        L83:
+            return r21
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkSampleStream.onLoadError(com.mbridge.msdk.playercommon.exoplayer2.source.chunk.Chunk, long, long, java.io.IOException):int");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SequenceableLoader
+    public boolean continueLoading(long j) {
+        BaseMediaChunk lastMediaChunk;
+        long j2;
+        if (this.loadingFinished || this.loader.isLoading()) {
+            return false;
+        }
+        boolean isPendingReset = isPendingReset();
+        if (isPendingReset) {
+            j2 = this.pendingResetPositionUs;
+            lastMediaChunk = null;
+        } else {
+            lastMediaChunk = getLastMediaChunk();
+            j2 = lastMediaChunk.endTimeUs;
+        }
+        this.chunkSource.getNextChunk(lastMediaChunk, j, j2, this.nextChunkHolder);
+        ChunkHolder chunkHolder = this.nextChunkHolder;
+        boolean z = chunkHolder.endOfStream;
+        Chunk chunk = chunkHolder.chunk;
+        chunkHolder.clear();
+        if (z) {
+            this.pendingResetPositionUs = C.TIME_UNSET;
+            this.loadingFinished = true;
+            return true;
+        }
+        if (chunk == null) {
+            return false;
+        }
+        if (isMediaChunk(chunk)) {
+            BaseMediaChunk baseMediaChunk = (BaseMediaChunk) chunk;
+            if (isPendingReset) {
+                long j3 = baseMediaChunk.startTimeUs;
+                long j4 = this.pendingResetPositionUs;
+                if (j3 == j4) {
+                    j4 = Long.MIN_VALUE;
+                }
+                this.decodeOnlyUntilPositionUs = j4;
+                this.pendingResetPositionUs = C.TIME_UNSET;
+            }
+            baseMediaChunk.init(this.mediaChunkOutput);
+            this.mediaChunks.add(baseMediaChunk);
+        }
+        this.eventDispatcher.loadStarted(chunk.dataSpec, chunk.type, this.primaryTrackType, chunk.trackFormat, chunk.trackSelectionReason, chunk.trackSelectionData, chunk.startTimeUs, chunk.endTimeUs, this.loader.startLoading(chunk, this, this.minLoadableRetryCount));
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SequenceableLoader
+    public long getNextLoadPositionUs() {
+        if (isPendingReset()) {
+            return this.pendingResetPositionUs;
+        }
+        if (this.loadingFinished) {
+            return Long.MIN_VALUE;
+        }
+        return getLastMediaChunk().endTimeUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SequenceableLoader
+    public void reevaluateBuffer(long j) {
+        int size;
+        int preferredQueueSize;
+        if (this.loader.isLoading() || isPendingReset() || (size = this.mediaChunks.size()) <= (preferredQueueSize = this.chunkSource.getPreferredQueueSize(j, this.readOnlyMediaChunks))) {
+            return;
+        }
+        while (true) {
+            if (preferredQueueSize >= size) {
+                preferredQueueSize = size;
+                break;
+            } else if (!haveReadFromMediaChunk(preferredQueueSize)) {
+                break;
+            } else {
+                preferredQueueSize++;
+            }
+        }
+        if (preferredQueueSize == size) {
+            return;
+        }
+        long j2 = getLastMediaChunk().endTimeUs;
+        BaseMediaChunk discardUpstreamMediaChunksFromIndex = discardUpstreamMediaChunksFromIndex(preferredQueueSize);
+        if (this.mediaChunks.isEmpty()) {
+            this.pendingResetPositionUs = this.lastSeekPositionUs;
+        }
+        this.loadingFinished = false;
+        this.eventDispatcher.upstreamDiscarded(this.primaryTrackType, discardUpstreamMediaChunksFromIndex.startTimeUs, j2);
+    }
+
+    private boolean isMediaChunk(Chunk chunk) {
+        return chunk instanceof BaseMediaChunk;
+    }
+
+    private boolean haveReadFromMediaChunk(int i) {
+        int readIndex;
+        BaseMediaChunk baseMediaChunk = this.mediaChunks.get(i);
+        if (this.primarySampleQueue.getReadIndex() > baseMediaChunk.getFirstSampleIndex(0)) {
+            return true;
+        }
+        int i2 = 0;
+        do {
+            SampleQueue[] sampleQueueArr = this.embeddedSampleQueues;
+            if (i2 >= sampleQueueArr.length) {
+                return false;
+            }
+            readIndex = sampleQueueArr[i2].getReadIndex();
+            i2++;
+        } while (readIndex <= baseMediaChunk.getFirstSampleIndex(i2));
+        return true;
+    }
+
+    private void discardDownstreamMediaChunks(int i) {
+        int primaryStreamIndexToMediaChunkIndex = primaryStreamIndexToMediaChunkIndex(i, 0);
+        if (primaryStreamIndexToMediaChunkIndex > 0) {
+            Util.removeRange(this.mediaChunks, 0, primaryStreamIndexToMediaChunkIndex);
+        }
+    }
+
+    private void maybeNotifyPrimaryTrackFormatChanged(int i, int i2) {
+        int primaryStreamIndexToMediaChunkIndex = primaryStreamIndexToMediaChunkIndex(i - i2, 0);
+        int primaryStreamIndexToMediaChunkIndex2 = i2 == 1 ? primaryStreamIndexToMediaChunkIndex : primaryStreamIndexToMediaChunkIndex(i - 1, primaryStreamIndexToMediaChunkIndex);
+        while (primaryStreamIndexToMediaChunkIndex <= primaryStreamIndexToMediaChunkIndex2) {
+            maybeNotifyPrimaryTrackFormatChanged(primaryStreamIndexToMediaChunkIndex);
+            primaryStreamIndexToMediaChunkIndex++;
+        }
+    }
+
+    private void maybeNotifyPrimaryTrackFormatChanged(int i) {
+        BaseMediaChunk baseMediaChunk = this.mediaChunks.get(i);
+        Format format = baseMediaChunk.trackFormat;
+        if (!format.equals(this.primaryDownstreamTrackFormat)) {
+            this.eventDispatcher.downstreamFormatChanged(this.primaryTrackType, format, baseMediaChunk.trackSelectionReason, baseMediaChunk.trackSelectionData, baseMediaChunk.startTimeUs);
+        }
+        this.primaryDownstreamTrackFormat = format;
+    }
+
+    private int primaryStreamIndexToMediaChunkIndex(int i, int i2) {
+        do {
+            i2++;
+            if (i2 >= this.mediaChunks.size()) {
+                return this.mediaChunks.size() - 1;
+            }
+        } while (this.mediaChunks.get(i2).getFirstSampleIndex(0) <= i);
+        return i2 - 1;
+    }
+
+    private BaseMediaChunk getLastMediaChunk() {
+        return this.mediaChunks.get(r0.size() - 1);
+    }
+
+    private BaseMediaChunk discardUpstreamMediaChunksFromIndex(int i) {
+        BaseMediaChunk baseMediaChunk = this.mediaChunks.get(i);
+        ArrayList<BaseMediaChunk> arrayList = this.mediaChunks;
+        Util.removeRange(arrayList, i, arrayList.size());
+        int i2 = 0;
+        this.primarySampleQueue.discardUpstreamSamples(baseMediaChunk.getFirstSampleIndex(0));
+        while (true) {
+            SampleQueue[] sampleQueueArr = this.embeddedSampleQueues;
+            if (i2 >= sampleQueueArr.length) {
+                return baseMediaChunk;
+            }
+            SampleQueue sampleQueue = sampleQueueArr[i2];
+            i2++;
+            sampleQueue.discardUpstreamSamples(baseMediaChunk.getFirstSampleIndex(i2));
+        }
+    }
+
+    public final class EmbeddedSampleStream implements SampleStream {
+        private boolean formatNotificationSent;
+        private final int index;
+        public final ChunkSampleStream<T> parent;
+        private final SampleQueue sampleQueue;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream
+        public final void maybeThrowError() throws IOException {
+        }
+
+        public EmbeddedSampleStream(ChunkSampleStream<T> chunkSampleStream, SampleQueue sampleQueue, int i) {
+            this.parent = chunkSampleStream;
+            this.sampleQueue = sampleQueue;
+            this.index = i;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream
+        public final boolean isReady() {
+            ChunkSampleStream chunkSampleStream = ChunkSampleStream.this;
+            return chunkSampleStream.loadingFinished || (!chunkSampleStream.isPendingReset() && this.sampleQueue.hasNextSample());
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream
+        public final int skipData(long j) {
+            int advanceTo;
+            if (ChunkSampleStream.this.loadingFinished && j > this.sampleQueue.getLargestQueuedTimestampUs()) {
+                advanceTo = this.sampleQueue.advanceToEnd();
+            } else {
+                advanceTo = this.sampleQueue.advanceTo(j, true, true);
+                if (advanceTo == -1) {
+                    advanceTo = 0;
+                }
+            }
+            if (advanceTo > 0) {
+                maybeNotifyTrackFormatChanged();
+            }
+            return advanceTo;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream
+        public final int readData(FormatHolder formatHolder, DecoderInputBuffer decoderInputBuffer, boolean z) {
+            if (ChunkSampleStream.this.isPendingReset()) {
+                return -3;
+            }
+            SampleQueue sampleQueue = this.sampleQueue;
+            ChunkSampleStream chunkSampleStream = ChunkSampleStream.this;
+            int read = sampleQueue.read(formatHolder, decoderInputBuffer, z, chunkSampleStream.loadingFinished, chunkSampleStream.decodeOnlyUntilPositionUs);
+            if (read == -4) {
+                maybeNotifyTrackFormatChanged();
+            }
+            return read;
+        }
+
+        public final void release() {
+            Assertions.checkState(ChunkSampleStream.this.embeddedTracksSelected[this.index]);
+            ChunkSampleStream.this.embeddedTracksSelected[this.index] = false;
+        }
+
+        private void maybeNotifyTrackFormatChanged() {
+            if (this.formatNotificationSent) {
+                return;
+            }
+            ChunkSampleStream.this.eventDispatcher.downstreamFormatChanged(ChunkSampleStream.this.embeddedTrackTypes[this.index], ChunkSampleStream.this.embeddedTrackFormats[this.index], 0, null, ChunkSampleStream.this.lastSeekPositionUs);
+            this.formatNotificationSent = true;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/ChunkSource.java

@@ -0,0 +1,20 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import com.mbridge.msdk.playercommon.exoplayer2.SeekParameters;
+import java.io.IOException;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public interface ChunkSource {
+    long getAdjustedSeekPositionUs(long j, SeekParameters seekParameters);
+
+    void getNextChunk(MediaChunk mediaChunk, long j, long j2, ChunkHolder chunkHolder);
+
+    int getPreferredQueueSize(long j, List<? extends MediaChunk> list);
+
+    void maybeThrowError() throws IOException;
+
+    void onChunkLoadCompleted(Chunk chunk);
+
+    boolean onChunkLoadError(Chunk chunk, boolean z, Exception exc);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/ChunkedTrackBlacklistUtil.java

@@ -0,0 +1,40 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource;
+
+/* loaded from: classes4.dex */
+public final class ChunkedTrackBlacklistUtil {
+    public static final long DEFAULT_TRACK_BLACKLIST_MS = 60000;
+    private static final String TAG = "ChunkedTrackBlacklist";
+
+    private ChunkedTrackBlacklistUtil() {
+    }
+
+    public static boolean maybeBlacklistTrack(TrackSelection trackSelection, int i, Exception exc) {
+        return maybeBlacklistTrack(trackSelection, i, exc, DEFAULT_TRACK_BLACKLIST_MS);
+    }
+
+    public static boolean maybeBlacklistTrack(TrackSelection trackSelection, int i, Exception exc, long j) {
+        if (!shouldBlacklist(exc)) {
+            return false;
+        }
+        boolean blacklist = trackSelection.blacklist(i, j);
+        int i2 = ((HttpDataSource.InvalidResponseCodeException) exc).responseCode;
+        if (blacklist) {
+            Log.w(TAG, "Blacklisted: duration=" + j + ", responseCode=" + i2 + ", format=" + trackSelection.getFormat(i));
+        } else {
+            Log.w(TAG, "Blacklisting failed (cannot blacklist last enabled track): responseCode=" + i2 + ", format=" + trackSelection.getFormat(i));
+        }
+        return blacklist;
+    }
+
+    public static boolean shouldBlacklist(Exception exc) {
+        if (!(exc instanceof HttpDataSource.InvalidResponseCodeException)) {
+            return false;
+        }
+        int i = ((HttpDataSource.InvalidResponseCodeException) exc).responseCode;
+        return i == 404 || i == 410;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/ContainerMediaChunk.java

@@ -0,0 +1,81 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.DefaultExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public class ContainerMediaChunk extends BaseMediaChunk {
+    private volatile int bytesLoaded;
+    private final int chunkCount;
+    private final ChunkExtractorWrapper extractorWrapper;
+    private volatile boolean loadCanceled;
+    private volatile boolean loadCompleted;
+    private final long sampleOffsetUs;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.chunk.Chunk
+    public final long bytesLoaded() {
+        return this.bytesLoaded;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Loadable
+    public final void cancelLoad() {
+        this.loadCanceled = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.chunk.MediaChunk
+    public long getNextChunkIndex() {
+        return this.chunkIndex + this.chunkCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.chunk.MediaChunk
+    public boolean isLoadCompleted() {
+        return this.loadCompleted;
+    }
+
+    public ContainerMediaChunk(DataSource dataSource, DataSpec dataSpec, Format format, int i, Object obj, long j, long j2, long j3, long j4, int i2, long j5, ChunkExtractorWrapper chunkExtractorWrapper) {
+        super(dataSource, dataSpec, format, i, obj, j, j2, j3, j4);
+        this.chunkCount = i2;
+        this.sampleOffsetUs = j5;
+        this.extractorWrapper = chunkExtractorWrapper;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Loadable
+    public final void load() throws IOException, InterruptedException {
+        DataSpec subrange = this.dataSpec.subrange(this.bytesLoaded);
+        try {
+            DataSource dataSource = this.dataSource;
+            DefaultExtractorInput defaultExtractorInput = new DefaultExtractorInput(dataSource, subrange.absoluteStreamPosition, dataSource.open(subrange));
+            if (this.bytesLoaded == 0) {
+                BaseMediaChunkOutput output = getOutput();
+                output.setSampleOffsetUs(this.sampleOffsetUs);
+                ChunkExtractorWrapper chunkExtractorWrapper = this.extractorWrapper;
+                long j = this.seekTimeUs;
+                chunkExtractorWrapper.init(output, j == C.TIME_UNSET ? 0L : j - this.sampleOffsetUs);
+            }
+            try {
+                Extractor extractor = this.extractorWrapper.extractor;
+                int i = 0;
+                while (i == 0 && !this.loadCanceled) {
+                    i = extractor.read(defaultExtractorInput, null);
+                }
+                Assertions.checkState(i != 1);
+                this.bytesLoaded = (int) (defaultExtractorInput.getPosition() - this.dataSpec.absoluteStreamPosition);
+                Util.closeQuietly(this.dataSource);
+                this.loadCompleted = true;
+            } catch (Throwable th) {
+                this.bytesLoaded = (int) (defaultExtractorInput.getPosition() - this.dataSpec.absoluteStreamPosition);
+                throw th;
+            }
+        } catch (Throwable th2) {
+            Util.closeQuietly(this.dataSource);
+            throw th2;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/DataChunk.java

@@ -0,0 +1,72 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public abstract class DataChunk extends Chunk {
+    private static final int READ_GRANULARITY = 16384;
+    private byte[] data;
+    private int limit;
+    private volatile boolean loadCanceled;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.chunk.Chunk
+    public long bytesLoaded() {
+        return this.limit;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Loadable
+    public final void cancelLoad() {
+        this.loadCanceled = true;
+    }
+
+    public abstract void consume(byte[] bArr, int i) throws IOException;
+
+    public byte[] getDataHolder() {
+        return this.data;
+    }
+
+    public DataChunk(DataSource dataSource, DataSpec dataSpec, int i, Format format, int i2, Object obj, byte[] bArr) {
+        super(dataSource, dataSpec, i, format, i2, obj, C.TIME_UNSET, C.TIME_UNSET);
+        this.data = bArr;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Loadable
+    public final void load() throws IOException, InterruptedException {
+        try {
+            this.dataSource.open(this.dataSpec);
+            this.limit = 0;
+            while (!this.loadCanceled) {
+                maybeExpandData();
+                int read = this.dataSource.read(this.data, this.limit, 16384);
+                if (read != -1) {
+                    this.limit += read;
+                }
+                if (read == -1) {
+                    break;
+                }
+            }
+            if (!this.loadCanceled) {
+                consume(this.data, this.limit);
+            }
+            Util.closeQuietly(this.dataSource);
+        } catch (Throwable th) {
+            Util.closeQuietly(this.dataSource);
+            throw th;
+        }
+    }
+
+    private void maybeExpandData() {
+        byte[] bArr = this.data;
+        if (bArr == null) {
+            this.data = new byte[16384];
+        } else if (bArr.length < this.limit + 16384) {
+            this.data = Arrays.copyOf(bArr, bArr.length + 16384);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/InitializationChunk.java

@@ -0,0 +1,60 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.DefaultExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class InitializationChunk extends Chunk {
+    private volatile int bytesLoaded;
+    private final ChunkExtractorWrapper extractorWrapper;
+    private volatile boolean loadCanceled;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.chunk.Chunk
+    public final long bytesLoaded() {
+        return this.bytesLoaded;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Loadable
+    public final void cancelLoad() {
+        this.loadCanceled = true;
+    }
+
+    public InitializationChunk(DataSource dataSource, DataSpec dataSpec, Format format, int i, @Nullable Object obj, ChunkExtractorWrapper chunkExtractorWrapper) {
+        super(dataSource, dataSpec, 2, format, i, obj, C.TIME_UNSET, C.TIME_UNSET);
+        this.extractorWrapper = chunkExtractorWrapper;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Loadable
+    public final void load() throws IOException, InterruptedException {
+        DataSpec subrange = this.dataSpec.subrange(this.bytesLoaded);
+        try {
+            DataSource dataSource = this.dataSource;
+            DefaultExtractorInput defaultExtractorInput = new DefaultExtractorInput(dataSource, subrange.absoluteStreamPosition, dataSource.open(subrange));
+            if (this.bytesLoaded == 0) {
+                this.extractorWrapper.init(null, C.TIME_UNSET);
+            }
+            try {
+                Extractor extractor = this.extractorWrapper.extractor;
+                int i = 0;
+                while (i == 0 && !this.loadCanceled) {
+                    i = extractor.read(defaultExtractorInput, null);
+                }
+                Assertions.checkState(i != 1);
+                this.bytesLoaded = (int) (defaultExtractorInput.getPosition() - this.dataSpec.absoluteStreamPosition);
+            } catch (Throwable th) {
+                this.bytesLoaded = (int) (defaultExtractorInput.getPosition() - this.dataSpec.absoluteStreamPosition);
+                throw th;
+            }
+        } finally {
+            Util.closeQuietly(this.dataSource);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/MediaChunk.java

@@ -0,0 +1,27 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public abstract class MediaChunk extends Chunk {
+    public final long chunkIndex;
+
+    public long getNextChunkIndex() {
+        long j = this.chunkIndex;
+        if (j != -1) {
+            return 1 + j;
+        }
+        return -1L;
+    }
+
+    public abstract boolean isLoadCompleted();
+
+    public MediaChunk(DataSource dataSource, DataSpec dataSpec, Format format, int i, Object obj, long j, long j2, long j3) {
+        super(dataSource, dataSpec, 1, format, i, obj, j, j2);
+        Assertions.checkNotNull(format);
+        this.chunkIndex = j3;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/source/chunk/SingleSampleMediaChunk.java

@@ -0,0 +1,62 @@
+package com.mbridge.msdk.playercommon.exoplayer2.source.chunk;
+
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.DefaultExtractorInput;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class SingleSampleMediaChunk extends BaseMediaChunk {
+    private volatile int bytesLoaded;
+    private volatile boolean loadCompleted;
+    private final Format sampleFormat;
+    private final int trackType;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.chunk.Chunk
+    public final long bytesLoaded() {
+        return this.bytesLoaded;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Loadable
+    public final void cancelLoad() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.chunk.MediaChunk
+    public final boolean isLoadCompleted() {
+        return this.loadCompleted;
+    }
+
+    public SingleSampleMediaChunk(DataSource dataSource, DataSpec dataSpec, Format format, int i, Object obj, long j, long j2, long j3, int i2, Format format2) {
+        super(dataSource, dataSpec, format, i, obj, j, j2, C.TIME_UNSET, j3);
+        this.trackType = i2;
+        this.sampleFormat = format2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.Loader.Loadable
+    public final void load() throws IOException, InterruptedException {
+        try {
+            long open = this.dataSource.open(this.dataSpec.subrange(this.bytesLoaded));
+            if (open != -1) {
+                open += this.bytesLoaded;
+            }
+            DefaultExtractorInput defaultExtractorInput = new DefaultExtractorInput(this.dataSource, this.bytesLoaded, open);
+            BaseMediaChunkOutput output = getOutput();
+            output.setSampleOffsetUs(0L);
+            TrackOutput track = output.track(0, this.trackType);
+            track.format(this.sampleFormat);
+            for (int i = 0; i != -1; i = track.sampleData(defaultExtractorInput, Integer.MAX_VALUE, true)) {
+                this.bytesLoaded += i;
+            }
+            track.sampleMetadata(this.startTimeUs, 1, this.bytesLoaded, 0, null);
+            Util.closeQuietly(this.dataSource);
+            this.loadCompleted = true;
+        } catch (Throwable th) {
+            Util.closeQuietly(this.dataSource);
+            throw th;
+        }
+    }
+}