package androidx.media3.exoplayer.trackselection;

import android.util.Pair;
import androidx.media3.common.Timeline;
import androidx.media3.common.TrackGroup;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.Util;
import androidx.media3.exoplayer.RendererCapabilities;
import androidx.media3.exoplayer.RendererConfiguration;
import androidx.media3.exoplayer.source.MediaSource;
import androidx.media3.exoplayer.source.TrackGroupArray;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.Arrays;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public abstract class MappingTrackSelector extends TrackSelector {
    private MappedTrackInfo currentMappedTrackInfo;

    private static int findRenderer(RendererCapabilities[] rendererCapabilitiesArr, TrackGroup trackGroup, int[] iArr, boolean z6) {
        int length = rendererCapabilitiesArr.length;
        int i6 = 0;
        boolean z7 = true;
        for (int i7 = 0; i7 < rendererCapabilitiesArr.length; i7++) {
            RendererCapabilities rendererCapabilities = rendererCapabilitiesArr[i7];
            int iMax = 0;
            for (int i8 = 0; i8 < trackGroup.length; i8++) {
                iMax = Math.max(iMax, RendererCapabilities.getFormatSupport(rendererCapabilities.supportsFormat(trackGroup.getFormat(i8))));
            }
            boolean z8 = iArr[i7] == 0;
            if (iMax > i6 || (iMax == i6 && z6 && !z7 && z8)) {
                length = i7;
                z7 = z8;
                i6 = iMax;
            }
        }
        return length;
    }

    private static int[] getFormatSupport(RendererCapabilities rendererCapabilities, TrackGroup trackGroup) {
        int[] iArr = new int[trackGroup.length];
        for (int i6 = 0; i6 < trackGroup.length; i6++) {
            iArr[i6] = rendererCapabilities.supportsFormat(trackGroup.getFormat(i6));
        }
        return iArr;
    }

    private static int[] getMixedMimeTypeAdaptationSupports(RendererCapabilities[] rendererCapabilitiesArr) {
        int length = rendererCapabilitiesArr.length;
        int[] iArr = new int[length];
        for (int i6 = 0; i6 < length; i6++) {
            iArr[i6] = rendererCapabilitiesArr[i6].supportsMixedMimeTypeAdaptation();
        }
        return iArr;
    }

    public final MappedTrackInfo getCurrentMappedTrackInfo() {
        return this.currentMappedTrackInfo;
    }

    @Override // androidx.media3.exoplayer.trackselection.TrackSelector
    public final void onSelectionActivated(Object obj) {
        this.currentMappedTrackInfo = (MappedTrackInfo) obj;
    }

    public abstract Pair<RendererConfiguration[], ExoTrackSelection[]> selectTracks(MappedTrackInfo mappedTrackInfo, int[][][] iArr, int[] iArr2, MediaSource.MediaPeriodId mediaPeriodId, Timeline timeline);

    @Override // androidx.media3.exoplayer.trackselection.TrackSelector
    public final TrackSelectorResult selectTracks(RendererCapabilities[] rendererCapabilitiesArr, TrackGroupArray trackGroupArray, MediaSource.MediaPeriodId mediaPeriodId, Timeline timeline) {
        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 i6 = 0; i6 < length; i6++) {
            int i7 = trackGroupArray.length;
            trackGroupArr[i6] = new TrackGroup[i7];
            iArr2[i6] = new int[i7][];
        }
        int[] mixedMimeTypeAdaptationSupports = getMixedMimeTypeAdaptationSupports(rendererCapabilitiesArr);
        for (int i8 = 0; i8 < trackGroupArray.length; i8++) {
            TrackGroup trackGroup = trackGroupArray.get(i8);
            int iFindRenderer = findRenderer(rendererCapabilitiesArr, trackGroup, iArr, trackGroup.type == 5);
            int[] formatSupport = iFindRenderer == rendererCapabilitiesArr.length ? new int[trackGroup.length] : getFormatSupport(rendererCapabilitiesArr[iFindRenderer], trackGroup);
            int i9 = iArr[iFindRenderer];
            trackGroupArr[iFindRenderer][i9] = trackGroup;
            iArr2[iFindRenderer][i9] = formatSupport;
            iArr[iFindRenderer] = i9 + 1;
        }
        TrackGroupArray[] trackGroupArrayArr = new TrackGroupArray[rendererCapabilitiesArr.length];
        String[] strArr = new String[rendererCapabilitiesArr.length];
        int[] iArr3 = new int[rendererCapabilitiesArr.length];
        for (int i10 = 0; i10 < rendererCapabilitiesArr.length; i10++) {
            int i11 = iArr[i10];
            trackGroupArrayArr[i10] = new TrackGroupArray((TrackGroup[]) Util.nullSafeArrayCopy(trackGroupArr[i10], i11));
            iArr2[i10] = (int[][]) Util.nullSafeArrayCopy(iArr2[i10], i11);
            strArr[i10] = rendererCapabilitiesArr[i10].getName();
            iArr3[i10] = rendererCapabilitiesArr[i10].getTrackType();
        }
        MappedTrackInfo mappedTrackInfo = new MappedTrackInfo(strArr, iArr3, trackGroupArrayArr, mixedMimeTypeAdaptationSupports, iArr2, new TrackGroupArray((TrackGroup[]) Util.nullSafeArrayCopy(trackGroupArr[rendererCapabilitiesArr.length], iArr[rendererCapabilitiesArr.length])));
        Pair<RendererConfiguration[], ExoTrackSelection[]> pairSelectTracks = selectTracks(mappedTrackInfo, iArr2, mixedMimeTypeAdaptationSupports, mediaPeriodId, timeline);
        return new TrackSelectorResult((RendererConfiguration[]) pairSelectTracks.first, (ExoTrackSelection[]) pairSelectTracks.second, TrackSelectionUtil.buildTracks(mappedTrackInfo, (TrackSelection[]) pairSelectTracks.second), mappedTrackInfo);
    }

    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;
        private final int rendererCount;
        private final int[][][] rendererFormatSupports;
        private final int[] rendererMixedMimeTypeAdaptiveSupports;
        private final String[] rendererNames;
        private final TrackGroupArray[] rendererTrackGroups;
        private final int[] rendererTrackTypes;
        private final TrackGroupArray unmappedTrackGroups;

        @Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE, ElementType.TYPE_USE})
        @Documented
        @Retention(RetentionPolicy.SOURCE)
        public @interface RendererSupport {
        }

        public MappedTrackInfo(String[] strArr, int[] iArr, TrackGroupArray[] trackGroupArrayArr, int[] iArr2, int[][][] iArr3, TrackGroupArray trackGroupArray) {
            this.rendererNames = strArr;
            this.rendererTrackTypes = iArr;
            this.rendererTrackGroups = trackGroupArrayArr;
            this.rendererFormatSupports = iArr3;
            this.rendererMixedMimeTypeAdaptiveSupports = iArr2;
            this.unmappedTrackGroups = trackGroupArray;
            this.rendererCount = iArr.length;
        }

        public int getAdaptiveSupport(int i6, int i7, boolean z6) {
            int i8 = this.rendererTrackGroups[i6].get(i7).length;
            int[] iArr = new int[i8];
            int i9 = 0;
            for (int i10 = 0; i10 < i8; i10++) {
                int trackSupport = getTrackSupport(i6, i7, i10);
                if (trackSupport == 4 || (z6 && trackSupport == 3)) {
                    iArr[i9] = i10;
                    i9++;
                }
            }
            return getAdaptiveSupport(i6, i7, Arrays.copyOf(iArr, i9));
        }

        public int getCapabilities(int i6, int i7, int i8) {
            return this.rendererFormatSupports[i6][i7][i8];
        }

        public int getRendererCount() {
            return this.rendererCount;
        }

        public String getRendererName(int i6) {
            return this.rendererNames[i6];
        }

        public int getRendererSupport(int i6) {
            int iMax = 0;
            for (int[] iArr : this.rendererFormatSupports[i6]) {
                for (int i7 : iArr) {
                    int formatSupport = RendererCapabilities.getFormatSupport(i7);
                    int i8 = 1;
                    if (formatSupport != 0 && formatSupport != 1 && formatSupport != 2) {
                        if (formatSupport != 3) {
                            if (formatSupport == 4) {
                                return 3;
                            }
                            throw new IllegalStateException();
                        }
                        i8 = 2;
                    }
                    iMax = Math.max(iMax, i8);
                }
            }
            return iMax;
        }

        public int getRendererType(int i6) {
            return this.rendererTrackTypes[i6];
        }

        public TrackGroupArray getTrackGroups(int i6) {
            return this.rendererTrackGroups[i6];
        }

        public int getTrackSupport(int i6, int i7, int i8) {
            return RendererCapabilities.getFormatSupport(getCapabilities(i6, i7, i8));
        }

        public int getTypeSupport(int i6) {
            int iMax = 0;
            for (int i7 = 0; i7 < this.rendererCount; i7++) {
                if (this.rendererTrackTypes[i7] == i6) {
                    iMax = Math.max(iMax, getRendererSupport(i7));
                }
            }
            return iMax;
        }

        public TrackGroupArray getUnmappedTrackGroups() {
            return this.unmappedTrackGroups;
        }

        public int getAdaptiveSupport(int i6, int i7, int[] iArr) {
            int i8 = 0;
            int iMin = 16;
            String str = null;
            boolean z6 = false;
            int i9 = 0;
            while (i8 < iArr.length) {
                String str2 = this.rendererTrackGroups[i6].get(i7).getFormat(iArr[i8]).sampleMimeType;
                int i10 = i9 + 1;
                if (i9 == 0) {
                    str = str2;
                } else {
                    z6 |= !Util.areEqual(str, str2);
                }
                iMin = Math.min(iMin, RendererCapabilities.getAdaptiveSupport(this.rendererFormatSupports[i6][i7][i8]));
                i8++;
                i9 = i10;
            }
            return z6 ? Math.min(iMin, this.rendererMixedMimeTypeAdaptiveSupports[i6]) : iMin;
        }
    }
}