package androidx.media3.exoplayer;

import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.media.MediaCodec;
import android.media.MediaDataSource;
import android.media.MediaFormat;
import android.media.metrics.LogSessionId;
import android.net.Uri;
import android.os.Build;
import android.os.PersistableBundle;
import android.util.Pair;
import android.util.SparseArray;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.annotation.VisibleForTesting;
import androidx.media3.common.C;
import androidx.media3.common.DataReader;
import androidx.media3.common.DrmInitData;
import androidx.media3.common.Format;
import androidx.media3.common.ParserException;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.CodecSpecificDataUtil;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.MediaFormatUtil;
import androidx.media3.common.util.ParsableByteArray;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.Util;
import androidx.media3.datasource.DataSource;
import androidx.media3.datasource.DataSourceUtil;
import androidx.media3.datasource.DataSpec;
import androidx.media3.datasource.DefaultDataSource;
import androidx.media3.datasource.FileDescriptorDataSource;
import androidx.media3.datasource.MediaDataSourceAdapter;
import androidx.media3.exoplayer.mediacodec.MediaCodecUtil;
import androidx.media3.exoplayer.source.SampleQueue;
import androidx.media3.exoplayer.source.UnrecognizedInputFormatException;
import androidx.media3.exoplayer.upstream.Allocator;
import androidx.media3.exoplayer.upstream.DefaultAllocator;
import androidx.media3.extractor.r;
import androidx.media3.extractor.y0;
import androidx.media3.extractor.z0;
import com.google.common.collect.ImmutableList;
import java.io.EOFException;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.nio.ByteBuffer;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import org.checkerframework.checker.nullness.qual.EnsuresNonNullIf;
import tv.danmaku.ijk.media.player.misc.IMediaFormat;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class MediaExtractorCompat {
    private static final long DEFAULT_LAST_SAMPLE_DURATION_US = 10000;
    public static final int SEEK_TO_CLOSEST_SYNC = 2;
    public static final int SEEK_TO_NEXT_SYNC = 1;
    public static final int SEEK_TO_PREVIOUS_SYNC = 0;
    private static final String TAG = "MediaExtractorCompat";
    private final Allocator allocator;

    @Nullable
    private DataSource currentDataSource;

    @Nullable
    private androidx.media3.extractor.y currentExtractor;

    @Nullable
    private androidx.media3.extractor.z currentExtractorInput;
    private final DataSource.Factory dataSourceFactory;
    private final androidx.media3.extractor.e0 extractorsFactory;
    private final FormatHolder formatHolder;
    private boolean hasBeenPrepared;

    @Nullable
    private Map<String, String> httpRequestHeaders;

    @Nullable
    private LogSessionId logSessionId;
    private long offsetInCurrentFile;

    @Nullable
    private androidx.media3.extractor.u0 pendingSeek;
    private final androidx.media3.extractor.r0 positionHolder;
    private final s1.f sampleHolderWithBufferReplacementDisabled;
    private final s1.f sampleHolderWithBufferReplacementEnabled;
    private final SampleMetadataQueue sampleMetadataQueue;
    private final SparseArray<MediaExtractorSampleQueue> sampleQueues;

    @Nullable
    private androidx.media3.extractor.t0 seekMap;
    private final Set<Integer> selectedTrackIndices;
    private final ArrayList<MediaExtractorTrack> tracks;
    private boolean tracksEnded;
    private int upstreamFormatsCount;

    public final class ExtractorOutputImpl implements androidx.media3.extractor.b0 {
        private ExtractorOutputImpl() {
        }

        @Override // androidx.media3.extractor.b0
        public void endTracks() {
            MediaExtractorCompat.this.tracksEnded = true;
        }

        @Override // androidx.media3.extractor.b0
        public void seekMap(androidx.media3.extractor.t0 t0Var) {
            MediaExtractorCompat.this.seekMap = t0Var;
        }

        @Override // androidx.media3.extractor.b0
        public z0 track(int i10, int i11) {
            MediaExtractorSampleQueue mediaExtractorSampleQueue = (MediaExtractorSampleQueue) MediaExtractorCompat.this.sampleQueues.get(i10);
            if (mediaExtractorSampleQueue != null) {
                return mediaExtractorSampleQueue;
            }
            if (MediaExtractorCompat.this.tracksEnded) {
                return new androidx.media3.extractor.v();
            }
            MediaExtractorCompat mediaExtractorCompat = MediaExtractorCompat.this;
            MediaExtractorSampleQueue mediaExtractorSampleQueue2 = mediaExtractorCompat.new MediaExtractorSampleQueue(mediaExtractorCompat.allocator, i10);
            MediaExtractorCompat.this.sampleQueues.put(i10, mediaExtractorSampleQueue2);
            return mediaExtractorSampleQueue2;
        }
    }

    public final class MediaExtractorSampleQueue extends SampleQueue {
        private int compatibilityTrackIndex;
        private int mainTrackIndex;
        public long trackDurationUs;
        public final int trackId;

        public MediaExtractorSampleQueue(Allocator allocator, int i10) {
            super(allocator, null, null);
            this.trackId = i10;
            this.trackDurationUs = -9223372036854775807L;
            this.mainTrackIndex = -1;
            this.compatibilityTrackIndex = -1;
        }

        private void queueSampleMetadata(long j10, int i10) {
            int i11 = ((1073741824 & i10) != 0 ? 2 : 0) | ((i10 & 1) != 0 ? 1 : 0);
            if (this.compatibilityTrackIndex != -1) {
                MediaExtractorCompat.this.sampleMetadataQueue.addLast(j10, i11, this.compatibilityTrackIndex);
            }
            MediaExtractorCompat.this.sampleMetadataQueue.addLast(j10, i11, this.mainTrackIndex);
        }

        @Override // androidx.media3.exoplayer.source.SampleQueue, androidx.media3.extractor.z0
        public void durationUs(long j10) {
            this.trackDurationUs = j10;
            super.durationUs(j10);
        }

        @Override // androidx.media3.exoplayer.source.SampleQueue
        public Format getAdjustedUpstreamFormat(Format format) {
            if (getUpstreamFormat() == null) {
                MediaExtractorCompat.this.onSampleQueueFormatInitialized(this, format);
            }
            return super.getAdjustedUpstreamFormat(format);
        }

        @Override // androidx.media3.exoplayer.source.SampleQueue, androidx.media3.extractor.z0
        public int sampleData(DataReader dataReader, int i10, boolean z10) throws IOException {
            return sampleData(dataReader, i10, z10, 0);
        }

        @Override // androidx.media3.exoplayer.source.SampleQueue, androidx.media3.extractor.z0
        public void sampleMetadata(long j10, int i10, int i11, int i12, @Nullable y0 y0Var) {
            int i13 = i10 & (-536870913);
            Assertions.checkState(this.mainTrackIndex != -1);
            int writeIndex = getWriteIndex();
            super.sampleMetadata(j10, i13, i11, i12, y0Var);
            if (getWriteIndex() == writeIndex + 1) {
                queueSampleMetadata(j10, i13);
            }
        }

        public void setCompatibilityTrackIndex(int i10) {
            this.compatibilityTrackIndex = i10;
        }

        public void setMainTrackIndex(int i10) {
            this.mainTrackIndex = i10;
        }

        public String toString() {
            return String.format("trackId: %s, mainTrackIndex: %s, compatibilityTrackIndex: %s", Integer.valueOf(this.trackId), Integer.valueOf(this.mainTrackIndex), Integer.valueOf(this.compatibilityTrackIndex));
        }

        @Override // androidx.media3.exoplayer.source.SampleQueue, androidx.media3.extractor.z0
        public void sampleData(ParsableByteArray parsableByteArray, int i10) {
            sampleData(parsableByteArray, i10, 0);
        }
    }

    public static final class MediaExtractorTrack {

        @Nullable
        public final String compatibilityTrackMimeType;
        public final boolean isCompatibilityTrack;
        public final MediaExtractorSampleQueue sampleQueue;

        /* JADX INFO: Access modifiers changed from: private */
        public Format getFormat(FormatHolder formatHolder, s1.f fVar) {
            formatHolder.clear();
            this.sampleQueue.read(formatHolder, fVar, 2, false);
            Format format = (Format) Assertions.checkNotNull(formatHolder.format);
            formatHolder.clear();
            return format;
        }

        public MediaFormat createDownstreamMediaFormat(FormatHolder formatHolder, s1.f fVar) {
            Format format = getFormat(formatHolder, fVar);
            MediaFormat mediaFormatCreateMediaFormatFromFormat = MediaFormatUtil.createMediaFormatFromFormat(format);
            if (this.compatibilityTrackMimeType != null) {
                if (Build.VERSION.SDK_INT >= 29) {
                    mediaFormatCreateMediaFormatFromFormat.removeKey("codecs-string");
                }
                mediaFormatCreateMediaFormatFromFormat.setString(IMediaFormat.KEY_MIME, this.compatibilityTrackMimeType);
            }
            Pair<Integer, Integer> codecProfileAndLevel = CodecSpecificDataUtil.getCodecProfileAndLevel(format);
            if (codecProfileAndLevel != null) {
                mediaFormatCreateMediaFormatFromFormat.setInteger("profile", ((Integer) codecProfileAndLevel.first).intValue());
                mediaFormatCreateMediaFormatFromFormat.setInteger("level", ((Integer) codecProfileAndLevel.second).intValue());
            }
            return mediaFormatCreateMediaFormatFromFormat;
        }

        public void discardFrontSample() {
            this.sampleQueue.skip(1);
            this.sampleQueue.discardToRead();
        }

        public int getIdOfBackingTrack() {
            return this.sampleQueue.trackId;
        }

        public String toString() {
            return String.format("MediaExtractorSampleQueue: %s, isCompatibilityTrack: %s, compatibilityTrackMimeType: %s", this.sampleQueue, Boolean.valueOf(this.isCompatibilityTrack), this.compatibilityTrackMimeType);
        }

        private MediaExtractorTrack(MediaExtractorSampleQueue mediaExtractorSampleQueue, boolean z10, @Nullable String str) {
            this.sampleQueue = mediaExtractorSampleQueue;
            this.isCompatibilityTrack = z10;
            this.compatibilityTrackMimeType = str;
        }
    }

    public static final class SampleMetadataQueue {
        private final ArrayDeque<SampleMetadata> sampleMetadataPool = new ArrayDeque<>();
        private final ArrayDeque<SampleMetadata> sampleMetadataQueue = new ArrayDeque<>();

        public static final class SampleMetadata {
            public int flags;
            public long timeUs;
            public int trackIndex;

            public SampleMetadata(long j10, int i10, int i11) {
                set(j10, i10, i11);
            }

            public void set(long j10, int i10, int i11) {
                this.timeUs = j10;
                this.flags = i10;
                this.trackIndex = i11;
            }
        }

        private SampleMetadata obtainSampleMetadata(long j10, int i10, int i11) {
            SampleMetadata sampleMetadata = this.sampleMetadataPool.isEmpty() ? new SampleMetadata(j10, i10, i11) : this.sampleMetadataPool.pop();
            sampleMetadata.set(j10, i10, i11);
            return sampleMetadata;
        }

        public void addLast(long j10, int i10, int i11) {
            this.sampleMetadataQueue.addLast(obtainSampleMetadata(j10, i10, i11));
        }

        public void clear() {
            Iterator<SampleMetadata> it = this.sampleMetadataQueue.iterator();
            while (it.hasNext()) {
                this.sampleMetadataPool.push(it.next());
            }
            this.sampleMetadataQueue.clear();
        }

        public boolean isEmpty() {
            return this.sampleMetadataQueue.isEmpty();
        }

        @Nullable
        public SampleMetadata peekFirst() {
            return this.sampleMetadataQueue.peekFirst();
        }

        public SampleMetadata removeFirst() {
            SampleMetadata sampleMetadataRemoveFirst = this.sampleMetadataQueue.removeFirst();
            this.sampleMetadataPool.push(sampleMetadataRemoveFirst);
            return sampleMetadataRemoveFirst;
        }
    }

    @Retention(RetentionPolicy.SOURCE)
    public @interface SeekMode {
    }

    public MediaExtractorCompat(Context context) {
        this(new androidx.media3.extractor.u(), new DefaultDataSource.Factory(context));
    }

    @EnsuresNonNullIf(expression = {"sampleMetadataQueue.peekFirst()"}, result = true)
    private boolean advanceToSampleOrEndOfInput() {
        int i10;
        try {
            maybeResolvePendingSeek();
            boolean z10 = false;
            while (true) {
                if (this.sampleMetadataQueue.isEmpty()) {
                    if (z10) {
                        return false;
                    }
                    try {
                        i10 = ((androidx.media3.extractor.y) Assertions.checkNotNull(this.currentExtractor)).read((androidx.media3.extractor.z) Assertions.checkNotNull(this.currentExtractorInput), this.positionHolder);
                    } catch (Exception | OutOfMemoryError e10) {
                        Log.w(TAG, "Treating exception as the end of input.", e10);
                    }
                    if (i10 == -1) {
                        z10 = true;
                    } else if (i10 == 1) {
                        this.currentExtractorInput = reopenCurrentDataSource(this.positionHolder.f3463a);
                    }
                } else {
                    if (this.selectedTrackIndices.contains(Integer.valueOf(((SampleMetadataQueue.SampleMetadata) Assertions.checkNotNull(this.sampleMetadataQueue.peekFirst())).trackIndex))) {
                        return true;
                    }
                    skipOneSample();
                }
            }
        } catch (IOException e11) {
            Log.w(TAG, "Treating exception as the end of input.", e11);
            return false;
        }
    }

    private DataSpec buildDataSpec(Uri uri, long j10) {
        DataSpec.Builder flags = new DataSpec.Builder().setUri(uri).setPosition(j10).setFlags(6);
        Map<String, String> map = this.httpRequestHeaders;
        if (map != null) {
            flags.setHttpRequestHeaders(map);
        }
        return flags.build();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ String lambda$selectExtractor$0(androidx.media3.extractor.y yVar) {
        return yVar.getUnderlyingImplementation().getClass().getSimpleName();
    }

    private void maybeResolvePendingSeek() throws IOException {
        androidx.media3.extractor.u0 u0Var = this.pendingSeek;
        if (u0Var == null) {
            return;
        }
        androidx.media3.extractor.u0 u0Var2 = (androidx.media3.extractor.u0) Assertions.checkNotNull(u0Var);
        ((androidx.media3.extractor.y) Assertions.checkNotNull(this.currentExtractor)).seek(u0Var2.f3478b, u0Var2.f3477a);
        this.currentExtractorInput = reopenCurrentDataSource(u0Var2.f3478b);
        this.pendingSeek = null;
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Multi-variable type inference failed */
    public void onSampleQueueFormatInitialized(MediaExtractorSampleQueue mediaExtractorSampleQueue, Format format) {
        boolean z10 = true;
        this.upstreamFormatsCount++;
        mediaExtractorSampleQueue.setMainTrackIndex(this.tracks.size());
        Object[] objArr = 0;
        this.tracks.add(new MediaExtractorTrack(mediaExtractorSampleQueue, false, null));
        String alternativeCodecMimeType = MediaCodecUtil.getAlternativeCodecMimeType(format);
        if (alternativeCodecMimeType != null) {
            mediaExtractorSampleQueue.setCompatibilityTrackIndex(this.tracks.size());
            this.tracks.add(new MediaExtractorTrack(mediaExtractorSampleQueue, z10, alternativeCodecMimeType));
        }
    }

    private void peekNextSelectedTrackSample(s1.f fVar) {
        MediaExtractorSampleQueue mediaExtractorSampleQueue = this.tracks.get(((SampleMetadataQueue.SampleMetadata) Assertions.checkNotNull(this.sampleMetadataQueue.peekFirst())).trackIndex).sampleQueue;
        int i10 = mediaExtractorSampleQueue.read(this.formatHolder, fVar, 1, false);
        if (i10 == -5) {
            i10 = mediaExtractorSampleQueue.read(this.formatHolder, fVar, 1, false);
        }
        this.formatHolder.clear();
        Assertions.checkState(i10 == -4);
    }

    private void populatePlatformCryptoInfoParameters(MediaCodec.CryptoInfo cryptoInfo) {
        MediaCodec.CryptoInfo cryptoInfo2 = ((s1.d) Assertions.checkNotNull(this.sampleHolderWithBufferReplacementEnabled.cryptoInfo)).f32643e;
        cryptoInfo.numSubSamples = cryptoInfo2.numSubSamples;
        cryptoInfo.numBytesOfClearData = cryptoInfo2.numBytesOfClearData;
        cryptoInfo.numBytesOfEncryptedData = cryptoInfo2.numBytesOfEncryptedData;
        cryptoInfo.key = cryptoInfo2.key;
        cryptoInfo.iv = cryptoInfo2.iv;
        cryptoInfo.mode = cryptoInfo2.mode;
    }

    /* JADX WARN: Multi-variable type inference failed */
    private void prepareDataSource(DataSource dataSource, DataSpec dataSpec) throws IOException {
        int i10;
        Assertions.checkState(!this.hasBeenPrepared);
        this.hasBeenPrepared = true;
        this.offsetInCurrentFile = dataSpec.position;
        this.currentDataSource = dataSource;
        androidx.media3.extractor.z rVar = new r(this.currentDataSource, 0L, dataSource.open(dataSpec));
        androidx.media3.extractor.y yVarSelectExtractor = selectExtractor(rVar);
        Throwable e10 = null;
        yVarSelectExtractor.init(new ExtractorOutputImpl());
        boolean z10 = true;
        while (z10) {
            try {
                i10 = yVarSelectExtractor.read(rVar, this.positionHolder);
            } catch (Exception | OutOfMemoryError e11) {
                e10 = e11;
                i10 = -1;
            }
            boolean z11 = !this.tracksEnded || this.upstreamFormatsCount < this.sampleQueues.size() || this.seekMap == null;
            if (e10 != null || (z11 && i10 == -1)) {
                release();
                throw ParserException.createForMalformedContainer(e10 != null ? "Exception encountered while parsing input media." : "Reached end of input before preparation completed.", e10);
            }
            if (i10 == 1) {
                rVar = reopenCurrentDataSource(this.positionHolder.f3463a);
            }
            z10 = z11;
        }
        this.currentExtractorInput = rVar;
        this.currentExtractor = yVarSelectExtractor;
    }

    private androidx.media3.extractor.z reopenCurrentDataSource(long j10) throws IOException {
        DataSource dataSource = (DataSource) Assertions.checkNotNull(this.currentDataSource);
        Uri uri = (Uri) Assertions.checkNotNull(dataSource.getUri());
        DataSourceUtil.closeQuietly(dataSource);
        long jOpen = dataSource.open(buildDataSpec(uri, this.offsetInCurrentFile + j10));
        if (jOpen != -1) {
            jOpen += j10;
        }
        return new r(dataSource, j10, jOpen);
    }

    private androidx.media3.extractor.y selectExtractor(androidx.media3.extractor.z zVar) throws IOException {
        androidx.media3.extractor.y yVar;
        androidx.media3.extractor.y[] yVarArrA = this.extractorsFactory.a();
        int length = yVarArrA.length;
        int i10 = 0;
        while (true) {
            if (i10 >= length) {
                yVar = null;
                break;
            }
            yVar = yVarArrA[i10];
            try {
                if (yVar.sniff(zVar)) {
                    zVar.j();
                    break;
                }
            } catch (EOFException unused) {
            } catch (Throwable th) {
                zVar.j();
                throw th;
            }
            zVar.j();
            i10++;
        }
        if (yVar != null) {
            return yVar;
        }
        throw new UnrecognizedInputFormatException("None of the available extractors (" + new com.google.common.base.f(", ").b(com.google.common.collect.z0.B(ImmutableList.r(yVarArrA), new q0(4))) + ") could read the stream.", (Uri) Assertions.checkNotNull(((DataSource) Assertions.checkNotNull(this.currentDataSource)).getUri()), ImmutableList.t());
    }

    private void skipOneSample() {
        MediaExtractorTrack mediaExtractorTrack = this.tracks.get(this.sampleMetadataQueue.removeFirst().trackIndex);
        if (mediaExtractorTrack.isCompatibilityTrack) {
            return;
        }
        mediaExtractorTrack.discardFrontSample();
    }

    public boolean advance() {
        if (!advanceToSampleOrEndOfInput()) {
            return false;
        }
        skipOneSample();
        return advanceToSampleOrEndOfInput();
    }

    @VisibleForTesting(otherwise = 5)
    public Allocator getAllocator() {
        return this.allocator;
    }

    public long getCachedDuration() {
        if (!advanceToSampleOrEndOfInput()) {
            return 0L;
        }
        long jMax = Long.MIN_VALUE;
        long jMax2 = Long.MIN_VALUE;
        for (int i10 = 0; i10 < this.tracks.size(); i10++) {
            MediaExtractorSampleQueue mediaExtractorSampleQueue = this.tracks.get(i10).sampleQueue;
            jMax2 = Math.max(jMax2, mediaExtractorSampleQueue.getLargestReadTimestampUs());
            jMax = Math.max(jMax, mediaExtractorSampleQueue.getLargestQueuedTimestampUs());
        }
        Assertions.checkState(jMax != Long.MIN_VALUE);
        if (jMax2 == jMax) {
            return 0L;
        }
        return (jMax - (jMax2 != Long.MIN_VALUE ? jMax2 : 0L)) + 10000;
    }

    @Nullable
    public DrmInitData getDrmInitData() {
        for (int i10 = 0; i10 < this.tracks.size(); i10++) {
            DrmInitData drmInitData = this.tracks.get(i10).getFormat(this.formatHolder, this.sampleHolderWithBufferReplacementDisabled).drmInitData;
            if (drmInitData != null) {
                return drmInitData;
            }
        }
        return null;
    }

    @RequiresApi(31)
    public LogSessionId getLogSessionId() {
        LogSessionId logSessionId = this.logSessionId;
        return logSessionId != null ? logSessionId : LogSessionId.LOG_SESSION_ID_NONE;
    }

    @RequiresApi(26)
    public PersistableBundle getMetrics() {
        String str;
        PersistableBundle persistableBundle = new PersistableBundle();
        androidx.media3.extractor.y yVar = this.currentExtractor;
        if (yVar != null) {
            persistableBundle.putString("android.media.mediaextractor.fmt", yVar.getUnderlyingImplementation().getClass().getSimpleName());
        }
        if (!this.tracks.isEmpty() && (str = this.tracks.get(0).getFormat(this.formatHolder, this.sampleHolderWithBufferReplacementDisabled).containerMimeType) != null) {
            persistableBundle.putString("android.media.mediaextractor.mime", str);
        }
        persistableBundle.putInt("android.media.mediaextractor.ntrk", this.tracks.size());
        return persistableBundle;
    }

    @Nullable
    public Map<UUID, byte[]> getPsshInfo() {
        l2.v psshAtom;
        DrmInitData drmInitData = getDrmInitData();
        if (drmInitData == null) {
            return null;
        }
        HashMap map = new HashMap();
        for (int i10 = 0; i10 < drmInitData.schemeDataCount; i10++) {
            byte[] bArr = drmInitData.get(i10).data;
            if (bArr != null && (psshAtom = l2.w.parsePsshAtom(bArr)) != null) {
                map.put(psshAtom.f30090a, psshAtom.f30092c);
            }
        }
        if (map.isEmpty()) {
            return null;
        }
        return map;
    }

    public boolean getSampleCryptoInfo(MediaCodec.CryptoInfo cryptoInfo) {
        if (!advanceToSampleOrEndOfInput() || (this.sampleMetadataQueue.peekFirst().flags & 2) == 0) {
            return false;
        }
        peekNextSelectedTrackSample(this.sampleHolderWithBufferReplacementEnabled);
        populatePlatformCryptoInfoParameters(cryptoInfo);
        return true;
    }

    public int getSampleFlags() {
        if (advanceToSampleOrEndOfInput()) {
            return this.sampleMetadataQueue.peekFirst().flags;
        }
        return -1;
    }

    public long getSampleSize() {
        if (!advanceToSampleOrEndOfInput()) {
            return -1L;
        }
        peekNextSelectedTrackSample(this.sampleHolderWithBufferReplacementEnabled);
        ByteBuffer byteBuffer = (ByteBuffer) Assertions.checkNotNull(this.sampleHolderWithBufferReplacementEnabled.data);
        int iPosition = byteBuffer.position();
        byteBuffer.position(0);
        return iPosition;
    }

    public long getSampleTime() {
        if (advanceToSampleOrEndOfInput()) {
            return this.sampleMetadataQueue.peekFirst().timeUs;
        }
        return -1L;
    }

    public int getSampleTrackIndex() {
        if (advanceToSampleOrEndOfInput()) {
            return this.sampleMetadataQueue.peekFirst().trackIndex;
        }
        return -1;
    }

    public int getTrackCount() {
        return this.tracks.size();
    }

    public MediaFormat getTrackFormat(int i10) {
        MediaExtractorTrack mediaExtractorTrack = this.tracks.get(i10);
        MediaFormat mediaFormatCreateDownstreamMediaFormat = mediaExtractorTrack.createDownstreamMediaFormat(this.formatHolder, this.sampleHolderWithBufferReplacementDisabled);
        long j10 = mediaExtractorTrack.sampleQueue.trackDurationUs;
        if (j10 != -9223372036854775807L) {
            mediaFormatCreateDownstreamMediaFormat.setLong("durationUs", j10);
        } else {
            androidx.media3.extractor.t0 t0Var = this.seekMap;
            if (t0Var != null && t0Var.getDurationUs() != -9223372036854775807L) {
                mediaFormatCreateDownstreamMediaFormat.setLong("durationUs", this.seekMap.getDurationUs());
            }
        }
        return mediaFormatCreateDownstreamMediaFormat;
    }

    public boolean hasCacheReachedEndOfStream() {
        return getCachedDuration() == 0;
    }

    public int readSampleData(ByteBuffer byteBuffer, int i10) {
        if (!advanceToSampleOrEndOfInput()) {
            return -1;
        }
        byteBuffer.position(i10);
        byteBuffer.limit(byteBuffer.capacity());
        s1.f fVar = this.sampleHolderWithBufferReplacementDisabled;
        fVar.data = byteBuffer;
        peekNextSelectedTrackSample(fVar);
        byteBuffer.flip();
        byteBuffer.position(i10);
        this.sampleHolderWithBufferReplacementDisabled.data = null;
        return byteBuffer.remaining();
    }

    public void release() {
        for (int i10 = 0; i10 < this.sampleQueues.size(); i10++) {
            this.sampleQueues.valueAt(i10).release();
        }
        this.sampleQueues.clear();
        androidx.media3.extractor.y yVar = this.currentExtractor;
        if (yVar != null) {
            yVar.release();
            this.currentExtractor = null;
        }
        this.currentExtractorInput = null;
        this.pendingSeek = null;
        DataSourceUtil.closeQuietly(this.currentDataSource);
        this.currentDataSource = null;
    }

    /* JADX WARN: Removed duplicated region for block: B:10:0x0037  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public void seekTo(long j10, int i10) {
        androidx.media3.extractor.s0 s0VarD;
        androidx.media3.extractor.u0 u0Var;
        if (this.seekMap == null) {
            return;
        }
        if (this.selectedTrackIndices.size() == 1) {
            androidx.media3.extractor.y yVar = this.currentExtractor;
            s0VarD = yVar instanceof l2.u ? ((l2.u) yVar).d(this.tracks.get(this.selectedTrackIndices.iterator().next().intValue()).getIdOfBackingTrack(), j10) : this.seekMap.getSeekPoints(j10);
        }
        if (i10 == 0) {
            u0Var = s0VarD.f3464a;
        } else if (i10 == 1) {
            u0Var = s0VarD.f3465b;
        } else {
            if (i10 != 2) {
                throw new IllegalArgumentException();
            }
            long jAbs = Math.abs(j10 - s0VarD.f3465b.f3477a);
            u0Var = s0VarD.f3464a;
            if (jAbs < Math.abs(j10 - u0Var.f3477a)) {
                u0Var = s0VarD.f3465b;
            }
        }
        this.sampleMetadataQueue.clear();
        for (int i11 = 0; i11 < this.sampleQueues.size(); i11++) {
            this.sampleQueues.valueAt(i11).reset();
        }
        this.pendingSeek = u0Var;
    }

    public void selectTrack(int i10) {
        this.selectedTrackIndices.add(Integer.valueOf(i10));
    }

    public void setDataSource(Uri uri, long j10) throws IOException {
        prepareDataSource(this.dataSourceFactory.createDataSource(), buildDataSpec(uri, j10));
    }

    @RequiresApi(31)
    public void setLogSessionId(LogSessionId logSessionId) {
        if (logSessionId.equals(LogSessionId.LOG_SESSION_ID_NONE)) {
            return;
        }
        this.logSessionId = logSessionId;
    }

    public void unselectTrack(int i10) {
        this.selectedTrackIndices.remove(Integer.valueOf(i10));
    }

    public MediaExtractorCompat(androidx.media3.extractor.e0 e0Var, DataSource.Factory factory) {
        this.extractorsFactory = e0Var;
        this.dataSourceFactory = factory;
        this.positionHolder = new androidx.media3.extractor.r0();
        this.allocator = new DefaultAllocator(true, C.DEFAULT_BUFFER_SEGMENT_SIZE);
        this.tracks = new ArrayList<>();
        this.sampleQueues = new SparseArray<>();
        this.sampleMetadataQueue = new SampleMetadataQueue();
        this.formatHolder = new FormatHolder();
        this.sampleHolderWithBufferReplacementDisabled = s1.f.newNoDataInstance();
        this.sampleHolderWithBufferReplacementEnabled = new s1.f(2);
        this.selectedTrackIndices = new HashSet();
    }

    public void setDataSource(AssetFileDescriptor assetFileDescriptor) throws IOException {
        if (assetFileDescriptor.getDeclaredLength() == -1) {
            setDataSource(assetFileDescriptor.getFileDescriptor());
        } else {
            setDataSource(assetFileDescriptor.getFileDescriptor(), assetFileDescriptor.getStartOffset(), assetFileDescriptor.getDeclaredLength());
        }
    }

    public void setDataSource(FileDescriptor fileDescriptor) throws IOException {
        setDataSource(fileDescriptor, 0L, -1L);
    }

    public void setDataSource(FileDescriptor fileDescriptor, long j10, long j11) throws IOException {
        prepareDataSource(new FileDescriptorDataSource(fileDescriptor, j10, j11), buildDataSpec(Uri.EMPTY, 0L));
    }

    public void setDataSource(Context context, Uri uri, @Nullable Map<String, String> map) throws IOException {
        AssetFileDescriptor assetFileDescriptorOpenAssetFileDescriptor;
        if (Util.isLocalFileUri(uri)) {
            setDataSource((String) Assertions.checkNotNull(uri.getPath()));
            return;
        }
        try {
            assetFileDescriptorOpenAssetFileDescriptor = context.getContentResolver().openAssetFileDescriptor(uri, "r");
        } catch (FileNotFoundException | SecurityException unused) {
        }
        if (assetFileDescriptorOpenAssetFileDescriptor != null) {
            try {
                setDataSource(assetFileDescriptorOpenAssetFileDescriptor);
                assetFileDescriptorOpenAssetFileDescriptor.close();
                return;
            } catch (Throwable th) {
                try {
                    assetFileDescriptorOpenAssetFileDescriptor.close();
                } catch (Throwable th2) {
                    th.addSuppressed(th2);
                }
                throw th;
            }
        }
        if (assetFileDescriptorOpenAssetFileDescriptor != null) {
            assetFileDescriptorOpenAssetFileDescriptor.close();
        }
        setDataSource(uri.toString(), map);
    }

    public void setDataSource(String str) throws IOException {
        setDataSource(str, (Map<String, String>) null);
    }

    public void setDataSource(String str, @Nullable Map<String, String> map) throws IOException {
        this.httpRequestHeaders = map;
        prepareDataSource(this.dataSourceFactory.createDataSource(), buildDataSpec(Uri.parse(str), 0L));
    }

    @RequiresApi(23)
    public void setDataSource(MediaDataSource mediaDataSource) throws IOException {
        prepareDataSource(new MediaDataSourceAdapter(mediaDataSource, false), buildDataSpec(Uri.EMPTY, 0L));
    }
}