package androidx.media3.exoplayer.source; import android.net.Uri; import android.os.Handler; import androidx.annotation.Nullable; import androidx.media3.common.DataReader; import androidx.media3.common.Format; import androidx.media3.common.Metadata; import androidx.media3.common.MimeTypes; import androidx.media3.common.ParserException; import androidx.media3.common.TrackGroup; import androidx.media3.common.util.Assertions; import androidx.media3.common.util.ConditionVariable; import androidx.media3.common.util.Log; import androidx.media3.common.util.ParsableByteArray; 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.StatsDataSource; import androidx.media3.exoplayer.FormatHolder; import androidx.media3.exoplayer.LoadingInfo; import androidx.media3.exoplayer.SeekParameters; import androidx.media3.exoplayer.drm.DrmSessionEventListener; import androidx.media3.exoplayer.drm.DrmSessionManager; import androidx.media3.exoplayer.source.IcyDataSource; import androidx.media3.exoplayer.source.MediaPeriod; import androidx.media3.exoplayer.source.MediaSourceEventListener; import androidx.media3.exoplayer.source.SampleQueue; import androidx.media3.exoplayer.trackselection.ExoTrackSelection; import androidx.media3.exoplayer.upstream.Allocator; import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy; import androidx.media3.exoplayer.upstream.Loader; import androidx.media3.exoplayer.util.ReleasableExecutor; import androidx.media3.extractor.b0; import androidx.media3.extractor.i0; import androidx.media3.extractor.l0; import androidx.media3.extractor.p0; import androidx.media3.extractor.r0; import androidx.media3.extractor.s0; import androidx.media3.extractor.t0; import androidx.media3.extractor.v; import androidx.media3.extractor.z0; import java.io.IOException; import java.io.InterruptedIOException; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.Map; import org.checkerframework.checker.nullness.qual.EnsuresNonNull; /* JADX INFO: loaded from: classes.dex */ final class ProgressiveMediaPeriod implements MediaPeriod, b0, Loader.Callback, Loader.ReleaseCallback, SampleQueue.UpstreamFormatChangedListener { private static final long DEFAULT_LAST_SAMPLE_DURATION_US = 10000; private static final String TAG = "ProgressiveMediaPeriod"; private final Allocator allocator; @Nullable private MediaPeriod.Callback callback; private final long continueLoadingCheckIntervalBytes; @Nullable private final String customCacheKey; private final DataSource dataSource; private int dataType; private final DrmSessionEventListener.EventDispatcher drmEventDispatcher; private final DrmSessionManager drmSessionManager; private long durationUs; private int enabledTrackCount; private int extractedSamplesCountAtStartOfLoad; private final Handler handler; private boolean haveAudioVideoTracks; @Nullable private e2.b icyHeaders; private boolean isLengthKnown; private boolean isLive; private boolean isSingleSample; private long lastSeekPositionUs; private final Listener listener; private final ConditionVariable loadCondition; private final LoadErrorHandlingPolicy loadErrorHandlingPolicy; private final Loader loader; private boolean loadingFinished; private final Runnable maybeFinishPrepareRunnable; private final MediaSourceEventListener.EventDispatcher mediaSourceEventDispatcher; private boolean notifyDiscontinuity; private final Runnable onContinueLoadingRequestedRunnable; private boolean pendingDeferredRetry; private boolean pendingInitialDiscontinuity; private long pendingResetPositionUs; private boolean prepared; private final ProgressiveMediaExtractor progressiveMediaExtractor; private boolean released; private TrackId[] sampleQueueTrackIds; private SampleQueue[] sampleQueues; private boolean sampleQueuesBuilt; private t0 seekMap; private boolean seenFirstTrackSelection; private final long singleSampleDurationUs; @Nullable private final Format singleTrackFormat; private final int singleTrackId; private TrackState trackState; private final Uri uri; private static final Map ICY_METADATA_HEADERS = createIcyMetadataHeaders(); private static final Format ICY_FORMAT = new Format.Builder().setId("icy").setSampleMimeType(MimeTypes.APPLICATION_ICY).build(); public final class ExtractingLoadable implements Loader.Loadable, IcyDataSource.Listener { private final StatsDataSource dataSource; private final b0 extractorOutput; @Nullable private z0 icyTrackOutput; private volatile boolean loadCanceled; private final ConditionVariable loadCondition; private final ProgressiveMediaExtractor progressiveMediaExtractor; private long seekTimeUs; private boolean seenIcyMetadata; private final Uri uri; private final r0 positionHolder = new r0(); private boolean pendingExtractorSeek = true; private final long loadTaskId = LoadEventInfo.getNewId(); private DataSpec dataSpec = buildDataSpec(0); public ExtractingLoadable(Uri uri, DataSource dataSource, ProgressiveMediaExtractor progressiveMediaExtractor, b0 b0Var, ConditionVariable conditionVariable) { this.uri = uri; this.dataSource = new StatsDataSource(dataSource); this.progressiveMediaExtractor = progressiveMediaExtractor; this.extractorOutput = b0Var; this.loadCondition = conditionVariable; } private DataSpec buildDataSpec(long j10) { return new DataSpec.Builder().setUri(this.uri).setPosition(j10).setKey(ProgressiveMediaPeriod.this.customCacheKey).setFlags(6).setHttpRequestHeaders(ProgressiveMediaPeriod.ICY_METADATA_HEADERS).build(); } /* JADX INFO: Access modifiers changed from: private */ public void setLoadPosition(long j10, long j11) { this.positionHolder.f3463a = j10; this.seekTimeUs = j11; this.pendingExtractorSeek = true; this.seenIcyMetadata = false; } @Override // androidx.media3.exoplayer.upstream.Loader.Loadable public void cancelLoad() { this.loadCanceled = true; } @Override // androidx.media3.exoplayer.upstream.Loader.Loadable public void load() throws IOException { int i10 = 0; while (i10 == 0 && !this.loadCanceled) { try { long j10 = this.positionHolder.f3463a; DataSpec dataSpecBuildDataSpec = buildDataSpec(j10); this.dataSpec = dataSpecBuildDataSpec; long jOpen = this.dataSource.open(dataSpecBuildDataSpec); if (this.loadCanceled) { if (i10 != 1 && this.progressiveMediaExtractor.getCurrentInputPosition() != -1) { this.positionHolder.f3463a = this.progressiveMediaExtractor.getCurrentInputPosition(); } DataSourceUtil.closeQuietly(this.dataSource); return; } if (jOpen != -1) { jOpen += j10; ProgressiveMediaPeriod.this.onLengthKnown(); } long j11 = jOpen; ProgressiveMediaPeriod.this.icyHeaders = e2.b.parse(this.dataSource.getResponseHeaders()); DataReader icyDataSource = this.dataSource; if (ProgressiveMediaPeriod.this.icyHeaders != null && ProgressiveMediaPeriod.this.icyHeaders.f25449c != -1) { icyDataSource = new IcyDataSource(this.dataSource, ProgressiveMediaPeriod.this.icyHeaders.f25449c, this); z0 z0VarIcyTrack = ProgressiveMediaPeriod.this.icyTrack(); this.icyTrackOutput = z0VarIcyTrack; z0VarIcyTrack.format(ProgressiveMediaPeriod.ICY_FORMAT); } long currentInputPosition = j10; this.progressiveMediaExtractor.init(icyDataSource, this.uri, this.dataSource.getResponseHeaders(), j10, j11, this.extractorOutput); if (ProgressiveMediaPeriod.this.icyHeaders != null) { this.progressiveMediaExtractor.disableSeekingOnMp3Streams(); } if (this.pendingExtractorSeek) { this.progressiveMediaExtractor.seek(currentInputPosition, this.seekTimeUs); this.pendingExtractorSeek = false; } while (true) { long j12 = currentInputPosition; while (i10 == 0 && !this.loadCanceled) { try { this.loadCondition.block(); i10 = this.progressiveMediaExtractor.read(this.positionHolder); currentInputPosition = this.progressiveMediaExtractor.getCurrentInputPosition(); if (currentInputPosition > ProgressiveMediaPeriod.this.continueLoadingCheckIntervalBytes + j12) { break; } } catch (InterruptedException unused) { throw new InterruptedIOException(); } } this.loadCondition.close(); ProgressiveMediaPeriod.this.handler.post(ProgressiveMediaPeriod.this.onContinueLoadingRequestedRunnable); } if (i10 == 1) { i10 = 0; } else if (this.progressiveMediaExtractor.getCurrentInputPosition() != -1) { this.positionHolder.f3463a = this.progressiveMediaExtractor.getCurrentInputPosition(); } DataSourceUtil.closeQuietly(this.dataSource); } catch (Throwable th) { if (i10 != 1 && this.progressiveMediaExtractor.getCurrentInputPosition() != -1) { this.positionHolder.f3463a = this.progressiveMediaExtractor.getCurrentInputPosition(); } DataSourceUtil.closeQuietly(this.dataSource); throw th; } } } @Override // androidx.media3.exoplayer.source.IcyDataSource.Listener public void onIcyMetadata(ParsableByteArray parsableByteArray) { long jMax = !this.seenIcyMetadata ? this.seekTimeUs : Math.max(ProgressiveMediaPeriod.this.getLargestQueuedTimestampUs(true), this.seekTimeUs); int iBytesLeft = parsableByteArray.bytesLeft(); z0 z0Var = (z0) Assertions.checkNotNull(this.icyTrackOutput); z0Var.sampleData(parsableByteArray, iBytesLeft); z0Var.sampleMetadata(jMax, 1, iBytesLeft, 0, null); this.seenIcyMetadata = true; } } public interface Listener { void onSourceInfoRefreshed(long j10, t0 t0Var, boolean z10); } public final class SampleStreamImpl implements SampleStream { private final int track; public SampleStreamImpl(int i10) { this.track = i10; } @Override // androidx.media3.exoplayer.source.SampleStream public boolean isReady() { return ProgressiveMediaPeriod.this.isReady(this.track); } @Override // androidx.media3.exoplayer.source.SampleStream public void maybeThrowError() throws IOException { ProgressiveMediaPeriod.this.maybeThrowError(this.track); } @Override // androidx.media3.exoplayer.source.SampleStream public int readData(FormatHolder formatHolder, s1.f fVar, int i10) { return ProgressiveMediaPeriod.this.readData(this.track, formatHolder, fVar, i10); } @Override // androidx.media3.exoplayer.source.SampleStream public int skipData(long j10) { return ProgressiveMediaPeriod.this.skipData(this.track, j10); } } public static final class TrackId { /* JADX INFO: renamed from: id, reason: collision with root package name */ public final int f3150id; public final boolean isIcyTrack; public TrackId(int i10, boolean z10) { this.f3150id = i10; this.isIcyTrack = z10; } public boolean equals(@Nullable Object obj) { if (this == obj) { return true; } if (obj == null || TrackId.class != obj.getClass()) { return false; } TrackId trackId = (TrackId) obj; return this.f3150id == trackId.f3150id && this.isIcyTrack == trackId.isIcyTrack; } public int hashCode() { return (this.f3150id * 31) + (this.isIcyTrack ? 1 : 0); } } public static final class TrackState { public final boolean[] trackEnabledStates; public final boolean[] trackIsAudioVideoFlags; public final boolean[] trackNotifiedDownstreamFormats; public final TrackGroupArray tracks; public TrackState(TrackGroupArray trackGroupArray, boolean[] zArr) { this.tracks = trackGroupArray; this.trackIsAudioVideoFlags = zArr; int i10 = trackGroupArray.length; this.trackEnabledStates = new boolean[i10]; this.trackNotifiedDownstreamFormats = new boolean[i10]; } } public ProgressiveMediaPeriod(Uri uri, DataSource dataSource, ProgressiveMediaExtractor progressiveMediaExtractor, DrmSessionManager drmSessionManager, DrmSessionEventListener.EventDispatcher eventDispatcher, LoadErrorHandlingPolicy loadErrorHandlingPolicy, MediaSourceEventListener.EventDispatcher eventDispatcher2, Listener listener, Allocator allocator, @Nullable String str, int i10, int i11, @Nullable Format format, long j10, @Nullable ReleasableExecutor releasableExecutor) { this.uri = uri; this.dataSource = dataSource; this.drmSessionManager = drmSessionManager; this.drmEventDispatcher = eventDispatcher; this.loadErrorHandlingPolicy = loadErrorHandlingPolicy; this.mediaSourceEventDispatcher = eventDispatcher2; this.listener = listener; this.allocator = allocator; this.customCacheKey = str; this.continueLoadingCheckIntervalBytes = i10; this.singleTrackId = i11; this.singleTrackFormat = format; this.loader = releasableExecutor != null ? new Loader(releasableExecutor) : new Loader(TAG); this.progressiveMediaExtractor = progressiveMediaExtractor; this.singleSampleDurationUs = j10; this.loadCondition = new ConditionVariable(); this.maybeFinishPrepareRunnable = new i(this, 0); this.onContinueLoadingRequestedRunnable = new i(this, 1); this.handler = Util.createHandlerForCurrentLooper(); this.sampleQueueTrackIds = new TrackId[0]; this.sampleQueues = new SampleQueue[0]; this.pendingResetPositionUs = -9223372036854775807L; this.dataType = 1; } @EnsuresNonNull({"trackState", "seekMap"}) private void assertPrepared() { Assertions.checkState(this.prepared); Assertions.checkNotNull(this.trackState); Assertions.checkNotNull(this.seekMap); } private boolean configureRetry(ExtractingLoadable extractingLoadable, int i10) { t0 t0Var; if (this.isLengthKnown || !((t0Var = this.seekMap) == null || t0Var.getDurationUs() == -9223372036854775807L)) { this.extractedSamplesCountAtStartOfLoad = i10; return true; } if (this.prepared && !suppressRead()) { this.pendingDeferredRetry = true; return false; } this.notifyDiscontinuity = this.prepared; this.lastSeekPositionUs = 0L; this.extractedSamplesCountAtStartOfLoad = 0; for (SampleQueue sampleQueue : this.sampleQueues) { sampleQueue.reset(); } extractingLoadable.setLoadPosition(0L, 0L); return true; } private static Map createIcyMetadataHeaders() { HashMap map = new HashMap(); map.put("Icy-MetaData", "1"); return Collections.unmodifiableMap(map); } private int getExtractedSamplesCount() { int writeIndex = 0; for (SampleQueue sampleQueue : this.sampleQueues) { writeIndex += sampleQueue.getWriteIndex(); } return writeIndex; } /* JADX INFO: Access modifiers changed from: private */ public long getLargestQueuedTimestampUs(boolean z10) { long jMax = Long.MIN_VALUE; for (int i10 = 0; i10 < this.sampleQueues.length; i10++) { if (z10 || ((TrackState) Assertions.checkNotNull(this.trackState)).trackEnabledStates[i10]) { jMax = Math.max(jMax, this.sampleQueues[i10].getLargestQueuedTimestampUs()); } } return jMax; } private boolean isPendingReset() { return this.pendingResetPositionUs != -9223372036854775807L; } /* JADX INFO: Access modifiers changed from: private */ public /* synthetic */ void lambda$new$0() { if (this.released) { return; } ((MediaPeriod.Callback) Assertions.checkNotNull(this.callback)).onContinueLoadingRequested(this); } /* JADX INFO: Access modifiers changed from: private */ public /* synthetic */ void lambda$onLengthKnown$2() { this.isLengthKnown = true; } /* JADX INFO: Access modifiers changed from: private */ public void maybeFinishPrepare() { int i10; if (this.released || this.prepared || !this.sampleQueuesBuilt || this.seekMap == null) { return; } for (SampleQueue sampleQueue : this.sampleQueues) { if (sampleQueue.getUpstreamFormat() == null) { return; } } this.loadCondition.close(); int length = this.sampleQueues.length; TrackGroup[] trackGroupArr = new TrackGroup[length]; boolean[] zArr = new boolean[length]; for (int i11 = 0; i11 < length; i11++) { Format formatBuild = (Format) Assertions.checkNotNull(this.sampleQueues[i11].getUpstreamFormat()); String str = formatBuild.sampleMimeType; boolean zIsAudio = MimeTypes.isAudio(str); boolean z10 = zIsAudio || MimeTypes.isVideo(str); zArr[i11] = z10; this.haveAudioVideoTracks = z10 | this.haveAudioVideoTracks; this.isSingleSample = this.singleSampleDurationUs != -9223372036854775807L && length == 1 && MimeTypes.isImage(str); e2.b bVar = this.icyHeaders; if (bVar != null) { if (zIsAudio || this.sampleQueueTrackIds[i11].isIcyTrack) { Metadata metadata = formatBuild.metadata; formatBuild = formatBuild.buildUpon().setMetadata(metadata == null ? new Metadata(bVar) : metadata.copyWithAppendedEntries(bVar)).build(); } if (zIsAudio && formatBuild.averageBitrate == -1 && formatBuild.peakBitrate == -1 && (i10 = bVar.f25447a) != -1) { formatBuild = formatBuild.buildUpon().setAverageBitrate(i10).build(); } } Format formatCopyWithCryptoType = formatBuild.copyWithCryptoType(this.drmSessionManager.getCryptoType(formatBuild)); trackGroupArr[i11] = new TrackGroup(Integer.toString(i11), formatCopyWithCryptoType); this.pendingInitialDiscontinuity = formatCopyWithCryptoType.hasPrerollSamples | this.pendingInitialDiscontinuity; } this.trackState = new TrackState(new TrackGroupArray(trackGroupArr), zArr); if (this.isSingleSample && this.durationUs == -9223372036854775807L) { this.durationUs = this.singleSampleDurationUs; this.seekMap = new l0(this.seekMap) { // from class: androidx.media3.exoplayer.source.ProgressiveMediaPeriod.1 @Override // androidx.media3.extractor.l0, androidx.media3.extractor.t0 public long getDurationUs() { return ProgressiveMediaPeriod.this.durationUs; } }; } this.listener.onSourceInfoRefreshed(this.durationUs, this.seekMap, this.isLive); this.prepared = true; ((MediaPeriod.Callback) Assertions.checkNotNull(this.callback)).onPrepared(this); } private void maybeNotifyDownstreamFormat(int i10) { assertPrepared(); TrackState trackState = this.trackState; boolean[] zArr = trackState.trackNotifiedDownstreamFormats; if (zArr[i10]) { return; } Format format = trackState.tracks.get(i10).getFormat(0); this.mediaSourceEventDispatcher.downstreamFormatChanged(MimeTypes.getTrackType(format.sampleMimeType), format, 0, null, this.lastSeekPositionUs); zArr[i10] = true; } private void maybeStartDeferredRetry(int i10) { assertPrepared(); if (this.pendingDeferredRetry) { if (!this.haveAudioVideoTracks || this.trackState.trackIsAudioVideoFlags[i10]) { if (this.sampleQueues[i10].isReady(false)) { return; } this.pendingResetPositionUs = 0L; this.pendingDeferredRetry = false; this.notifyDiscontinuity = true; this.lastSeekPositionUs = 0L; this.extractedSamplesCountAtStartOfLoad = 0; for (SampleQueue sampleQueue : this.sampleQueues) { sampleQueue.reset(); } ((MediaPeriod.Callback) Assertions.checkNotNull(this.callback)).onContinueLoadingRequested(this); } } } /* JADX INFO: Access modifiers changed from: private */ public void onLengthKnown() { this.handler.post(new i(this, 2)); } private z0 prepareTrackOutput(TrackId trackId) { int length = this.sampleQueues.length; for (int i10 = 0; i10 < length; i10++) { if (trackId.equals(this.sampleQueueTrackIds[i10])) { return this.sampleQueues[i10]; } } if (this.sampleQueuesBuilt) { Log.w(TAG, "Extractor added new track (id=" + trackId.f3150id + ") after finishing tracks."); return new v(); } SampleQueue sampleQueueCreateWithDrm = SampleQueue.createWithDrm(this.allocator, this.drmSessionManager, this.drmEventDispatcher); sampleQueueCreateWithDrm.setUpstreamFormatChangeListener(this); int i11 = length + 1; TrackId[] trackIdArr = (TrackId[]) Arrays.copyOf(this.sampleQueueTrackIds, i11); trackIdArr[length] = trackId; this.sampleQueueTrackIds = (TrackId[]) Util.castNonNullTypeArray(trackIdArr); SampleQueue[] sampleQueueArr = (SampleQueue[]) Arrays.copyOf(this.sampleQueues, i11); sampleQueueArr[length] = sampleQueueCreateWithDrm; this.sampleQueues = (SampleQueue[]) Util.castNonNullTypeArray(sampleQueueArr); return sampleQueueCreateWithDrm; } private boolean seekInsideBufferUs(boolean[] zArr, long j10, boolean z10) { int length = this.sampleQueues.length; for (int i10 = 0; i10 < length; i10++) { SampleQueue sampleQueue = this.sampleQueues[i10]; if (sampleQueue.getReadIndex() != 0 || !z10) { if (!(this.isSingleSample ? sampleQueue.seekTo(sampleQueue.getFirstIndex()) : sampleQueue.seekTo(j10, this.loadingFinished)) && (zArr[i10] || !this.haveAudioVideoTracks)) { return false; } } } return true; } /* JADX INFO: Access modifiers changed from: private */ /* JADX INFO: renamed from: setSeekMap, reason: merged with bridge method [inline-methods] */ public void lambda$seekMap$1(t0 t0Var) { this.seekMap = this.icyHeaders == null ? t0Var : new i0(-9223372036854775807L); this.durationUs = t0Var.getDurationUs(); boolean z10 = !this.isLengthKnown && t0Var.getDurationUs() == -9223372036854775807L; this.isLive = z10; this.dataType = z10 ? 7 : 1; if (this.prepared) { this.listener.onSourceInfoRefreshed(this.durationUs, t0Var, z10); } else { maybeFinishPrepare(); } } private void startLoading() { ExtractingLoadable extractingLoadable = new ExtractingLoadable(this.uri, this.dataSource, this.progressiveMediaExtractor, this, this.loadCondition); if (this.prepared) { Assertions.checkState(isPendingReset()); long j10 = this.durationUs; if (j10 != -9223372036854775807L && this.pendingResetPositionUs > j10) { this.loadingFinished = true; this.pendingResetPositionUs = -9223372036854775807L; return; } extractingLoadable.setLoadPosition(((t0) Assertions.checkNotNull(this.seekMap)).getSeekPoints(this.pendingResetPositionUs).f3464a.f3478b, this.pendingResetPositionUs); for (SampleQueue sampleQueue : this.sampleQueues) { sampleQueue.setStartTimeUs(this.pendingResetPositionUs); } this.pendingResetPositionUs = -9223372036854775807L; } this.extractedSamplesCountAtStartOfLoad = getExtractedSamplesCount(); this.loader.startLoading(extractingLoadable, this, this.loadErrorHandlingPolicy.getMinimumLoadableRetryCount(this.dataType)); } private boolean suppressRead() { return this.notifyDiscontinuity || isPendingReset(); } @Override // androidx.media3.exoplayer.source.MediaPeriod, androidx.media3.exoplayer.source.SequenceableLoader public boolean continueLoading(LoadingInfo loadingInfo) { if (this.loadingFinished || this.loader.hasFatalError() || this.pendingDeferredRetry) { return false; } if ((this.prepared || this.singleTrackFormat != null) && this.enabledTrackCount == 0) { return false; } boolean zOpen = this.loadCondition.open(); if (this.loader.isLoading()) { return zOpen; } startLoading(); return true; } @Override // androidx.media3.exoplayer.source.MediaPeriod public void discardBuffer(long j10, boolean z10) { if (this.isSingleSample) { return; } assertPrepared(); if (isPendingReset()) { return; } boolean[] zArr = this.trackState.trackEnabledStates; int length = this.sampleQueues.length; for (int i10 = 0; i10 < length; i10++) { this.sampleQueues[i10].discardTo(j10, z10, zArr[i10]); } } @Override // androidx.media3.extractor.b0 public void endTracks() { this.sampleQueuesBuilt = true; this.handler.post(this.maybeFinishPrepareRunnable); } @Override // androidx.media3.exoplayer.source.MediaPeriod public long getAdjustedSeekPositionUs(long j10, SeekParameters seekParameters) { assertPrepared(); if (!this.seekMap.isSeekable()) { return 0L; } s0 seekPoints = this.seekMap.getSeekPoints(j10); return seekParameters.resolveSeekPositionUs(j10, seekPoints.f3464a.f3477a, seekPoints.f3465b.f3477a); } @Override // androidx.media3.exoplayer.source.MediaPeriod, androidx.media3.exoplayer.source.SequenceableLoader public long getBufferedPositionUs() { long largestQueuedTimestampUs; assertPrepared(); if (this.loadingFinished || this.enabledTrackCount == 0) { return Long.MIN_VALUE; } if (isPendingReset()) { return this.pendingResetPositionUs; } if (this.haveAudioVideoTracks) { int length = this.sampleQueues.length; largestQueuedTimestampUs = Long.MAX_VALUE; for (int i10 = 0; i10 < length; i10++) { TrackState trackState = this.trackState; if (trackState.trackIsAudioVideoFlags[i10] && trackState.trackEnabledStates[i10] && !this.sampleQueues[i10].isLastSampleQueued()) { largestQueuedTimestampUs = Math.min(largestQueuedTimestampUs, this.sampleQueues[i10].getLargestQueuedTimestampUs()); } } } else { largestQueuedTimestampUs = Long.MAX_VALUE; } if (largestQueuedTimestampUs == Long.MAX_VALUE) { largestQueuedTimestampUs = getLargestQueuedTimestampUs(false); } return largestQueuedTimestampUs == Long.MIN_VALUE ? this.lastSeekPositionUs : largestQueuedTimestampUs; } @Override // androidx.media3.exoplayer.source.MediaPeriod, androidx.media3.exoplayer.source.SequenceableLoader public long getNextLoadPositionUs() { return getBufferedPositionUs(); } @Override // androidx.media3.exoplayer.source.MediaPeriod public TrackGroupArray getTrackGroups() { assertPrepared(); return this.trackState.tracks; } public z0 icyTrack() { return prepareTrackOutput(new TrackId(0, true)); } @Override // androidx.media3.exoplayer.source.MediaPeriod, androidx.media3.exoplayer.source.SequenceableLoader public boolean isLoading() { return this.loader.isLoading() && this.loadCondition.isOpen(); } public boolean isReady(int i10) { return !suppressRead() && this.sampleQueues[i10].isReady(this.loadingFinished); } public void maybeThrowError(int i10) throws IOException { this.sampleQueues[i10].maybeThrowError(); maybeThrowError(); } @Override // androidx.media3.exoplayer.source.MediaPeriod public void maybeThrowPrepareError() throws IOException { maybeThrowError(); if (this.loadingFinished && !this.prepared) { throw ParserException.createForMalformedContainer("Loading finished before preparation is complete.", null); } } @Override // androidx.media3.exoplayer.upstream.Loader.ReleaseCallback public void onLoaderReleased() { for (SampleQueue sampleQueue : this.sampleQueues) { sampleQueue.release(); } this.progressiveMediaExtractor.release(); } @Override // androidx.media3.exoplayer.source.SampleQueue.UpstreamFormatChangedListener public void onUpstreamFormatChanged(Format format) { this.handler.post(this.maybeFinishPrepareRunnable); } @Override // androidx.media3.exoplayer.source.MediaPeriod public void prepare(MediaPeriod.Callback callback, long j10) { this.callback = callback; if (this.singleTrackFormat == null) { this.loadCondition.open(); startLoading(); } else { track(this.singleTrackId, 3).format(this.singleTrackFormat); lambda$seekMap$1(new p0(-9223372036854775807L, new long[]{0}, new long[]{0})); endTracks(); this.pendingResetPositionUs = j10; } } public int readData(int i10, FormatHolder formatHolder, s1.f fVar, int i11) { if (suppressRead()) { return -3; } maybeNotifyDownstreamFormat(i10); int i12 = this.sampleQueues[i10].read(formatHolder, fVar, i11, this.loadingFinished); if (i12 == -3) { maybeStartDeferredRetry(i10); } return i12; } @Override // androidx.media3.exoplayer.source.MediaPeriod public long readDiscontinuity() { if (this.pendingInitialDiscontinuity) { this.pendingInitialDiscontinuity = false; return this.lastSeekPositionUs; } if (!this.notifyDiscontinuity) { return -9223372036854775807L; } if (!this.loadingFinished && getExtractedSamplesCount() <= this.extractedSamplesCountAtStartOfLoad) { return -9223372036854775807L; } this.notifyDiscontinuity = false; return this.lastSeekPositionUs; } @Override // androidx.media3.exoplayer.source.MediaPeriod, androidx.media3.exoplayer.source.SequenceableLoader public void reevaluateBuffer(long j10) { } public void release() { if (this.prepared) { for (SampleQueue sampleQueue : this.sampleQueues) { sampleQueue.preRelease(); } } this.loader.release(this); this.handler.removeCallbacksAndMessages(null); this.callback = null; this.released = true; } @Override // androidx.media3.extractor.b0 public void seekMap(t0 t0Var) { this.handler.post(new j(this, t0Var, 0)); } @Override // androidx.media3.exoplayer.source.MediaPeriod public long seekToUs(long j10) { assertPrepared(); boolean[] zArr = this.trackState.trackIsAudioVideoFlags; if (!this.seekMap.isSeekable()) { j10 = 0; } int i10 = 0; this.notifyDiscontinuity = false; boolean z10 = this.lastSeekPositionUs == j10; this.lastSeekPositionUs = j10; if (isPendingReset()) { this.pendingResetPositionUs = j10; return j10; } if (this.dataType != 7 && ((this.loadingFinished || this.loader.isLoading()) && seekInsideBufferUs(zArr, j10, z10))) { return j10; } this.pendingDeferredRetry = false; this.pendingResetPositionUs = j10; this.loadingFinished = false; this.pendingInitialDiscontinuity = false; if (this.loader.isLoading()) { SampleQueue[] sampleQueueArr = this.sampleQueues; int length = sampleQueueArr.length; while (i10 < length) { sampleQueueArr[i10].discardToEnd(); i10++; } this.loader.cancelLoading(); } else { this.loader.clearFatalError(); SampleQueue[] sampleQueueArr2 = this.sampleQueues; int length2 = sampleQueueArr2.length; while (i10 < length2) { sampleQueueArr2[i10].reset(); i10++; } } return j10; } @Override // androidx.media3.exoplayer.source.MediaPeriod public long selectTracks(ExoTrackSelection[] exoTrackSelectionArr, boolean[] zArr, SampleStream[] sampleStreamArr, boolean[] zArr2, long j10) { ExoTrackSelection exoTrackSelection; assertPrepared(); TrackState trackState = this.trackState; TrackGroupArray trackGroupArray = trackState.tracks; boolean[] zArr3 = trackState.trackEnabledStates; int i10 = this.enabledTrackCount; int i11 = 0; for (int i12 = 0; i12 < exoTrackSelectionArr.length; i12++) { SampleStream sampleStream = sampleStreamArr[i12]; if (sampleStream != null && (exoTrackSelectionArr[i12] == null || !zArr[i12])) { int i13 = ((SampleStreamImpl) sampleStream).track; Assertions.checkState(zArr3[i13]); this.enabledTrackCount--; zArr3[i13] = false; sampleStreamArr[i12] = null; } } boolean z10 = !this.seenFirstTrackSelection ? j10 == 0 || this.isSingleSample : i10 != 0; for (int i14 = 0; i14 < exoTrackSelectionArr.length; i14++) { if (sampleStreamArr[i14] == null && (exoTrackSelection = exoTrackSelectionArr[i14]) != null) { Assertions.checkState(exoTrackSelection.length() == 1); Assertions.checkState(exoTrackSelection.getIndexInTrackGroup(0) == 0); int iIndexOf = trackGroupArray.indexOf(exoTrackSelection.getTrackGroup()); Assertions.checkState(!zArr3[iIndexOf]); this.enabledTrackCount++; zArr3[iIndexOf] = true; this.pendingInitialDiscontinuity = exoTrackSelection.getSelectedFormat().hasPrerollSamples | this.pendingInitialDiscontinuity; sampleStreamArr[i14] = new SampleStreamImpl(iIndexOf); zArr2[i14] = true; if (!z10) { SampleQueue sampleQueue = this.sampleQueues[iIndexOf]; z10 = (sampleQueue.getReadIndex() == 0 || sampleQueue.seekTo(j10, true)) ? false : true; } } } if (this.enabledTrackCount == 0) { this.pendingDeferredRetry = false; this.notifyDiscontinuity = false; this.pendingInitialDiscontinuity = false; if (this.loader.isLoading()) { SampleQueue[] sampleQueueArr = this.sampleQueues; int length = sampleQueueArr.length; while (i11 < length) { sampleQueueArr[i11].discardToEnd(); i11++; } this.loader.cancelLoading(); } else { this.loadingFinished = false; SampleQueue[] sampleQueueArr2 = this.sampleQueues; int length2 = sampleQueueArr2.length; while (i11 < length2) { sampleQueueArr2[i11].reset(); i11++; } } } else if (z10) { j10 = seekToUs(j10); while (i11 < sampleStreamArr.length) { if (sampleStreamArr[i11] != null) { zArr2[i11] = true; } i11++; } } this.seenFirstTrackSelection = true; return j10; } public int skipData(int i10, long j10) { if (suppressRead()) { return 0; } maybeNotifyDownstreamFormat(i10); SampleQueue sampleQueue = this.sampleQueues[i10]; int skipCount = sampleQueue.getSkipCount(j10, this.loadingFinished); sampleQueue.skip(skipCount); if (skipCount == 0) { maybeStartDeferredRetry(i10); } return skipCount; } @Override // androidx.media3.extractor.b0 public z0 track(int i10, int i11) { return prepareTrackOutput(new TrackId(i10, false)); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadCanceled(ExtractingLoadable extractingLoadable, long j10, long j11, boolean z10) { StatsDataSource statsDataSource = extractingLoadable.dataSource; LoadEventInfo loadEventInfo = new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, statsDataSource.getLastOpenedUri(), statsDataSource.getLastResponseHeaders(), j10, j11, statsDataSource.getBytesRead()); this.loadErrorHandlingPolicy.onLoadTaskConcluded(extractingLoadable.loadTaskId); this.mediaSourceEventDispatcher.loadCanceled(loadEventInfo, 1, -1, null, 0, null, extractingLoadable.seekTimeUs, this.durationUs); if (z10) { return; } for (SampleQueue sampleQueue : this.sampleQueues) { sampleQueue.reset(); } if (this.enabledTrackCount > 0) { ((MediaPeriod.Callback) Assertions.checkNotNull(this.callback)).onContinueLoadingRequested(this); } } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadCompleted(ExtractingLoadable extractingLoadable, long j10, long j11) { if (this.durationUs == -9223372036854775807L && this.seekMap != null) { long largestQueuedTimestampUs = getLargestQueuedTimestampUs(true); long j12 = largestQueuedTimestampUs == Long.MIN_VALUE ? 0L : largestQueuedTimestampUs + 10000; this.durationUs = j12; this.listener.onSourceInfoRefreshed(j12, this.seekMap, this.isLive); } StatsDataSource statsDataSource = extractingLoadable.dataSource; LoadEventInfo loadEventInfo = new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, statsDataSource.getLastOpenedUri(), statsDataSource.getLastResponseHeaders(), j10, j11, statsDataSource.getBytesRead()); this.loadErrorHandlingPolicy.onLoadTaskConcluded(extractingLoadable.loadTaskId); this.mediaSourceEventDispatcher.loadCompleted(loadEventInfo, 1, -1, null, 0, null, extractingLoadable.seekTimeUs, this.durationUs); this.loadingFinished = true; ((MediaPeriod.Callback) Assertions.checkNotNull(this.callback)).onContinueLoadingRequested(this); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public Loader.LoadErrorAction onLoadError(ExtractingLoadable extractingLoadable, long j10, long j11, IOException iOException, int i10) { boolean z10; ExtractingLoadable extractingLoadable2; Loader.LoadErrorAction loadErrorActionCreateRetryAction; StatsDataSource statsDataSource = extractingLoadable.dataSource; LoadEventInfo loadEventInfo = new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, statsDataSource.getLastOpenedUri(), statsDataSource.getLastResponseHeaders(), j10, j11, statsDataSource.getBytesRead()); long retryDelayMsFor = this.loadErrorHandlingPolicy.getRetryDelayMsFor(new LoadErrorHandlingPolicy.LoadErrorInfo(loadEventInfo, new MediaLoadData(1, -1, null, 0, null, Util.usToMs(extractingLoadable.seekTimeUs), Util.usToMs(this.durationUs)), iOException, i10)); if (retryDelayMsFor == -9223372036854775807L) { loadErrorActionCreateRetryAction = Loader.DONT_RETRY_FATAL; } else { int extractedSamplesCount = getExtractedSamplesCount(); if (extractedSamplesCount > this.extractedSamplesCountAtStartOfLoad) { extractingLoadable2 = extractingLoadable; z10 = true; } else { z10 = false; extractingLoadable2 = extractingLoadable; } loadErrorActionCreateRetryAction = configureRetry(extractingLoadable2, extractedSamplesCount) ? Loader.createRetryAction(z10, retryDelayMsFor) : Loader.DONT_RETRY; } boolean z11 = !loadErrorActionCreateRetryAction.isRetry(); this.mediaSourceEventDispatcher.loadError(loadEventInfo, 1, -1, null, 0, null, extractingLoadable.seekTimeUs, this.durationUs, iOException, z11); if (z11) { this.loadErrorHandlingPolicy.onLoadTaskConcluded(extractingLoadable.loadTaskId); } return loadErrorActionCreateRetryAction; } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadStarted(ExtractingLoadable extractingLoadable, long j10, long j11, int i10) { StatsDataSource statsDataSource = extractingLoadable.dataSource; this.mediaSourceEventDispatcher.loadStarted(i10 == 0 ? new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, j10) : new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, statsDataSource.getLastOpenedUri(), statsDataSource.getLastResponseHeaders(), j10, j11, statsDataSource.getBytesRead()), 1, -1, null, 0, null, extractingLoadable.seekTimeUs, this.durationUs, i10); } public void maybeThrowError() throws IOException { this.loader.maybeThrowError(this.loadErrorHandlingPolicy.getMinimumLoadableRetryCount(this.dataType)); } }