package androidx.media3.exoplayer.trackselection;

import F3.L;
import F3.M;
import F3.O;
import F3.p0;
import android.os.SystemClock;
import androidx.media3.common.TrackGroup;
import androidx.media3.common.Tracks;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.exoplayer.source.TrackGroupArray;
import androidx.media3.exoplayer.trackselection.DefaultTrackSelector;
import androidx.media3.exoplayer.trackselection.ExoTrackSelection;
import androidx.media3.exoplayer.trackselection.MappingTrackSelector;
import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy;
import java.util.Arrays;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class TrackSelectionUtil {

    public interface AdaptiveTrackSelectionFactory {
        ExoTrackSelection createAdaptiveTrackSelection(ExoTrackSelection.Definition definition);
    }

    private TrackSelectionUtil() {
    }

    public static Tracks buildTracks(MappingTrackSelector.MappedTrackInfo mappedTrackInfo, TrackSelection[] trackSelectionArr) {
        p0 p0VarU;
        List[] listArr = new List[trackSelectionArr.length];
        for (int i6 = 0; i6 < trackSelectionArr.length; i6++) {
            TrackSelection trackSelection = trackSelectionArr[i6];
            if (trackSelection != null) {
                p0VarU = O.u(trackSelection);
            } else {
                M m6 = O.f1509b;
                p0VarU = p0.f1586e;
            }
            listArr[i6] = p0VarU;
        }
        return buildTracks(mappedTrackInfo, (List<? extends TrackSelection>[]) listArr);
    }

    public static LoadErrorHandlingPolicy.FallbackOptions createFallbackOptions(ExoTrackSelection exoTrackSelection) {
        long jElapsedRealtime = SystemClock.elapsedRealtime();
        int length = exoTrackSelection.length();
        int i6 = 0;
        for (int i7 = 0; i7 < length; i7++) {
            if (exoTrackSelection.isTrackExcluded(i7, jElapsedRealtime)) {
                i6++;
            }
        }
        return new LoadErrorHandlingPolicy.FallbackOptions(1, 0, length, i6);
    }

    public static ExoTrackSelection[] createTrackSelectionsForDefinitions(ExoTrackSelection.Definition[] definitionArr, AdaptiveTrackSelectionFactory adaptiveTrackSelectionFactory) {
        ExoTrackSelection[] exoTrackSelectionArr = new ExoTrackSelection[definitionArr.length];
        boolean z6 = false;
        for (int i6 = 0; i6 < definitionArr.length; i6++) {
            ExoTrackSelection.Definition definition = definitionArr[i6];
            if (definition != null) {
                int[] iArr = definition.tracks;
                if (iArr.length <= 1 || z6) {
                    exoTrackSelectionArr[i6] = new FixedTrackSelection(definition.group, iArr[0], definition.type);
                } else {
                    exoTrackSelectionArr[i6] = adaptiveTrackSelectionFactory.createAdaptiveTrackSelection(definition);
                    z6 = true;
                }
            }
        }
        return exoTrackSelectionArr;
    }

    @Deprecated
    public static DefaultTrackSelector.Parameters updateParametersWithOverride(DefaultTrackSelector.Parameters parameters, int i6, TrackGroupArray trackGroupArray, boolean z6, DefaultTrackSelector.SelectionOverride selectionOverride) {
        DefaultTrackSelector.Parameters.Builder rendererDisabled = parameters.buildUpon().clearSelectionOverrides(i6).setRendererDisabled(i6, z6);
        if (selectionOverride != null) {
            rendererDisabled.setSelectionOverride(i6, trackGroupArray, selectionOverride);
        }
        return rendererDisabled.build();
    }

    public static Tracks buildTracks(MappingTrackSelector.MappedTrackInfo mappedTrackInfo, List<? extends TrackSelection>[] listArr) {
        boolean z6;
        L l = new L(4);
        for (int i6 = 0; i6 < mappedTrackInfo.getRendererCount(); i6++) {
            TrackGroupArray trackGroups = mappedTrackInfo.getTrackGroups(i6);
            List<? extends TrackSelection> list = listArr[i6];
            for (int i7 = 0; i7 < trackGroups.length; i7++) {
                TrackGroup trackGroup = trackGroups.get(i7);
                boolean z7 = mappedTrackInfo.getAdaptiveSupport(i6, i7, false) != 0;
                int i8 = trackGroup.length;
                int[] iArr = new int[i8];
                boolean[] zArr = new boolean[i8];
                for (int i9 = 0; i9 < trackGroup.length; i9++) {
                    iArr[i9] = mappedTrackInfo.getTrackSupport(i6, i7, i9);
                    int i10 = 0;
                    while (true) {
                        if (i10 >= list.size()) {
                            z6 = false;
                            break;
                        }
                        TrackSelection trackSelection = list.get(i10);
                        if (trackSelection.getTrackGroup().equals(trackGroup) && trackSelection.indexOf(i9) != -1) {
                            z6 = true;
                            break;
                        }
                        i10++;
                    }
                    zArr[i9] = z6;
                }
                l.a(new Tracks.Group(trackGroup, z7, iArr, zArr));
            }
        }
        TrackGroupArray unmappedTrackGroups = mappedTrackInfo.getUnmappedTrackGroups();
        for (int i11 = 0; i11 < unmappedTrackGroups.length; i11++) {
            TrackGroup trackGroup2 = unmappedTrackGroups.get(i11);
            int[] iArr2 = new int[trackGroup2.length];
            Arrays.fill(iArr2, 0);
            l.a(new Tracks.Group(trackGroup2, false, iArr2, new boolean[trackGroup2.length]));
        }
        return new Tracks(l.f());
    }
}