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/trackselection/AdaptiveTrackSelection.java

@@ -0,0 +1,185 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import androidx.annotation.Nullable;
+import androidx.work.WorkRequest;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroup;
+import com.mbridge.msdk.playercommon.exoplayer2.source.chunk.MediaChunk;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.BandwidthMeter;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Clock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public class AdaptiveTrackSelection extends BaseTrackSelection {
+    public static final float DEFAULT_BANDWIDTH_FRACTION = 0.75f;
+    public static final float DEFAULT_BUFFERED_FRACTION_TO_LIVE_EDGE_FOR_QUALITY_INCREASE = 0.75f;
+    public static final int DEFAULT_MAX_DURATION_FOR_QUALITY_DECREASE_MS = 25000;
+    public static final int DEFAULT_MIN_DURATION_FOR_QUALITY_INCREASE_MS = 10000;
+    public static final int DEFAULT_MIN_DURATION_TO_RETAIN_AFTER_DISCARD_MS = 25000;
+    public static final long DEFAULT_MIN_TIME_BETWEEN_BUFFER_REEVALUTATION_MS = 2000;
+    private final float bandwidthFraction;
+    private final BandwidthMeter bandwidthMeter;
+    private final float bufferedFractionToLiveEdgeForQualityIncrease;
+    private final Clock clock;
+    private long lastBufferEvaluationMs;
+    private final long maxDurationForQualityDecreaseUs;
+    private final long minDurationForQualityIncreaseUs;
+    private final long minDurationToRetainAfterDiscardUs;
+    private final long minTimeBetweenBufferReevaluationMs;
+    private float playbackSpeed;
+    private int reason;
+    private int selectedIndex;
+
+    private long minDurationForQualityIncreaseUs(long j) {
+        return (j == C.TIME_UNSET || j > this.minDurationForQualityIncreaseUs) ? this.minDurationForQualityIncreaseUs : (long) (j * this.bufferedFractionToLiveEdgeForQualityIncrease);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.BaseTrackSelection, com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public void enable() {
+        this.lastBufferEvaluationMs = C.TIME_UNSET;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public int getSelectedIndex() {
+        return this.selectedIndex;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    @Nullable
+    public Object getSelectionData() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public int getSelectionReason() {
+        return this.reason;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.BaseTrackSelection, com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public void onPlaybackSpeed(float f) {
+        this.playbackSpeed = f;
+    }
+
+    public static final class Factory implements TrackSelection.Factory {
+        private final float bandwidthFraction;
+        private final BandwidthMeter bandwidthMeter;
+        private final float bufferedFractionToLiveEdgeForQualityIncrease;
+        private final Clock clock;
+        private final int maxDurationForQualityDecreaseMs;
+        private final int minDurationForQualityIncreaseMs;
+        private final int minDurationToRetainAfterDiscardMs;
+        private final long minTimeBetweenBufferReevaluationMs;
+
+        public Factory(BandwidthMeter bandwidthMeter) {
+            this(bandwidthMeter, 10000, 25000, 25000, 0.75f, 0.75f, 2000L, Clock.DEFAULT);
+        }
+
+        public Factory(BandwidthMeter bandwidthMeter, int i, int i2, int i3, float f) {
+            this(bandwidthMeter, i, i2, i3, f, 0.75f, 2000L, Clock.DEFAULT);
+        }
+
+        public Factory(BandwidthMeter bandwidthMeter, int i, int i2, int i3, float f, float f2, long j, Clock clock) {
+            this.bandwidthMeter = bandwidthMeter;
+            this.minDurationForQualityIncreaseMs = i;
+            this.maxDurationForQualityDecreaseMs = i2;
+            this.minDurationToRetainAfterDiscardMs = i3;
+            this.bandwidthFraction = f;
+            this.bufferedFractionToLiveEdgeForQualityIncrease = f2;
+            this.minTimeBetweenBufferReevaluationMs = j;
+            this.clock = clock;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection.Factory
+        public final AdaptiveTrackSelection createTrackSelection(TrackGroup trackGroup, int... iArr) {
+            return new AdaptiveTrackSelection(trackGroup, iArr, this.bandwidthMeter, this.minDurationForQualityIncreaseMs, this.maxDurationForQualityDecreaseMs, this.minDurationToRetainAfterDiscardMs, this.bandwidthFraction, this.bufferedFractionToLiveEdgeForQualityIncrease, this.minTimeBetweenBufferReevaluationMs, this.clock);
+        }
+    }
+
+    public AdaptiveTrackSelection(TrackGroup trackGroup, int[] iArr, BandwidthMeter bandwidthMeter) {
+        this(trackGroup, iArr, bandwidthMeter, WorkRequest.MIN_BACKOFF_MILLIS, 25000L, 25000L, 0.75f, 0.75f, 2000L, Clock.DEFAULT);
+    }
+
+    public AdaptiveTrackSelection(TrackGroup trackGroup, int[] iArr, BandwidthMeter bandwidthMeter, long j, long j2, long j3, float f, float f2, long j4, Clock clock) {
+        super(trackGroup, iArr);
+        this.bandwidthMeter = bandwidthMeter;
+        this.minDurationForQualityIncreaseUs = j * 1000;
+        this.maxDurationForQualityDecreaseUs = j2 * 1000;
+        this.minDurationToRetainAfterDiscardUs = j3 * 1000;
+        this.bandwidthFraction = f;
+        this.bufferedFractionToLiveEdgeForQualityIncrease = f2;
+        this.minTimeBetweenBufferReevaluationMs = j4;
+        this.clock = clock;
+        this.playbackSpeed = 1.0f;
+        this.reason = 1;
+        this.lastBufferEvaluationMs = C.TIME_UNSET;
+        this.selectedIndex = determineIdealSelectedIndex(Long.MIN_VALUE);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public void updateSelectedTrack(long j, long j2, long j3) {
+        long elapsedRealtime = this.clock.elapsedRealtime();
+        int i = this.selectedIndex;
+        int determineIdealSelectedIndex = determineIdealSelectedIndex(elapsedRealtime);
+        this.selectedIndex = determineIdealSelectedIndex;
+        if (determineIdealSelectedIndex == i) {
+            return;
+        }
+        if (!isBlacklisted(i, elapsedRealtime)) {
+            Format format = getFormat(i);
+            Format format2 = getFormat(this.selectedIndex);
+            if (format2.bitrate > format.bitrate && j2 < minDurationForQualityIncreaseUs(j3)) {
+                this.selectedIndex = i;
+            } else if (format2.bitrate < format.bitrate && j2 >= this.maxDurationForQualityDecreaseUs) {
+                this.selectedIndex = i;
+            }
+        }
+        if (this.selectedIndex != i) {
+            this.reason = 3;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.BaseTrackSelection, com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public int evaluateQueueSize(long j, List<? extends MediaChunk> list) {
+        int i;
+        int i2;
+        long elapsedRealtime = this.clock.elapsedRealtime();
+        long j2 = this.lastBufferEvaluationMs;
+        if (j2 != C.TIME_UNSET && elapsedRealtime - j2 < this.minTimeBetweenBufferReevaluationMs) {
+            return list.size();
+        }
+        this.lastBufferEvaluationMs = elapsedRealtime;
+        if (list.isEmpty()) {
+            return 0;
+        }
+        int size = list.size();
+        if (Util.getPlayoutDurationForMediaDuration(list.get(size - 1).startTimeUs - j, this.playbackSpeed) < this.minDurationToRetainAfterDiscardUs) {
+            return size;
+        }
+        Format format = getFormat(determineIdealSelectedIndex(elapsedRealtime));
+        for (int i3 = 0; i3 < size; i3++) {
+            MediaChunk mediaChunk = list.get(i3);
+            Format format2 = mediaChunk.trackFormat;
+            if (Util.getPlayoutDurationForMediaDuration(mediaChunk.startTimeUs - j, this.playbackSpeed) >= this.minDurationToRetainAfterDiscardUs && format2.bitrate < format.bitrate && (i = format2.height) != -1 && i < 720 && (i2 = format2.width) != -1 && i2 < 1280 && i < format.height) {
+                return i3;
+            }
+        }
+        return size;
+    }
+
+    private int determineIdealSelectedIndex(long j) {
+        long bitrateEstimate = (long) (this.bandwidthMeter.getBitrateEstimate() * this.bandwidthFraction);
+        int i = 0;
+        for (int i2 = 0; i2 < this.length; i2++) {
+            if (j == Long.MIN_VALUE || !isBlacklisted(i2, j)) {
+                if (Math.round(getFormat(i2).bitrate * this.playbackSpeed) <= bitrateEstimate) {
+                    return i2;
+                }
+                i = i2;
+            }
+        }
+        return i;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/trackselection/BaseTrackSelection.java

@@ -0,0 +1,161 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import android.os.SystemClock;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroup;
+import com.mbridge.msdk.playercommon.exoplayer2.source.chunk.MediaChunk;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public abstract class BaseTrackSelection implements TrackSelection {
+    private final long[] blacklistUntilTimes;
+    private final Format[] formats;
+    protected final TrackGroup group;
+    private int hashCode;
+    protected final int length;
+    protected final int[] tracks;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public void disable() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public void enable() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final TrackGroup getTrackGroup() {
+        return this.group;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public void onPlaybackSpeed(float f) {
+    }
+
+    public BaseTrackSelection(TrackGroup trackGroup, int... iArr) {
+        int i = 0;
+        Assertions.checkState(iArr.length > 0);
+        this.group = (TrackGroup) Assertions.checkNotNull(trackGroup);
+        int length = iArr.length;
+        this.length = length;
+        this.formats = new Format[length];
+        for (int i2 = 0; i2 < iArr.length; i2++) {
+            this.formats[i2] = trackGroup.getFormat(iArr[i2]);
+        }
+        Arrays.sort(this.formats, new DecreasingBandwidthComparator());
+        this.tracks = new int[this.length];
+        while (true) {
+            int i3 = this.length;
+            if (i < i3) {
+                this.tracks[i] = trackGroup.indexOf(this.formats[i]);
+                i++;
+            } else {
+                this.blacklistUntilTimes = new long[i3];
+                return;
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int length() {
+        return this.tracks.length;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final Format getFormat(int i) {
+        return this.formats[i];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int getIndexInTrackGroup(int i) {
+        return this.tracks[i];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int indexOf(Format format) {
+        for (int i = 0; i < this.length; i++) {
+            if (this.formats[i] == format) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int indexOf(int i) {
+        for (int i2 = 0; i2 < this.length; i2++) {
+            if (this.tracks[i2] == i) {
+                return i2;
+            }
+        }
+        return -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final Format getSelectedFormat() {
+        return this.formats[getSelectedIndex()];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int getSelectedIndexInTrackGroup() {
+        return this.tracks[getSelectedIndex()];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public int evaluateQueueSize(long j, List<? extends MediaChunk> list) {
+        return list.size();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final boolean blacklist(int i, long j) {
+        long elapsedRealtime = SystemClock.elapsedRealtime();
+        boolean isBlacklisted = isBlacklisted(i, elapsedRealtime);
+        int i2 = 0;
+        while (i2 < this.length && !isBlacklisted) {
+            isBlacklisted = (i2 == i || isBlacklisted(i2, elapsedRealtime)) ? false : true;
+            i2++;
+        }
+        if (!isBlacklisted) {
+            return false;
+        }
+        long[] jArr = this.blacklistUntilTimes;
+        jArr[i] = Math.max(jArr[i], elapsedRealtime + j);
+        return true;
+    }
+
+    public final boolean isBlacklisted(int i, long j) {
+        return this.blacklistUntilTimes[i] > j;
+    }
+
+    public int hashCode() {
+        if (this.hashCode == 0) {
+            this.hashCode = (System.identityHashCode(this.group) * 31) + Arrays.hashCode(this.tracks);
+        }
+        return this.hashCode;
+    }
+
+    public boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        BaseTrackSelection baseTrackSelection = (BaseTrackSelection) obj;
+        return this.group == baseTrackSelection.group && Arrays.equals(this.tracks, baseTrackSelection.tracks);
+    }
+
+    public static final class DecreasingBandwidthComparator implements Comparator<Format> {
+        private DecreasingBandwidthComparator() {
+        }
+
+        @Override // java.util.Comparator
+        public final int compare(Format format, Format format2) {
+            return format2.bitrate - format.bitrate;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/trackselection/FixedTrackSelection.java

@@ -0,0 +1,67 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroup;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public final class FixedTrackSelection extends BaseTrackSelection {
+
+    @Nullable
+    private final Object data;
+    private final int reason;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int getSelectedIndex() {
+        return 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    @Nullable
+    public final Object getSelectionData() {
+        return this.data;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int getSelectionReason() {
+        return this.reason;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final void updateSelectedTrack(long j, long j2, long j3) {
+    }
+
+    public static final class Factory implements TrackSelection.Factory {
+
+        @Nullable
+        private final Object data;
+        private final int reason;
+
+        public Factory() {
+            this.reason = 0;
+            this.data = null;
+        }
+
+        public Factory(int i, @Nullable Object obj) {
+            this.reason = i;
+            this.data = obj;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection.Factory
+        public final FixedTrackSelection createTrackSelection(TrackGroup trackGroup, int... iArr) {
+            Assertions.checkArgument(iArr.length == 1);
+            return new FixedTrackSelection(trackGroup, iArr[0], this.reason, this.data);
+        }
+    }
+
+    public FixedTrackSelection(TrackGroup trackGroup, int i) {
+        this(trackGroup, i, 0, null);
+    }
+
+    public FixedTrackSelection(TrackGroup trackGroup, int i, int i2, @Nullable Object obj) {
+        super(trackGroup, i);
+        this.reason = i2;
+        this.data = obj;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/trackselection/MappingTrackSelector.java

@@ -0,0 +1,262 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities;
+import com.mbridge.msdk.playercommon.exoplayer2.RendererConfiguration;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroup;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public abstract class MappingTrackSelector extends TrackSelector {
+
+    @Nullable
+    private MappedTrackInfo currentMappedTrackInfo;
+
+    @Nullable
+    public final MappedTrackInfo getCurrentMappedTrackInfo() {
+        return this.currentMappedTrackInfo;
+    }
+
+    public abstract Pair<RendererConfiguration[], TrackSelection[]> selectTracks(MappedTrackInfo mappedTrackInfo, int[][][] iArr, int[] iArr2) throws ExoPlaybackException;
+
+    public static final class MappedTrackInfo {
+        public static final int RENDERER_SUPPORT_EXCEEDS_CAPABILITIES_TRACKS = 2;
+        public static final int RENDERER_SUPPORT_NO_TRACKS = 0;
+        public static final int RENDERER_SUPPORT_PLAYABLE_TRACKS = 3;
+        public static final int RENDERER_SUPPORT_UNSUPPORTED_TRACKS = 1;
+
+        @Deprecated
+        public final int length;
+        private final int rendererCount;
+        private final int[][][] rendererFormatSupports;
+        private final int[] rendererMixedMimeTypeAdaptiveSupports;
+        private final TrackGroupArray[] rendererTrackGroups;
+        private final int[] rendererTrackTypes;
+        private final TrackGroupArray unmappedTrackGroups;
+
+        @Retention(RetentionPolicy.SOURCE)
+        public @interface RendererSupport {
+        }
+
+        public final int getRendererCount() {
+            return this.rendererCount;
+        }
+
+        public final TrackGroupArray getUnmappedTrackGroups() {
+            return this.unmappedTrackGroups;
+        }
+
+        public MappedTrackInfo(int[] iArr, TrackGroupArray[] trackGroupArrayArr, int[] iArr2, int[][][] iArr3, TrackGroupArray trackGroupArray) {
+            this.rendererTrackTypes = iArr;
+            this.rendererTrackGroups = trackGroupArrayArr;
+            this.rendererFormatSupports = iArr3;
+            this.rendererMixedMimeTypeAdaptiveSupports = iArr2;
+            this.unmappedTrackGroups = trackGroupArray;
+            int length = iArr.length;
+            this.rendererCount = length;
+            this.length = length;
+        }
+
+        public final int getRendererType(int i) {
+            return this.rendererTrackTypes[i];
+        }
+
+        public final TrackGroupArray getTrackGroups(int i) {
+            return this.rendererTrackGroups[i];
+        }
+
+        /* JADX WARN: Code restructure failed: missing block: B:20:0x0025, code lost:
+        
+            r1 = r1 + 1;
+         */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public final int getRendererSupport(int r8) {
+            /*
+                r7 = this;
+                int[][][] r0 = r7.rendererFormatSupports
+                r8 = r0[r8]
+                r0 = 0
+                r1 = r0
+                r2 = r1
+            L7:
+                int r3 = r8.length
+                if (r1 >= r3) goto L28
+                r3 = r0
+            Lb:
+                r4 = r8[r1]
+                int r5 = r4.length
+                if (r3 >= r5) goto L25
+                r4 = r4[r3]
+                r4 = r4 & 7
+                r5 = 3
+                if (r4 == r5) goto L1d
+                r6 = 4
+                if (r4 == r6) goto L1c
+                r4 = 1
+                goto L1e
+            L1c:
+                return r5
+            L1d:
+                r4 = 2
+            L1e:
+                int r2 = java.lang.Math.max(r2, r4)
+                int r3 = r3 + 1
+                goto Lb
+            L25:
+                int r1 = r1 + 1
+                goto L7
+            L28:
+                return r2
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.trackselection.MappingTrackSelector.MappedTrackInfo.getRendererSupport(int):int");
+        }
+
+        @Deprecated
+        public final int getTrackTypeRendererSupport(int i) {
+            return getTypeSupport(i);
+        }
+
+        public final int getTypeSupport(int i) {
+            int i2 = 0;
+            for (int i3 = 0; i3 < this.rendererCount; i3++) {
+                if (this.rendererTrackTypes[i3] == i) {
+                    i2 = Math.max(i2, getRendererSupport(i3));
+                }
+            }
+            return i2;
+        }
+
+        @Deprecated
+        public final int getTrackFormatSupport(int i, int i2, int i3) {
+            return getTrackSupport(i, i2, i3);
+        }
+
+        public final int getTrackSupport(int i, int i2, int i3) {
+            return this.rendererFormatSupports[i][i2][i3] & 7;
+        }
+
+        public final int getAdaptiveSupport(int i, int i2, boolean z) {
+            int i3 = this.rendererTrackGroups[i].get(i2).length;
+            int[] iArr = new int[i3];
+            int i4 = 0;
+            for (int i5 = 0; i5 < i3; i5++) {
+                int trackSupport = getTrackSupport(i, i2, i5);
+                if (trackSupport == 4 || (z && trackSupport == 3)) {
+                    iArr[i4] = i5;
+                    i4++;
+                }
+            }
+            return getAdaptiveSupport(i, i2, Arrays.copyOf(iArr, i4));
+        }
+
+        public final int getAdaptiveSupport(int i, int i2, int[] iArr) {
+            int i3 = 0;
+            int i4 = 16;
+            String str = null;
+            boolean z = false;
+            int i5 = 0;
+            while (i3 < iArr.length) {
+                String str2 = this.rendererTrackGroups[i].get(i2).getFormat(iArr[i3]).sampleMimeType;
+                int i6 = i5 + 1;
+                if (i5 == 0) {
+                    str = str2;
+                } else {
+                    z |= !Util.areEqual(str, str2);
+                }
+                i4 = Math.min(i4, this.rendererFormatSupports[i][i2][i3] & 24);
+                i3++;
+                i5 = i6;
+            }
+            return z ? Math.min(i4, this.rendererMixedMimeTypeAdaptiveSupports[i]) : i4;
+        }
+
+        @Deprecated
+        public final TrackGroupArray getUnassociatedTrackGroups() {
+            return getUnmappedTrackGroups();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelector
+    public final void onSelectionActivated(Object obj) {
+        this.currentMappedTrackInfo = (MappedTrackInfo) obj;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelector
+    public final TrackSelectorResult selectTracks(RendererCapabilities[] rendererCapabilitiesArr, TrackGroupArray trackGroupArray) throws ExoPlaybackException {
+        int[] iArr = new int[rendererCapabilitiesArr.length + 1];
+        int length = rendererCapabilitiesArr.length + 1;
+        TrackGroup[][] trackGroupArr = new TrackGroup[length][];
+        int[][][] iArr2 = new int[rendererCapabilitiesArr.length + 1][][];
+        for (int i = 0; i < length; i++) {
+            int i2 = trackGroupArray.length;
+            trackGroupArr[i] = new TrackGroup[i2];
+            iArr2[i] = new int[i2][];
+        }
+        int[] mixedMimeTypeAdaptationSupports = getMixedMimeTypeAdaptationSupports(rendererCapabilitiesArr);
+        for (int i3 = 0; i3 < trackGroupArray.length; i3++) {
+            TrackGroup trackGroup = trackGroupArray.get(i3);
+            int findRenderer = findRenderer(rendererCapabilitiesArr, trackGroup);
+            int[] formatSupport = findRenderer == rendererCapabilitiesArr.length ? new int[trackGroup.length] : getFormatSupport(rendererCapabilitiesArr[findRenderer], trackGroup);
+            int i4 = iArr[findRenderer];
+            trackGroupArr[findRenderer][i4] = trackGroup;
+            iArr2[findRenderer][i4] = formatSupport;
+            iArr[findRenderer] = i4 + 1;
+        }
+        TrackGroupArray[] trackGroupArrayArr = new TrackGroupArray[rendererCapabilitiesArr.length];
+        int[] iArr3 = new int[rendererCapabilitiesArr.length];
+        for (int i5 = 0; i5 < rendererCapabilitiesArr.length; i5++) {
+            int i6 = iArr[i5];
+            trackGroupArrayArr[i5] = new TrackGroupArray((TrackGroup[]) Util.nullSafeArrayCopy(trackGroupArr[i5], i6));
+            iArr2[i5] = (int[][]) Util.nullSafeArrayCopy(iArr2[i5], i6);
+            iArr3[i5] = rendererCapabilitiesArr[i5].getTrackType();
+        }
+        MappedTrackInfo mappedTrackInfo = new MappedTrackInfo(iArr3, trackGroupArrayArr, mixedMimeTypeAdaptationSupports, iArr2, new TrackGroupArray((TrackGroup[]) Util.nullSafeArrayCopy(trackGroupArr[rendererCapabilitiesArr.length], iArr[rendererCapabilitiesArr.length])));
+        Pair<RendererConfiguration[], TrackSelection[]> selectTracks = selectTracks(mappedTrackInfo, iArr2, mixedMimeTypeAdaptationSupports);
+        return new TrackSelectorResult((RendererConfiguration[]) selectTracks.first, (TrackSelection[]) selectTracks.second, mappedTrackInfo);
+    }
+
+    private static int findRenderer(RendererCapabilities[] rendererCapabilitiesArr, TrackGroup trackGroup) throws ExoPlaybackException {
+        int length = rendererCapabilitiesArr.length;
+        int i = 0;
+        for (int i2 = 0; i2 < rendererCapabilitiesArr.length; i2++) {
+            RendererCapabilities rendererCapabilities = rendererCapabilitiesArr[i2];
+            for (int i3 = 0; i3 < trackGroup.length; i3++) {
+                int supportsFormat = rendererCapabilities.supportsFormat(trackGroup.getFormat(i3)) & 7;
+                if (supportsFormat > i) {
+                    if (supportsFormat == 4) {
+                        return i2;
+                    }
+                    length = i2;
+                    i = supportsFormat;
+                }
+            }
+        }
+        return length;
+    }
+
+    private static int[] getFormatSupport(RendererCapabilities rendererCapabilities, TrackGroup trackGroup) throws ExoPlaybackException {
+        int[] iArr = new int[trackGroup.length];
+        for (int i = 0; i < trackGroup.length; i++) {
+            iArr[i] = rendererCapabilities.supportsFormat(trackGroup.getFormat(i));
+        }
+        return iArr;
+    }
+
+    private static int[] getMixedMimeTypeAdaptationSupports(RendererCapabilities[] rendererCapabilitiesArr) throws ExoPlaybackException {
+        int length = rendererCapabilitiesArr.length;
+        int[] iArr = new int[length];
+        for (int i = 0; i < length; i++) {
+            iArr[i] = rendererCapabilitiesArr[i].supportsMixedMimeTypeAdaptation();
+        }
+        return iArr;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/trackselection/RandomTrackSelection.java

@@ -0,0 +1,88 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import android.os.SystemClock;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroup;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection;
+import java.util.Random;
+
+/* loaded from: classes4.dex */
+public final class RandomTrackSelection extends BaseTrackSelection {
+    private final Random random;
+    private int selectedIndex;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int getSelectedIndex() {
+        return this.selectedIndex;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    @Nullable
+    public final Object getSelectionData() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final int getSelectionReason() {
+        return 3;
+    }
+
+    public static final class Factory implements TrackSelection.Factory {
+        private final Random random;
+
+        public Factory() {
+            this.random = new Random();
+        }
+
+        public Factory(int i) {
+            this.random = new Random(i);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection.Factory
+        public final RandomTrackSelection createTrackSelection(TrackGroup trackGroup, int... iArr) {
+            return new RandomTrackSelection(trackGroup, iArr, this.random);
+        }
+    }
+
+    public RandomTrackSelection(TrackGroup trackGroup, int... iArr) {
+        super(trackGroup, iArr);
+        Random random = new Random();
+        this.random = random;
+        this.selectedIndex = random.nextInt(this.length);
+    }
+
+    public RandomTrackSelection(TrackGroup trackGroup, int[] iArr, long j) {
+        this(trackGroup, iArr, new Random(j));
+    }
+
+    public RandomTrackSelection(TrackGroup trackGroup, int[] iArr, Random random) {
+        super(trackGroup, iArr);
+        this.random = random;
+        this.selectedIndex = random.nextInt(this.length);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection
+    public final void updateSelectedTrack(long j, long j2, long j3) {
+        long elapsedRealtime = SystemClock.elapsedRealtime();
+        int i = 0;
+        for (int i2 = 0; i2 < this.length; i2++) {
+            if (!isBlacklisted(i2, elapsedRealtime)) {
+                i++;
+            }
+        }
+        this.selectedIndex = this.random.nextInt(i);
+        if (i != this.length) {
+            int i3 = 0;
+            for (int i4 = 0; i4 < this.length; i4++) {
+                if (!isBlacklisted(i4, elapsedRealtime)) {
+                    int i5 = i3 + 1;
+                    if (this.selectedIndex == i3) {
+                        this.selectedIndex = i4;
+                        return;
+                    }
+                    i3 = i5;
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/trackselection/TrackSelection.java

@@ -0,0 +1,50 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroup;
+import com.mbridge.msdk.playercommon.exoplayer2.source.chunk.MediaChunk;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public interface TrackSelection {
+
+    public interface Factory {
+        TrackSelection createTrackSelection(TrackGroup trackGroup, int... iArr);
+    }
+
+    boolean blacklist(int i, long j);
+
+    void disable();
+
+    void enable();
+
+    int evaluateQueueSize(long j, List<? extends MediaChunk> list);
+
+    Format getFormat(int i);
+
+    int getIndexInTrackGroup(int i);
+
+    Format getSelectedFormat();
+
+    int getSelectedIndex();
+
+    int getSelectedIndexInTrackGroup();
+
+    @Nullable
+    Object getSelectionData();
+
+    int getSelectionReason();
+
+    TrackGroup getTrackGroup();
+
+    int indexOf(int i);
+
+    int indexOf(Format format);
+
+    int length();
+
+    void onPlaybackSpeed(float f);
+
+    void updateSelectedTrack(long j, long j2, long j3);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/trackselection/TrackSelectionArray.java

@@ -0,0 +1,43 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import androidx.annotation.Nullable;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class TrackSelectionArray {
+    private int hashCode;
+    public final int length;
+    private final TrackSelection[] trackSelections;
+
+    public TrackSelectionArray(TrackSelection... trackSelectionArr) {
+        this.trackSelections = trackSelectionArr;
+        this.length = trackSelectionArr.length;
+    }
+
+    @Nullable
+    public final TrackSelection get(int i) {
+        return this.trackSelections[i];
+    }
+
+    public final TrackSelection[] getAll() {
+        return (TrackSelection[]) this.trackSelections.clone();
+    }
+
+    public final int hashCode() {
+        if (this.hashCode == 0) {
+            this.hashCode = IronSourceError.ERROR_NON_EXISTENT_INSTANCE + Arrays.hashCode(this.trackSelections);
+        }
+        return this.hashCode;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || TrackSelectionArray.class != obj.getClass()) {
+            return false;
+        }
+        return Arrays.equals(this.trackSelections, ((TrackSelectionArray) obj).trackSelections);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/trackselection/TrackSelector.java

@@ -0,0 +1,32 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+
+/* loaded from: classes4.dex */
+public abstract class TrackSelector {
+
+    @Nullable
+    private InvalidationListener listener;
+
+    public interface InvalidationListener {
+        void onTrackSelectionsInvalidated();
+    }
+
+    public final void init(InvalidationListener invalidationListener) {
+        this.listener = invalidationListener;
+    }
+
+    public abstract void onSelectionActivated(Object obj);
+
+    public abstract TrackSelectorResult selectTracks(RendererCapabilities[] rendererCapabilitiesArr, TrackGroupArray trackGroupArray) throws ExoPlaybackException;
+
+    public final void invalidate() {
+        InvalidationListener invalidationListener = this.listener;
+        if (invalidationListener != null) {
+            invalidationListener.onTrackSelectionsInvalidated();
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/trackselection/TrackSelectorResult.java

@@ -0,0 +1,39 @@
+package com.mbridge.msdk.playercommon.exoplayer2.trackselection;
+
+import com.mbridge.msdk.playercommon.exoplayer2.RendererConfiguration;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public final class TrackSelectorResult {
+    public final Object info;
+    public final int length;
+    public final RendererConfiguration[] rendererConfigurations;
+    public final TrackSelectionArray selections;
+
+    public TrackSelectorResult(RendererConfiguration[] rendererConfigurationArr, TrackSelection[] trackSelectionArr, Object obj) {
+        this.rendererConfigurations = rendererConfigurationArr;
+        this.selections = new TrackSelectionArray(trackSelectionArr);
+        this.info = obj;
+        this.length = rendererConfigurationArr.length;
+    }
+
+    public final boolean isRendererEnabled(int i) {
+        return this.rendererConfigurations[i] != null;
+    }
+
+    public final boolean isEquivalent(TrackSelectorResult trackSelectorResult) {
+        if (trackSelectorResult == null || trackSelectorResult.selections.length != this.selections.length) {
+            return false;
+        }
+        for (int i = 0; i < this.selections.length; i++) {
+            if (!isEquivalent(trackSelectorResult, i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public final boolean isEquivalent(TrackSelectorResult trackSelectorResult, int i) {
+        return trackSelectorResult != null && Util.areEqual(this.rendererConfigurations[i], trackSelectorResult.rendererConfigurations[i]) && Util.areEqual(this.selections.get(i), trackSelectorResult.selections.get(i));
+    }
+}