package androidx.media3.exoplayer.hls;

import android.annotation.SuppressLint;
import android.net.Uri;
import android.text.TextUtils;
import androidx.annotation.Nullable;
import androidx.media3.common.FileTypes;
import androidx.media3.common.Format;
import androidx.media3.common.Metadata;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.TimestampAdjuster;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.exoplayer.analytics.PlayerId;
import androidx.media3.extractor.y;
import androidx.media3.extractor.z;
import com.google.common.collect.ImmutableList;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.io.EOFException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import l2.q;
import n2.n;
import x2.k0;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class DefaultHlsExtractorFactory implements HlsExtractorFactory {
    private static final int[] DEFAULT_EXTRACTOR_ORDER = {8, 13, 11, 2, 0, 1, 7};
    private int codecsToParseWithinGopSampleDependencies;
    private final boolean exposeCea608WhenMissingDeclarations;
    private boolean parseSubtitlesDuringExtraction;
    private final int payloadReaderFactoryFlags;
    private n subtitleParserFactory;

    public DefaultHlsExtractorFactory() {
        this(0, true);
    }

    private static void addFileTypeIfValidAndNotPresent(int i10, List<Integer> list) {
        int[] iArr = DEFAULT_EXTRACTOR_ORDER;
        if (com.google.common.primitives.a.g(iArr, i10, 0, iArr.length) == -1 || list.contains(Integer.valueOf(i10))) {
            return;
        }
        list.add(Integer.valueOf(i10));
    }

    @Nullable
    @SuppressLint({"SwitchIntDef"})
    private y createExtractorByFileType(int i10, Format format, @Nullable List<Format> list, TimestampAdjuster timestampAdjuster) {
        if (i10 == 0) {
            return new x2.a();
        }
        if (i10 == 1) {
            return new x2.c();
        }
        if (i10 == 2) {
            return new x2.e();
        }
        if (i10 == 7) {
            return new k2.d(0L);
        }
        if (i10 == 8) {
            return createFragmentedMp4Extractor(this.subtitleParserFactory, this.parseSubtitlesDuringExtraction, timestampAdjuster, format, list, this.codecsToParseWithinGopSampleDependencies);
        }
        if (i10 == 11) {
            return createTsExtractor(this.payloadReaderFactoryFlags, this.exposeCea608WhenMissingDeclarations, format, list, timestampAdjuster, this.subtitleParserFactory, this.parseSubtitlesDuringExtraction);
        }
        if (i10 != 13) {
            return null;
        }
        return new WebvttExtractor(format.language, timestampAdjuster, this.subtitleParserFactory, this.parseSubtitlesDuringExtraction);
    }

    private static q createFragmentedMp4Extractor(n nVar, boolean z10, TimestampAdjuster timestampAdjuster, Format format, @Nullable List<Format> list, int i10) {
        int i11 = isFmp4Variant(format) ? 4 : 0;
        if (!z10) {
            nVar = n.f30781a;
            i11 |= 32;
        }
        n nVar2 = nVar;
        int iA = i11 | q.a(i10);
        if (list == null) {
            list = ImmutableList.t();
        }
        return new q(nVar2, iA, timestampAdjuster, null, list, null);
    }

    private static k0 createTsExtractor(int i10, boolean z10, Format format, @Nullable List<Format> list, TimestampAdjuster timestampAdjuster, n nVar, boolean z11) {
        int i11;
        int i12 = i10 | 16;
        if (list != null) {
            i12 = i10 | 48;
        } else {
            list = z10 ? Collections.singletonList(new Format.Builder().setSampleMimeType(MimeTypes.APPLICATION_CEA608).build()) : Collections.emptyList();
        }
        String str = format.codecs;
        if (!TextUtils.isEmpty(str)) {
            if (!MimeTypes.containsCodecsCorrespondingToMimeType(str, MimeTypes.AUDIO_AAC)) {
                i12 |= 2;
            }
            if (!MimeTypes.containsCodecsCorrespondingToMimeType(str, MimeTypes.VIDEO_H264)) {
                i12 |= 4;
            }
        }
        if (z11) {
            i11 = 0;
        } else {
            nVar = n.f30781a;
            i11 = 1;
        }
        return new k0(2, i11, nVar, timestampAdjuster, new x2.g(i12, list));
    }

    private static boolean isFmp4Variant(Format format) {
        Metadata metadata = format.metadata;
        if (metadata == null) {
            return false;
        }
        for (int i10 = 0; i10 < metadata.length(); i10++) {
            if (metadata.get(i10) instanceof HlsTrackMetadataEntry) {
                return !((HlsTrackMetadataEntry) r2).variantInfos.isEmpty();
            }
        }
        return false;
    }

    private static boolean sniffQuietly(y yVar, z zVar) throws IOException {
        try {
            boolean zSniff = yVar.sniff(zVar);
            zVar.j();
            return zSniff;
        } catch (EOFException unused) {
            zVar.j();
            return false;
        } catch (Throwable th) {
            zVar.j();
            throw th;
        }
    }

    @Override // androidx.media3.exoplayer.hls.HlsExtractorFactory
    public /* bridge */ /* synthetic */ HlsMediaChunkExtractor createExtractor(Uri uri, Format format, @Nullable List list, TimestampAdjuster timestampAdjuster, Map map, z zVar, PlayerId playerId) throws IOException {
        return createExtractor(uri, format, (List<Format>) list, timestampAdjuster, (Map<String, List<String>>) map, zVar, playerId);
    }

    @Override // androidx.media3.exoplayer.hls.HlsExtractorFactory
    @CanIgnoreReturnValue
    public DefaultHlsExtractorFactory experimentalParseSubtitlesDuringExtraction(boolean z10) {
        this.parseSubtitlesDuringExtraction = z10;
        return this;
    }

    @Override // androidx.media3.exoplayer.hls.HlsExtractorFactory
    @CanIgnoreReturnValue
    public DefaultHlsExtractorFactory experimentalSetCodecsToParseWithinGopSampleDependencies(int i10) {
        this.codecsToParseWithinGopSampleDependencies = i10;
        return this;
    }

    @Override // androidx.media3.exoplayer.hls.HlsExtractorFactory
    public Format getOutputTextFormat(Format format) {
        String str;
        if (!this.parseSubtitlesDuringExtraction || !this.subtitleParserFactory.supportsFormat(format)) {
            return format;
        }
        Format.Builder cueReplacementBehavior = format.buildUpon().setSampleMimeType(MimeTypes.APPLICATION_MEDIA3_CUES).setCueReplacementBehavior(this.subtitleParserFactory.a(format));
        StringBuilder sb = new StringBuilder();
        sb.append(format.sampleMimeType);
        if (format.codecs != null) {
            str = " " + format.codecs;
        } else {
            str = "";
        }
        sb.append(str);
        return cueReplacementBehavior.setCodecs(sb.toString()).setSubsampleOffsetUs(Long.MAX_VALUE).build();
    }

    @Override // androidx.media3.exoplayer.hls.HlsExtractorFactory
    @CanIgnoreReturnValue
    public DefaultHlsExtractorFactory setSubtitleParserFactory(n nVar) {
        this.subtitleParserFactory = nVar;
        return this;
    }

    public DefaultHlsExtractorFactory(int i10, boolean z10) {
        this.payloadReaderFactoryFlags = i10;
        this.exposeCea608WhenMissingDeclarations = z10;
        this.subtitleParserFactory = new n2.d();
    }

    @Override // androidx.media3.exoplayer.hls.HlsExtractorFactory
    public BundledHlsMediaChunkExtractor createExtractor(Uri uri, Format format, @Nullable List<Format> list, TimestampAdjuster timestampAdjuster, Map<String, List<String>> map, z zVar, PlayerId playerId) throws IOException {
        int iInferFileTypeFromMimeType = FileTypes.inferFileTypeFromMimeType(format.sampleMimeType);
        int iInferFileTypeFromResponseHeaders = FileTypes.inferFileTypeFromResponseHeaders(map);
        int iInferFileTypeFromUri = FileTypes.inferFileTypeFromUri(uri);
        int[] iArr = DEFAULT_EXTRACTOR_ORDER;
        ArrayList arrayList = new ArrayList(iArr.length);
        addFileTypeIfValidAndNotPresent(iInferFileTypeFromMimeType, arrayList);
        addFileTypeIfValidAndNotPresent(iInferFileTypeFromResponseHeaders, arrayList);
        addFileTypeIfValidAndNotPresent(iInferFileTypeFromUri, arrayList);
        for (int i10 : iArr) {
            addFileTypeIfValidAndNotPresent(i10, arrayList);
        }
        zVar.j();
        y yVar = null;
        for (int i11 = 0; i11 < arrayList.size(); i11++) {
            int iIntValue = ((Integer) arrayList.get(i11)).intValue();
            y yVar2 = (y) Assertions.checkNotNull(createExtractorByFileType(iIntValue, format, list, timestampAdjuster));
            if (sniffQuietly(yVar2, zVar)) {
                return new BundledHlsMediaChunkExtractor(yVar2, format, timestampAdjuster, this.subtitleParserFactory, this.parseSubtitlesDuringExtraction);
            }
            if (yVar == null && (iIntValue == iInferFileTypeFromMimeType || iIntValue == iInferFileTypeFromResponseHeaders || iIntValue == iInferFileTypeFromUri || iIntValue == 11)) {
                yVar = yVar2;
            }
        }
        return new BundledHlsMediaChunkExtractor((y) Assertions.checkNotNull(yVar), format, timestampAdjuster, this.subtitleParserFactory, this.parseSubtitlesDuringExtraction);
    }
}