package androidx.media3.exoplayer.trackselection;

import F3.AbstractC0220u;
import F3.L;
import F3.M;
import F3.O;
import F3.k0;
import F3.l0;
import F3.n0;
import F3.p0;
import androidx.media3.common.C;
import androidx.media3.common.Format;
import androidx.media3.common.Timeline;
import androidx.media3.common.TrackGroup;
import androidx.media3.common.util.Clock;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.Util;
import androidx.media3.exoplayer.source.MediaSource;
import androidx.media3.exoplayer.source.chunk.MediaChunk;
import androidx.media3.exoplayer.source.chunk.MediaChunkIterator;
import androidx.media3.exoplayer.trackselection.ExoTrackSelection;
import androidx.media3.exoplayer.upstream.BandwidthMeter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.TreeMap;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public class AdaptiveTrackSelection extends BaseTrackSelection {
    public static final float DEFAULT_BANDWIDTH_FRACTION = 0.7f;
    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_MAX_HEIGHT_TO_DISCARD = 719;
    public static final int DEFAULT_MAX_WIDTH_TO_DISCARD = 1279;
    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;
    private static final long MIN_TIME_BETWEEN_BUFFER_REEVALUTATION_MS = 1000;
    private static final String TAG = "AdaptiveTrackSelection";
    private final O adaptationCheckpoints;
    private final float bandwidthFraction;
    private final BandwidthMeter bandwidthMeter;
    private final float bufferedFractionToLiveEdgeForQualityIncrease;
    private final Clock clock;
    private MediaChunk lastBufferEvaluationMediaChunk;
    private long lastBufferEvaluationMs;
    private long latestBitrateEstimate;
    private final long maxDurationForQualityDecreaseUs;
    private final int maxHeightToDiscard;
    private final int maxWidthToDiscard;
    private final long minDurationForQualityIncreaseUs;
    private final long minDurationToRetainAfterDiscardUs;
    private float playbackSpeed;
    private int reason;
    private int selectedIndex;

    public static final class AdaptationCheckpoint {
        public final long allocatedBandwidth;
        public final long totalBandwidth;

        public AdaptationCheckpoint(long j4, long j6) {
            this.totalBandwidth = j4;
            this.allocatedBandwidth = j6;
        }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof AdaptationCheckpoint)) {
                return false;
            }
            AdaptationCheckpoint adaptationCheckpoint = (AdaptationCheckpoint) obj;
            return this.totalBandwidth == adaptationCheckpoint.totalBandwidth && this.allocatedBandwidth == adaptationCheckpoint.allocatedBandwidth;
        }

        public int hashCode() {
            return (((int) this.totalBandwidth) * 31) + ((int) this.allocatedBandwidth);
        }
    }

    public static class Factory implements ExoTrackSelection.Factory {
        private final float bandwidthFraction;
        private final float bufferedFractionToLiveEdgeForQualityIncrease;
        private final Clock clock;
        private final int maxDurationForQualityDecreaseMs;
        private final int maxHeightToDiscard;
        private final int maxWidthToDiscard;
        private final int minDurationForQualityIncreaseMs;
        private final int minDurationToRetainAfterDiscardMs;

        public Factory() {
            this(10000, 25000, 25000, 0.7f);
        }

        public AdaptiveTrackSelection createAdaptiveTrackSelection(TrackGroup trackGroup, int[] iArr, int i6, BandwidthMeter bandwidthMeter, O o6) {
            return new AdaptiveTrackSelection(trackGroup, iArr, i6, bandwidthMeter, this.minDurationForQualityIncreaseMs, this.maxDurationForQualityDecreaseMs, this.minDurationToRetainAfterDiscardMs, this.maxWidthToDiscard, this.maxHeightToDiscard, this.bandwidthFraction, this.bufferedFractionToLiveEdgeForQualityIncrease, o6, this.clock);
        }

        /* JADX WARN: Removed duplicated region for block: B:9:0x0015  */
        @Override // androidx.media3.exoplayer.trackselection.ExoTrackSelection.Factory
        /*
            Code decompiled incorrectly, please refer to instructions dump.
        */
        public final ExoTrackSelection[] createTrackSelections(ExoTrackSelection.Definition[] definitionArr, BandwidthMeter bandwidthMeter, MediaSource.MediaPeriodId mediaPeriodId, Timeline timeline) {
            BandwidthMeter bandwidthMeter2;
            ExoTrackSelection exoTrackSelectionCreateAdaptiveTrackSelection;
            O adaptationCheckpoints = AdaptiveTrackSelection.getAdaptationCheckpoints(definitionArr);
            ExoTrackSelection[] exoTrackSelectionArr = new ExoTrackSelection[definitionArr.length];
            int i6 = 0;
            while (i6 < definitionArr.length) {
                ExoTrackSelection.Definition definition = definitionArr[i6];
                if (definition != null) {
                    int[] iArr = definition.tracks;
                    if (iArr.length == 0) {
                        bandwidthMeter2 = bandwidthMeter;
                    } else {
                        if (iArr.length == 1) {
                            exoTrackSelectionCreateAdaptiveTrackSelection = new FixedTrackSelection(definition.group, iArr[0], definition.type);
                            bandwidthMeter2 = bandwidthMeter;
                        } else {
                            bandwidthMeter2 = bandwidthMeter;
                            exoTrackSelectionCreateAdaptiveTrackSelection = createAdaptiveTrackSelection(definition.group, iArr, definition.type, bandwidthMeter2, (O) adaptationCheckpoints.get(i6));
                        }
                        exoTrackSelectionArr[i6] = exoTrackSelectionCreateAdaptiveTrackSelection;
                    }
                }
                i6++;
                bandwidthMeter = bandwidthMeter2;
            }
            return exoTrackSelectionArr;
        }

        public Factory(int i6, int i7, int i8, float f6) {
            this(i6, i7, i8, AdaptiveTrackSelection.DEFAULT_MAX_WIDTH_TO_DISCARD, AdaptiveTrackSelection.DEFAULT_MAX_HEIGHT_TO_DISCARD, f6, 0.75f, Clock.DEFAULT);
        }

        public Factory(int i6, int i7, int i8, int i9, int i10, float f6) {
            this(i6, i7, i8, i9, i10, f6, 0.75f, Clock.DEFAULT);
        }

        public Factory(int i6, int i7, int i8, float f6, float f7, Clock clock) {
            this(i6, i7, i8, AdaptiveTrackSelection.DEFAULT_MAX_WIDTH_TO_DISCARD, AdaptiveTrackSelection.DEFAULT_MAX_HEIGHT_TO_DISCARD, f6, f7, clock);
        }

        public Factory(int i6, int i7, int i8, int i9, int i10, float f6, float f7, Clock clock) {
            this.minDurationForQualityIncreaseMs = i6;
            this.maxDurationForQualityDecreaseMs = i7;
            this.minDurationToRetainAfterDiscardMs = i8;
            this.maxWidthToDiscard = i9;
            this.maxHeightToDiscard = i10;
            this.bandwidthFraction = f6;
            this.bufferedFractionToLiveEdgeForQualityIncrease = f7;
            this.clock = clock;
        }
    }

    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
    public AdaptiveTrackSelection(TrackGroup trackGroup, int[] iArr, BandwidthMeter bandwidthMeter) {
        this(trackGroup, iArr, 0, bandwidthMeter, 10000L, 25000L, 25000L, DEFAULT_MAX_WIDTH_TO_DISCARD, DEFAULT_MAX_HEIGHT_TO_DISCARD, 0.7f, 0.75f, p0.f1586e, Clock.DEFAULT);
        M m6 = O.f1509b;
    }

    private static void addCheckpoint(List<L> list, long[] jArr) {
        long j4 = 0;
        for (long j6 : jArr) {
            j4 += j6;
        }
        for (int i6 = 0; i6 < list.size(); i6++) {
            L l = list.get(i6);
            if (l != null) {
                l.a(new AdaptationCheckpoint(j4, jArr[i6]));
            }
        }
    }

    private int determineIdealSelectedIndex(long j4, long j6) {
        long allocatedBandwidth = getAllocatedBandwidth(j6);
        int i6 = 0;
        for (int i7 = 0; i7 < this.length; i7++) {
            if (j4 == Long.MIN_VALUE || !isTrackExcluded(i7, j4)) {
                Format format = getFormat(i7);
                if (canSelectFormat(format, format.bitrate, allocatedBandwidth)) {
                    return i7;
                }
                i6 = i7;
            }
        }
        return i6;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static O getAdaptationCheckpoints(ExoTrackSelection.Definition[] definitionArr) {
        ArrayList arrayList = new ArrayList();
        for (ExoTrackSelection.Definition definition : definitionArr) {
            if (definition == null || definition.tracks.length <= 1) {
                arrayList.add(null);
            } else {
                L lO = O.o();
                lO.a(new AdaptationCheckpoint(0L, 0L));
                arrayList.add(lO);
            }
        }
        long[][] sortedTrackBitrates = getSortedTrackBitrates(definitionArr);
        int[] iArr = new int[sortedTrackBitrates.length];
        long[] jArr = new long[sortedTrackBitrates.length];
        for (int i6 = 0; i6 < sortedTrackBitrates.length; i6++) {
            long[] jArr2 = sortedTrackBitrates[i6];
            jArr[i6] = jArr2.length == 0 ? 0L : jArr2[0];
        }
        addCheckpoint(arrayList, jArr);
        O switchOrder = getSwitchOrder(sortedTrackBitrates);
        for (int i7 = 0; i7 < switchOrder.size(); i7++) {
            int iIntValue = ((Integer) switchOrder.get(i7)).intValue();
            int i8 = iArr[iIntValue] + 1;
            iArr[iIntValue] = i8;
            jArr[iIntValue] = sortedTrackBitrates[iIntValue][i8];
            addCheckpoint(arrayList, jArr);
        }
        for (int i9 = 0; i9 < definitionArr.length; i9++) {
            if (arrayList.get(i9) != null) {
                jArr[i9] = jArr[i9] * 2;
            }
        }
        addCheckpoint(arrayList, jArr);
        L lO2 = O.o();
        for (int i10 = 0; i10 < arrayList.size(); i10++) {
            L l = (L) arrayList.get(i10);
            lO2.a(l == null ? p0.f1586e : l.f());
        }
        return lO2.f();
    }

    private long getAllocatedBandwidth(long j4) {
        long totalAllocatableBandwidth = getTotalAllocatableBandwidth(j4);
        if (this.adaptationCheckpoints.isEmpty()) {
            return totalAllocatableBandwidth;
        }
        int i6 = 1;
        while (i6 < this.adaptationCheckpoints.size() - 1 && ((AdaptationCheckpoint) this.adaptationCheckpoints.get(i6)).totalBandwidth < totalAllocatableBandwidth) {
            i6++;
        }
        AdaptationCheckpoint adaptationCheckpoint = (AdaptationCheckpoint) this.adaptationCheckpoints.get(i6 - 1);
        AdaptationCheckpoint adaptationCheckpoint2 = (AdaptationCheckpoint) this.adaptationCheckpoints.get(i6);
        long j6 = adaptationCheckpoint.totalBandwidth;
        float f6 = (totalAllocatableBandwidth - j6) / (adaptationCheckpoint2.totalBandwidth - j6);
        return adaptationCheckpoint.allocatedBandwidth + ((long) (f6 * (adaptationCheckpoint2.allocatedBandwidth - r2)));
    }

    private long getLastChunkDurationUs(List<? extends MediaChunk> list) {
        if (list.isEmpty()) {
            return C.TIME_UNSET;
        }
        MediaChunk mediaChunk = (MediaChunk) AbstractC0220u.k(list);
        long j4 = mediaChunk.startTimeUs;
        if (j4 != C.TIME_UNSET) {
            long j6 = mediaChunk.endTimeUs;
            if (j6 != C.TIME_UNSET) {
                return j6 - j4;
            }
        }
        return C.TIME_UNSET;
    }

    private long getNextChunkDurationUs(MediaChunkIterator[] mediaChunkIteratorArr, List<? extends MediaChunk> list) {
        int i6 = this.selectedIndex;
        if (i6 < mediaChunkIteratorArr.length && mediaChunkIteratorArr[i6].next()) {
            MediaChunkIterator mediaChunkIterator = mediaChunkIteratorArr[this.selectedIndex];
            return mediaChunkIterator.getChunkEndTimeUs() - mediaChunkIterator.getChunkStartTimeUs();
        }
        for (MediaChunkIterator mediaChunkIterator2 : mediaChunkIteratorArr) {
            if (mediaChunkIterator2.next()) {
                return mediaChunkIterator2.getChunkEndTimeUs() - mediaChunkIterator2.getChunkStartTimeUs();
            }
        }
        return getLastChunkDurationUs(list);
    }

    private static long[][] getSortedTrackBitrates(ExoTrackSelection.Definition[] definitionArr) {
        long[][] jArr = new long[definitionArr.length][];
        for (int i6 = 0; i6 < definitionArr.length; i6++) {
            ExoTrackSelection.Definition definition = definitionArr[i6];
            if (definition == null) {
                jArr[i6] = new long[0];
            } else {
                jArr[i6] = new long[definition.tracks.length];
                int i7 = 0;
                while (true) {
                    int[] iArr = definition.tracks;
                    if (i7 >= iArr.length) {
                        break;
                    }
                    long j4 = definition.group.getFormat(iArr[i7]).bitrate;
                    long[] jArr2 = jArr[i6];
                    if (j4 == -1) {
                        j4 = 0;
                    }
                    jArr2[i7] = j4;
                    i7++;
                }
                Arrays.sort(jArr[i6]);
            }
        }
        return jArr;
    }

    private static O getSwitchOrder(long[][] jArr) {
        AbstractC0220u.d(2, "expectedValuesPerKey");
        TreeMap treeMap = new TreeMap(n0.f1581b);
        k0 k0Var = new k0();
        l0 l0Var = new l0(treeMap);
        l0Var.f1573j = k0Var;
        for (int i6 = 0; i6 < jArr.length; i6++) {
            long[] jArr2 = jArr[i6];
            if (jArr2.length > 1) {
                int length = jArr2.length;
                double[] dArr = new double[length];
                int i7 = 0;
                while (true) {
                    long[] jArr3 = jArr[i6];
                    double dLog = 0.0d;
                    if (i7 >= jArr3.length) {
                        break;
                    }
                    long j4 = jArr3[i7];
                    if (j4 != -1) {
                        dLog = Math.log(j4);
                    }
                    dArr[i7] = dLog;
                    i7++;
                }
                int i8 = length - 1;
                double d6 = dArr[i8] - dArr[0];
                int i9 = 0;
                while (i9 < i8) {
                    double d7 = dArr[i9];
                    i9++;
                    l0Var.put(Double.valueOf(d6 == 0.0d ? 1.0d : (((d7 + dArr[i9]) * 0.5d) - dArr[0]) / d6), Integer.valueOf(i6));
                }
            }
        }
        return O.p(l0Var.values());
    }

    private long getTotalAllocatableBandwidth(long j4) {
        long bitrateEstimate = this.bandwidthMeter.getBitrateEstimate();
        this.latestBitrateEstimate = bitrateEstimate;
        long j6 = (long) (bitrateEstimate * this.bandwidthFraction);
        long timeToFirstByteEstimateUs = this.bandwidthMeter.getTimeToFirstByteEstimateUs();
        if (timeToFirstByteEstimateUs == C.TIME_UNSET || j4 == C.TIME_UNSET) {
            return (long) (j6 / this.playbackSpeed);
        }
        float f6 = j4;
        return (long) ((j6 * Math.max((f6 / this.playbackSpeed) - timeToFirstByteEstimateUs, 0.0f)) / f6);
    }

    private long minDurationForQualityIncreaseUs(long j4, long j6) {
        if (j4 == C.TIME_UNSET) {
            return this.minDurationForQualityIncreaseUs;
        }
        if (j6 != C.TIME_UNSET) {
            j4 -= j6;
        }
        return Math.min((long) (j4 * this.bufferedFractionToLiveEdgeForQualityIncrease), this.minDurationForQualityIncreaseUs);
    }

    public boolean canSelectFormat(Format format, int i6, long j4) {
        return ((long) i6) <= j4;
    }

    @Override // androidx.media3.exoplayer.trackselection.BaseTrackSelection, androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public void disable() {
        this.lastBufferEvaluationMediaChunk = null;
    }

    @Override // androidx.media3.exoplayer.trackselection.BaseTrackSelection, androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public void enable() {
        this.lastBufferEvaluationMs = C.TIME_UNSET;
        this.lastBufferEvaluationMediaChunk = null;
    }

    @Override // androidx.media3.exoplayer.trackselection.BaseTrackSelection, androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public int evaluateQueueSize(long j4, List<? extends MediaChunk> list) {
        int i6;
        int i7;
        long jElapsedRealtime = this.clock.elapsedRealtime();
        if (!shouldEvaluateQueueSize(jElapsedRealtime, list)) {
            return list.size();
        }
        this.lastBufferEvaluationMs = jElapsedRealtime;
        this.lastBufferEvaluationMediaChunk = list.isEmpty() ? null : (MediaChunk) AbstractC0220u.k(list);
        if (list.isEmpty()) {
            return 0;
        }
        int size = list.size();
        long playoutDurationForMediaDuration = Util.getPlayoutDurationForMediaDuration(list.get(size - 1).startTimeUs - j4, this.playbackSpeed);
        long minDurationToRetainAfterDiscardUs = getMinDurationToRetainAfterDiscardUs();
        if (playoutDurationForMediaDuration >= minDurationToRetainAfterDiscardUs) {
            Format format = getFormat(determineIdealSelectedIndex(jElapsedRealtime, getLastChunkDurationUs(list)));
            for (int i8 = 0; i8 < size; i8++) {
                MediaChunk mediaChunk = list.get(i8);
                Format format2 = mediaChunk.trackFormat;
                if (Util.getPlayoutDurationForMediaDuration(mediaChunk.startTimeUs - j4, this.playbackSpeed) >= minDurationToRetainAfterDiscardUs && format2.bitrate < format.bitrate && (i6 = format2.height) != -1 && i6 <= this.maxHeightToDiscard && (i7 = format2.width) != -1 && i7 <= this.maxWidthToDiscard && i6 < format.height) {
                    return i8;
                }
            }
        }
        return size;
    }

    @Override // androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public long getLatestBitrateEstimate() {
        return this.latestBitrateEstimate;
    }

    public long getMinDurationToRetainAfterDiscardUs() {
        return this.minDurationToRetainAfterDiscardUs;
    }

    @Override // androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public int getSelectedIndex() {
        return this.selectedIndex;
    }

    @Override // androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public Object getSelectionData() {
        return null;
    }

    @Override // androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public int getSelectionReason() {
        return this.reason;
    }

    @Override // androidx.media3.exoplayer.trackselection.BaseTrackSelection, androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public void onPlaybackSpeed(float f6) {
        this.playbackSpeed = f6;
    }

    public boolean shouldEvaluateQueueSize(long j4, List<? extends MediaChunk> list) {
        long j6 = this.lastBufferEvaluationMs;
        if (j6 == C.TIME_UNSET || j4 - j6 >= 1000) {
            return true;
        }
        return (list.isEmpty() || ((MediaChunk) AbstractC0220u.k(list)).equals(this.lastBufferEvaluationMediaChunk)) ? false : true;
    }

    @Override // androidx.media3.exoplayer.trackselection.ExoTrackSelection
    public void updateSelectedTrack(long j4, long j6, long j7, List<? extends MediaChunk> list, MediaChunkIterator[] mediaChunkIteratorArr) {
        long jElapsedRealtime = this.clock.elapsedRealtime();
        long nextChunkDurationUs = getNextChunkDurationUs(mediaChunkIteratorArr, list);
        int i6 = this.reason;
        if (i6 == 0) {
            this.reason = 1;
            this.selectedIndex = determineIdealSelectedIndex(jElapsedRealtime, nextChunkDurationUs);
            return;
        }
        int i7 = this.selectedIndex;
        int iIndexOf = list.isEmpty() ? -1 : indexOf(((MediaChunk) AbstractC0220u.k(list)).trackFormat);
        if (iIndexOf != -1) {
            i6 = ((MediaChunk) AbstractC0220u.k(list)).trackSelectionReason;
            i7 = iIndexOf;
        }
        int iDetermineIdealSelectedIndex = determineIdealSelectedIndex(jElapsedRealtime, nextChunkDurationUs);
        if (iDetermineIdealSelectedIndex != i7 && !isTrackExcluded(i7, jElapsedRealtime)) {
            Format format = getFormat(i7);
            Format format2 = getFormat(iDetermineIdealSelectedIndex);
            long jMinDurationForQualityIncreaseUs = minDurationForQualityIncreaseUs(j7, nextChunkDurationUs);
            int i8 = format2.bitrate;
            int i9 = format.bitrate;
            if ((i8 > i9 && j6 < jMinDurationForQualityIncreaseUs) || (i8 < i9 && j6 >= this.maxDurationForQualityDecreaseUs)) {
                iDetermineIdealSelectedIndex = i7;
            }
        }
        if (iDetermineIdealSelectedIndex != i7) {
            i6 = 3;
        }
        this.reason = i6;
        this.selectedIndex = iDetermineIdealSelectedIndex;
    }

    public AdaptiveTrackSelection(TrackGroup trackGroup, int[] iArr, int i6, BandwidthMeter bandwidthMeter, long j4, long j6, long j7, int i7, int i8, float f6, float f7, List<AdaptationCheckpoint> list, Clock clock) {
        long j8;
        super(trackGroup, iArr, i6);
        if (j7 < j4) {
            Log.w(TAG, "Adjusting minDurationToRetainAfterDiscardMs to be at least minDurationForQualityIncreaseMs");
            j8 = j4;
        } else {
            j8 = j7;
        }
        this.bandwidthMeter = bandwidthMeter;
        this.minDurationForQualityIncreaseUs = j4 * 1000;
        this.maxDurationForQualityDecreaseUs = j6 * 1000;
        this.minDurationToRetainAfterDiscardUs = j8 * 1000;
        this.maxWidthToDiscard = i7;
        this.maxHeightToDiscard = i8;
        this.bandwidthFraction = f6;
        this.bufferedFractionToLiveEdgeForQualityIncrease = f7;
        this.adaptationCheckpoints = O.p(list);
        this.clock = clock;
        this.playbackSpeed = 1.0f;
        this.reason = 0;
        this.lastBufferEvaluationMs = C.TIME_UNSET;
        this.latestBitrateEstimate = -2147483647L;
    }
}