package androidx.media3.exoplayer.source; import android.net.Uri; import android.os.Handler; import androidx.media3.common.C; 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.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.decoder.DecoderInputBuffer; 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.DiscardingTrackOutput; import androidx.media3.extractor.ExtractorOutput; import androidx.media3.extractor.ForwardingSeekMap; import androidx.media3.extractor.ForwardingTrackOutput; import androidx.media3.extractor.IndexSeekMap; import androidx.media3.extractor.PositionHolder; import androidx.media3.extractor.SeekMap; import androidx.media3.extractor.TrackOutput; import androidx.media3.extractor.metadata.icy.IcyHeaders; import defpackage.fj4; import defpackage.if7; import defpackage.pm2; import defpackage.rq6; import java.io.IOException; import java.io.InterruptedIOException; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.atomic.AtomicReference; /* JADX INFO: loaded from: classes.dex */ final class ProgressiveMediaPeriod implements MediaPeriod, ExtractorOutput, 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; @rq6 private MediaPeriod.Callback callback; private final long continueLoadingCheckIntervalBytes; private ControlledTrackOutput[] controlledTrackOutputs; @rq6 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; @rq6 private IcyHeaders 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 boolean loadOnlySelectedTracks; 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 SeekMap seekMap; private boolean seenFirstTrackSelection; private final long singleSampleDurationUs; @rq6 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 static class ControlledTrackOutput extends ForwardingTrackOutput { private final DiscardingTrackOutput discardingTrackOutput; private final AtomicReference outputMode; private final SampleQueue sampleQueue; public enum OutputMode { PASS_THROUGH, DISCARD_AFTER_NEXT_SAMPLE_METADATA, DISCARDING } public ControlledTrackOutput(SampleQueue sampleQueue) { super(sampleQueue); this.sampleQueue = sampleQueue; this.discardingTrackOutput = new DiscardingTrackOutput(); this.outputMode = new AtomicReference<>(OutputMode.PASS_THROUGH); } private TrackOutput getCurrentOutput() { return this.outputMode.get() == OutputMode.DISCARDING ? this.discardingTrackOutput : this.sampleQueue; } public boolean isSelected() { return this.outputMode.get() == OutputMode.PASS_THROUGH; } @Override // androidx.media3.extractor.ForwardingTrackOutput, androidx.media3.extractor.TrackOutput public int sampleData(DataReader dataReader, int i, boolean z) throws IOException { return getCurrentOutput().sampleData(dataReader, i, z); } @Override // androidx.media3.extractor.ForwardingTrackOutput, androidx.media3.extractor.TrackOutput public void sampleMetadata(long j, int i, int i2, int i3, @rq6 TrackOutput.CryptoData cryptoData) { getCurrentOutput().sampleMetadata(j, i, i2, i3, cryptoData); if (this.outputMode.get() == OutputMode.DISCARD_AFTER_NEXT_SAMPLE_METADATA) { this.sampleQueue.reset(); this.outputMode.set(OutputMode.DISCARDING); } } public void updateSelectionState(boolean z) { this.outputMode.set(z ? OutputMode.PASS_THROUGH : OutputMode.DISCARD_AFTER_NEXT_SAMPLE_METADATA); if (z) { return; } this.sampleQueue.discardToEnd(); } @Override // androidx.media3.extractor.ForwardingTrackOutput, androidx.media3.extractor.TrackOutput public int sampleData(DataReader dataReader, int i, boolean z, int i2) throws IOException { return getCurrentOutput().sampleData(dataReader, i, z, i2); } @Override // androidx.media3.extractor.ForwardingTrackOutput, androidx.media3.extractor.TrackOutput public void sampleData(ParsableByteArray parsableByteArray, int i) { getCurrentOutput().sampleData(parsableByteArray, i); } @Override // androidx.media3.extractor.ForwardingTrackOutput, androidx.media3.extractor.TrackOutput public void sampleData(ParsableByteArray parsableByteArray, int i, int i2) { getCurrentOutput().sampleData(parsableByteArray, i, i2); } } public final class ExtractingLoadable implements Loader.Loadable, IcyDataSource.Listener { private final StatsDataSource dataSource; private final ExtractorOutput extractorOutput; @rq6 private TrackOutput 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 PositionHolder positionHolder = new PositionHolder(); private boolean pendingExtractorSeek = true; private final long loadTaskId = LoadEventInfo.getNewId(); private DataSpec dataSpec = buildDataSpec(0, null); public ExtractingLoadable(Uri uri, DataSource dataSource, ProgressiveMediaExtractor progressiveMediaExtractor, ExtractorOutput extractorOutput, ConditionVariable conditionVariable) { this.uri = uri; this.dataSource = new StatsDataSource(dataSource); this.progressiveMediaExtractor = progressiveMediaExtractor; this.extractorOutput = extractorOutput; this.loadCondition = conditionVariable; } private DataSpec buildDataSpec(long j, @rq6 String str) { Map mapB = ProgressiveMediaPeriod.ICY_METADATA_HEADERS; if (str != null && !str.startsWith("W/")) { fj4.a aVarA = fj4.a(); aVarA.e(mapB.entrySet()); aVarA.c("If-Range", str); mapB = aVarA.b(); } return new DataSpec.Builder().setUri(this.uri).setPosition(j).setKey(ProgressiveMediaPeriod.this.customCacheKey).setFlags(6).setHttpRequestHeaders(mapB).build(); } /* JADX INFO: Access modifiers changed from: private */ public void setLoadPosition(long j, long j2) { this.positionHolder.position = j; this.seekTimeUs = j2; 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 i = 0; String str = null; while (i == 0 && !this.loadCanceled) { try { long j = this.positionHolder.position; DataSpec dataSpecBuildDataSpec = buildDataSpec(j, str); this.dataSpec = dataSpecBuildDataSpec; long jOpen = this.dataSource.open(dataSpecBuildDataSpec); if (this.loadCanceled) { if (i != 1 && this.progressiveMediaExtractor.getCurrentInputPosition() != -1) { this.positionHolder.position = this.progressiveMediaExtractor.getCurrentInputPosition(); } DataSourceUtil.closeQuietly(this.dataSource); return; } List list = this.dataSource.getResponseHeaders().get("ETag"); str = (list == null || list.isEmpty()) ? null : list.get(0); if (jOpen != -1) { jOpen += j; ProgressiveMediaPeriod.this.onLengthKnown(); } long j2 = jOpen; ProgressiveMediaPeriod.this.icyHeaders = IcyHeaders.parse(this.dataSource.getResponseHeaders()); DataReader icyDataSource = this.dataSource; if (ProgressiveMediaPeriod.this.icyHeaders != null && ProgressiveMediaPeriod.this.icyHeaders.metadataInterval != -1) { icyDataSource = new IcyDataSource(this.dataSource, ProgressiveMediaPeriod.this.icyHeaders.metadataInterval, this); TrackOutput trackOutputIcyTrack = ProgressiveMediaPeriod.this.icyTrack(); this.icyTrackOutput = trackOutputIcyTrack; trackOutputIcyTrack.format(ProgressiveMediaPeriod.ICY_FORMAT); } this.progressiveMediaExtractor.init(icyDataSource, this.uri, this.dataSource.getResponseHeaders(), j, j2, this.extractorOutput); if (ProgressiveMediaPeriod.this.icyHeaders != null) { this.progressiveMediaExtractor.disableSeekingOnMp3Streams(); } if (this.pendingExtractorSeek) { this.progressiveMediaExtractor.seek(j, this.seekTimeUs); this.pendingExtractorSeek = false; } while (i == 0 && !this.loadCanceled) { try { this.loadCondition.block(); i = this.progressiveMediaExtractor.read(this.positionHolder); long currentInputPosition = this.progressiveMediaExtractor.getCurrentInputPosition(); if (currentInputPosition > ProgressiveMediaPeriod.this.continueLoadingCheckIntervalBytes + j) { this.loadCondition.close(); ProgressiveMediaPeriod.this.handler.post(ProgressiveMediaPeriod.this.onContinueLoadingRequestedRunnable); j = currentInputPosition; } } catch (InterruptedException unused) { throw new InterruptedIOException(); } } if (i == 1) { i = 0; } else if (this.progressiveMediaExtractor.getCurrentInputPosition() != -1) { this.positionHolder.position = this.progressiveMediaExtractor.getCurrentInputPosition(); } DataSourceUtil.closeQuietly(this.dataSource); } catch (Throwable th) { if (i != 1 && this.progressiveMediaExtractor.getCurrentInputPosition() != -1) { this.positionHolder.position = 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(); TrackOutput trackOutput = this.icyTrackOutput; trackOutput.getClass(); trackOutput.sampleData(parsableByteArray, iBytesLeft); trackOutput.sampleMetadata(jMax, 1, iBytesLeft, 0, null); this.seenIcyMetadata = true; } } public interface Listener { void onSourceInfoRefreshed(long j, SeekMap seekMap, boolean z); } public final class SampleStreamImpl implements SampleStream { private final int track; public SampleStreamImpl(int i) { this.track = i; } @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, DecoderInputBuffer decoderInputBuffer, int i) { return ProgressiveMediaPeriod.this.readData(this.track, formatHolder, decoderInputBuffer, i); } @Override // androidx.media3.exoplayer.source.SampleStream public int skipData(long j) { return ProgressiveMediaPeriod.this.skipData(this.track, j); } } public static final class TrackId { public final int id; public final boolean isIcyTrack; public TrackId(int i, boolean z) { this.id = i; this.isIcyTrack = z; } public boolean equals(@rq6 Object obj) { if (this == obj) { return true; } if (obj != null && TrackId.class == obj.getClass()) { TrackId trackId = (TrackId) obj; if (this.id == trackId.id && this.isIcyTrack == trackId.isIcyTrack) { return true; } } return false; } public int hashCode() { return (this.id * 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 i = trackGroupArray.length; this.trackEnabledStates = new boolean[i]; this.trackNotifiedDownstreamFormats = new boolean[i]; } } public ProgressiveMediaPeriod(Uri uri, DataSource dataSource, ProgressiveMediaExtractor progressiveMediaExtractor, DrmSessionManager drmSessionManager, DrmSessionEventListener.EventDispatcher eventDispatcher, LoadErrorHandlingPolicy loadErrorHandlingPolicy, MediaSourceEventListener.EventDispatcher eventDispatcher2, Listener listener, Allocator allocator, @rq6 String str, int i, boolean z, int i2, @rq6 Format format, long j, @rq6 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 = i; this.loadOnlySelectedTracks = z; this.singleTrackId = i2; this.singleTrackFormat = format; this.loader = releasableExecutor != null ? new Loader(releasableExecutor) : new Loader(TAG); this.progressiveMediaExtractor = progressiveMediaExtractor; this.singleSampleDurationUs = j; this.loadCondition = new ConditionVariable(); this.maybeFinishPrepareRunnable = new d(this, 1); this.onContinueLoadingRequestedRunnable = new d(this, 2); this.handler = Util.createHandlerForCurrentLooper(); this.sampleQueueTrackIds = new TrackId[0]; this.sampleQueues = new SampleQueue[0]; this.controlledTrackOutputs = new ControlledTrackOutput[0]; this.pendingResetPositionUs = C.TIME_UNSET; this.dataType = 1; } @pm2 private void assertPrepared() { if7.o(this.prepared); this.trackState.getClass(); this.seekMap.getClass(); } private boolean configureRetry(ExtractingLoadable extractingLoadable, int i) { SeekMap seekMap; if (this.isLengthKnown || !((seekMap = this.seekMap) == null || seekMap.getDurationUs() == C.TIME_UNSET)) { this.extractedSamplesCountAtStartOfLoad = i; 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(IcyHeaders.REQUEST_HEADER_ENABLE_METADATA_NAME, IcyHeaders.REQUEST_HEADER_ENABLE_METADATA_VALUE); 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 */ /* JADX WARN: Removed duplicated region for block: B:8:0x0015 */ /* Code decompiled incorrectly, please refer to instructions dump. */ public long getLargestQueuedTimestampUs(boolean z) { long jMax = Long.MIN_VALUE; for (int i = 0; i < this.sampleQueues.length; i++) { if (!z) { TrackState trackState = this.trackState; trackState.getClass(); if (trackState.trackEnabledStates[i]) { jMax = Math.max(jMax, this.sampleQueues[i].getLargestQueuedTimestampUs()); } } } return jMax; } private boolean isPendingReset() { return this.pendingResetPositionUs != C.TIME_UNSET; } /* JADX INFO: Access modifiers changed from: private */ public void lambda$new$0() { if (this.released) { return; } MediaPeriod.Callback callback = this.callback; callback.getClass(); 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() { 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 i = 0; i < length; i++) { Format upstreamFormat = this.sampleQueues[i].getUpstreamFormat(); upstreamFormat.getClass(); String str = upstreamFormat.sampleMimeType; boolean zIsAudio = MimeTypes.isAudio(str); boolean z = zIsAudio || MimeTypes.isVideo(str); zArr[i] = z; this.haveAudioVideoTracks = z | this.haveAudioVideoTracks; this.isSingleSample = this.singleSampleDurationUs != C.TIME_UNSET && length == 1 && MimeTypes.isImage(str); IcyHeaders icyHeaders = this.icyHeaders; if (icyHeaders != null) { if (zIsAudio || this.sampleQueueTrackIds[i].isIcyTrack) { Metadata metadata = upstreamFormat.metadata; upstreamFormat = upstreamFormat.buildUpon().setMetadata(metadata == null ? new Metadata(icyHeaders) : metadata.copyWithAppendedEntries(icyHeaders)).build(); } if (zIsAudio && upstreamFormat.averageBitrate == -1 && upstreamFormat.peakBitrate == -1 && icyHeaders.bitrate != -1) { upstreamFormat = upstreamFormat.buildUpon().setAverageBitrate(icyHeaders.bitrate).build(); } } Format formatCopyWithCryptoType = upstreamFormat.copyWithCryptoType(this.drmSessionManager.getCryptoType(upstreamFormat)); trackGroupArr[i] = new TrackGroup(Integer.toString(i), formatCopyWithCryptoType); this.pendingInitialDiscontinuity = formatCopyWithCryptoType.hasPrerollSamples | this.pendingInitialDiscontinuity; } this.trackState = new TrackState(new TrackGroupArray(trackGroupArr), zArr); if (this.isSingleSample && this.durationUs == C.TIME_UNSET) { this.durationUs = this.singleSampleDurationUs; this.seekMap = new ForwardingSeekMap(this.seekMap) { // from class: androidx.media3.exoplayer.source.ProgressiveMediaPeriod.1 @Override // androidx.media3.extractor.ForwardingSeekMap, androidx.media3.extractor.SeekMap public long getDurationUs() { return ProgressiveMediaPeriod.this.durationUs; } }; } this.listener.onSourceInfoRefreshed(this.durationUs, this.seekMap, this.isLive); this.prepared = true; MediaPeriod.Callback callback = this.callback; callback.getClass(); callback.onPrepared(this); } private void maybeNotifyDownstreamFormat(int i) { assertPrepared(); TrackState trackState = this.trackState; boolean[] zArr = trackState.trackNotifiedDownstreamFormats; if (zArr[i]) { return; } Format format = trackState.tracks.get(i).getFormat(0); this.mediaSourceEventDispatcher.downstreamFormatChanged(MimeTypes.getTrackType(format.sampleMimeType), format, 0, null, this.lastSeekPositionUs); zArr[i] = true; } private void maybeStartDeferredRetry(int i) { assertPrepared(); if (this.pendingDeferredRetry) { if (!this.haveAudioVideoTracks || this.trackState.trackIsAudioVideoFlags[i]) { if (this.sampleQueues[i].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 callback = this.callback; callback.getClass(); callback.onContinueLoadingRequested(this); } } } /* JADX INFO: Access modifiers changed from: private */ public void onLengthKnown() { this.handler.post(new d(this, 0)); } private TrackOutput prepareTrackOutput(TrackId trackId) { int length = this.sampleQueues.length; for (int i = 0; i < length; i++) { if (trackId.equals(this.sampleQueueTrackIds[i])) { return this.sampleQueues[i]; } } if (this.sampleQueuesBuilt) { Log.w(TAG, "Extractor added new track (id=" + trackId.id + ") after finishing tracks."); return new DiscardingTrackOutput(); } SampleQueue sampleQueueCreateWithDrm = SampleQueue.createWithDrm(this.allocator, this.drmSessionManager, this.drmEventDispatcher); ControlledTrackOutput controlledTrackOutput = new ControlledTrackOutput(sampleQueueCreateWithDrm); sampleQueueCreateWithDrm.setUpstreamFormatChangeListener(this); int i2 = length + 1; TrackId[] trackIdArr = (TrackId[]) Arrays.copyOf(this.sampleQueueTrackIds, i2); trackIdArr[length] = trackId; this.sampleQueueTrackIds = (TrackId[]) Util.castNonNullTypeArray(trackIdArr); SampleQueue[] sampleQueueArr = (SampleQueue[]) Arrays.copyOf(this.sampleQueues, i2); sampleQueueArr[length] = sampleQueueCreateWithDrm; this.sampleQueues = (SampleQueue[]) Util.castNonNullTypeArray(sampleQueueArr); ControlledTrackOutput[] controlledTrackOutputArr = (ControlledTrackOutput[]) Arrays.copyOf(this.controlledTrackOutputs, i2); controlledTrackOutputArr[length] = controlledTrackOutput; this.controlledTrackOutputs = (ControlledTrackOutput[]) Util.castNonNullTypeArray(controlledTrackOutputArr); return controlledTrackOutput; } private boolean seekInsideBufferUs(boolean[] zArr, long j, boolean z) { int length = this.sampleQueues.length; for (int i = 0; i < length; i++) { SampleQueue sampleQueue = this.sampleQueues[i]; if (this.controlledTrackOutputs[i].isSelected() && (sampleQueue.getReadIndex() != 0 || !z)) { if (!(this.isSingleSample ? sampleQueue.seekTo(sampleQueue.getFirstIndex()) : sampleQueue.seekTo(j, this.loadingFinished)) && (zArr[i] || !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(SeekMap seekMap) { this.seekMap = this.icyHeaders == null ? seekMap : new SeekMap.Unseekable(C.TIME_UNSET); this.durationUs = seekMap.getDurationUs(); boolean z = !this.isLengthKnown && seekMap.getDurationUs() == C.TIME_UNSET; this.isLive = z; this.dataType = z ? 7 : 1; if (this.prepared) { this.listener.onSourceInfoRefreshed(this.durationUs, seekMap, z); } else { maybeFinishPrepare(); } } private void startLoading() { ExtractingLoadable extractingLoadable = new ExtractingLoadable(this.uri, this.dataSource, this.progressiveMediaExtractor, this, this.loadCondition); if (this.prepared) { if7.o(isPendingReset()); long j = this.durationUs; if (j != C.TIME_UNSET && this.pendingResetPositionUs > j) { this.loadingFinished = true; this.pendingResetPositionUs = C.TIME_UNSET; return; } SeekMap seekMap = this.seekMap; seekMap.getClass(); extractingLoadable.setLoadPosition(seekMap.getSeekPoints(this.pendingResetPositionUs).first.position, this.pendingResetPositionUs); for (SampleQueue sampleQueue : this.sampleQueues) { sampleQueue.setStartTimeUs(this.pendingResetPositionUs); } this.pendingResetPositionUs = C.TIME_UNSET; } 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 j, boolean z) { if (this.isSingleSample) { return; } assertPrepared(); if (isPendingReset()) { return; } boolean[] zArr = this.trackState.trackEnabledStates; int length = this.sampleQueues.length; for (int i = 0; i < length; i++) { this.sampleQueues[i].discardTo(j, z, zArr[i]); } } @Override // androidx.media3.extractor.ExtractorOutput public void endTracks() { this.sampleQueuesBuilt = true; this.handler.post(this.maybeFinishPrepareRunnable); } @Override // androidx.media3.exoplayer.source.MediaPeriod public long getAdjustedSeekPositionUs(long j, SeekParameters seekParameters) { assertPrepared(); if (!this.seekMap.isSeekable()) { return 0L; } SeekMap.SeekPoints seekPoints = this.seekMap.getSeekPoints(j); return seekParameters.resolveSeekPositionUs(j, seekPoints.first.timeUs, seekPoints.second.timeUs); } @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 i = 0; i < length; i++) { TrackState trackState = this.trackState; if (trackState.trackIsAudioVideoFlags[i] && trackState.trackEnabledStates[i] && !this.sampleQueues[i].isLastSampleQueued()) { largestQueuedTimestampUs = Math.min(largestQueuedTimestampUs, this.sampleQueues[i].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 TrackOutput 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 i) { return !suppressRead() && this.sampleQueues[i].isReady(this.loadingFinished); } public void maybeThrowError(int i) throws IOException { this.sampleQueues[i].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 j) { this.callback = callback; if (this.singleTrackFormat == null) { this.loadCondition.open(); startLoading(); } else { track(this.singleTrackId, 3).format(this.singleTrackFormat); lambda$seekMap$1(new IndexSeekMap(new long[]{0}, new long[]{0}, C.TIME_UNSET)); endTracks(); this.pendingResetPositionUs = j; } } public int readData(int i, FormatHolder formatHolder, DecoderInputBuffer decoderInputBuffer, int i2) { if (suppressRead()) { return -3; } maybeNotifyDownstreamFormat(i); int i3 = this.sampleQueues[i].read(formatHolder, decoderInputBuffer, i2, this.loadingFinished); if (i3 == -3) { maybeStartDeferredRetry(i); } return i3; } @Override // androidx.media3.exoplayer.source.MediaPeriod public long readDiscontinuity() { if (this.pendingInitialDiscontinuity) { this.pendingInitialDiscontinuity = false; return this.lastSeekPositionUs; } if (!this.notifyDiscontinuity) { return C.TIME_UNSET; } if (!this.loadingFinished && getExtractedSamplesCount() <= this.extractedSamplesCountAtStartOfLoad) { return C.TIME_UNSET; } this.notifyDiscontinuity = false; return this.lastSeekPositionUs; } @Override // androidx.media3.exoplayer.source.MediaPeriod, androidx.media3.exoplayer.source.SequenceableLoader public void reevaluateBuffer(long j) { } 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.ExtractorOutput public void seekMap(final SeekMap seekMap) { this.handler.post(new Runnable() { // from class: androidx.media3.exoplayer.source.e @Override // java.lang.Runnable public final void run() { this.a.lambda$seekMap$1(seekMap); } }); } @Override // androidx.media3.exoplayer.source.MediaPeriod public long seekToUs(long j) { assertPrepared(); boolean[] zArr = this.trackState.trackIsAudioVideoFlags; if (!this.seekMap.isSeekable()) { j = 0; } int i = 0; this.notifyDiscontinuity = false; boolean z = this.lastSeekPositionUs == j; this.lastSeekPositionUs = j; if (isPendingReset()) { this.pendingResetPositionUs = j; return j; } if (this.dataType == 7 || ((!this.loadingFinished && !this.loader.isLoading()) || !seekInsideBufferUs(zArr, j, z))) { this.pendingDeferredRetry = false; this.pendingResetPositionUs = j; this.loadingFinished = false; this.pendingInitialDiscontinuity = false; if (this.loader.isLoading()) { SampleQueue[] sampleQueueArr = this.sampleQueues; int length = sampleQueueArr.length; while (i < length) { sampleQueueArr[i].discardToEnd(); i++; } this.loader.cancelLoading(); return j; } this.loader.clearFatalError(); SampleQueue[] sampleQueueArr2 = this.sampleQueues; int length2 = sampleQueueArr2.length; while (i < length2) { sampleQueueArr2[i].reset(); i++; } } return j; } @Override // androidx.media3.exoplayer.source.MediaPeriod public long selectTracks(ExoTrackSelection[] exoTrackSelectionArr, boolean[] zArr, SampleStream[] sampleStreamArr, boolean[] zArr2, long j) { ExoTrackSelection exoTrackSelection; assertPrepared(); TrackState trackState = this.trackState; TrackGroupArray trackGroupArray = trackState.tracks; boolean[] zArr3 = trackState.trackEnabledStates; int i = this.enabledTrackCount; int i2 = 0; for (int i3 = 0; i3 < exoTrackSelectionArr.length; i3++) { SampleStream sampleStream = sampleStreamArr[i3]; if (sampleStream != null && (exoTrackSelectionArr[i3] == null || !zArr[i3])) { int i4 = ((SampleStreamImpl) sampleStream).track; if7.o(zArr3[i4]); this.enabledTrackCount--; zArr3[i4] = false; sampleStreamArr[i3] = null; } } boolean z = !this.seenFirstTrackSelection ? j == 0 || this.isSingleSample : i != 0; for (int i5 = 0; i5 < exoTrackSelectionArr.length; i5++) { if (sampleStreamArr[i5] == null && (exoTrackSelection = exoTrackSelectionArr[i5]) != null) { if7.o(exoTrackSelection.length() == 1); if7.o(exoTrackSelection.getIndexInTrackGroup(0) == 0); int iIndexOf = trackGroupArray.indexOf(exoTrackSelection.getTrackGroup()); if7.o(!zArr3[iIndexOf]); this.enabledTrackCount++; zArr3[iIndexOf] = true; this.pendingInitialDiscontinuity = exoTrackSelection.getSelectedFormat().hasPrerollSamples | this.pendingInitialDiscontinuity; sampleStreamArr[i5] = new SampleStreamImpl(iIndexOf); zArr2[i5] = true; if (this.loadOnlySelectedTracks) { z |= this.seenFirstTrackSelection; } else if (!z) { SampleQueue sampleQueue = this.sampleQueues[iIndexOf]; z = (sampleQueue.getReadIndex() == 0 || sampleQueue.seekTo(j, true)) ? false : true; } } } if (this.loadOnlySelectedTracks) { int i6 = 0; while (true) { ControlledTrackOutput[] controlledTrackOutputArr = this.controlledTrackOutputs; if (i6 >= controlledTrackOutputArr.length) { break; } controlledTrackOutputArr[i6].updateSelectionState(zArr3[i6]); i6++; } } 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 (i2 < length) { sampleQueueArr[i2].discardToEnd(); i2++; } this.loader.cancelLoading(); } else { this.loadingFinished = false; SampleQueue[] sampleQueueArr2 = this.sampleQueues; int length2 = sampleQueueArr2.length; while (i2 < length2) { sampleQueueArr2[i2].reset(); i2++; } } } else if (z) { j = seekToUs(j); while (i2 < sampleStreamArr.length) { if (sampleStreamArr[i2] != null) { zArr2[i2] = true; } i2++; } } this.seenFirstTrackSelection = true; return j; } public int skipData(int i, long j) { if (suppressRead()) { return 0; } maybeNotifyDownstreamFormat(i); SampleQueue sampleQueue = this.sampleQueues[i]; int skipCount = sampleQueue.getSkipCount(j, this.loadingFinished); sampleQueue.skip(skipCount); if (skipCount == 0) { maybeStartDeferredRetry(i); } return skipCount; } @Override // androidx.media3.extractor.ExtractorOutput public TrackOutput track(int i, int i2) { return prepareTrackOutput(new TrackId(i, false)); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadCanceled(ExtractingLoadable extractingLoadable, long j, long j2, boolean z) { StatsDataSource statsDataSource = extractingLoadable.dataSource; LoadEventInfo loadEventInfo = new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, statsDataSource.getLastOpenedUri(), statsDataSource.getLastResponseHeaders(), j, j2, statsDataSource.getBytesRead()); this.loadErrorHandlingPolicy.onLoadTaskConcluded(extractingLoadable.loadTaskId); this.mediaSourceEventDispatcher.loadCanceled(loadEventInfo, 1, -1, null, 0, null, extractingLoadable.seekTimeUs, this.durationUs); if (z) { return; } for (SampleQueue sampleQueue : this.sampleQueues) { sampleQueue.reset(); } if (this.enabledTrackCount > 0) { MediaPeriod.Callback callback = this.callback; callback.getClass(); callback.onContinueLoadingRequested(this); } } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadCompleted(ExtractingLoadable extractingLoadable, long j, long j2) { if (this.durationUs == C.TIME_UNSET && this.seekMap != null) { long largestQueuedTimestampUs = getLargestQueuedTimestampUs(true); long j3 = largestQueuedTimestampUs == Long.MIN_VALUE ? 0L : largestQueuedTimestampUs + 10000; this.durationUs = j3; this.listener.onSourceInfoRefreshed(j3, this.seekMap, this.isLive); } StatsDataSource statsDataSource = extractingLoadable.dataSource; LoadEventInfo loadEventInfo = new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, statsDataSource.getLastOpenedUri(), statsDataSource.getLastResponseHeaders(), j, j2, 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 callback = this.callback; callback.getClass(); callback.onContinueLoadingRequested(this); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public Loader.LoadErrorAction onLoadError(ExtractingLoadable extractingLoadable, long j, long j2, IOException iOException, int i) { ExtractingLoadable extractingLoadable2; Loader.LoadErrorAction loadErrorActionCreateRetryAction; StatsDataSource statsDataSource = extractingLoadable.dataSource; LoadEventInfo loadEventInfo = new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, statsDataSource.getLastOpenedUri(), statsDataSource.getLastResponseHeaders(), j, j2, 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, i)); if (retryDelayMsFor == C.TIME_UNSET) { loadErrorActionCreateRetryAction = Loader.DONT_RETRY_FATAL; extractingLoadable2 = extractingLoadable; } else { int extractedSamplesCount = getExtractedSamplesCount(); extractingLoadable2 = extractingLoadable; loadErrorActionCreateRetryAction = configureRetry(extractingLoadable2, extractedSamplesCount) ? Loader.createRetryAction(extractedSamplesCount > this.extractedSamplesCountAtStartOfLoad, retryDelayMsFor) : Loader.DONT_RETRY; } boolean zIsRetry = loadErrorActionCreateRetryAction.isRetry(); this.mediaSourceEventDispatcher.loadError(loadEventInfo, 1, -1, null, 0, null, extractingLoadable2.seekTimeUs, this.durationUs, iOException, !zIsRetry); if (!zIsRetry) { this.loadErrorHandlingPolicy.onLoadTaskConcluded(extractingLoadable2.loadTaskId); } return loadErrorActionCreateRetryAction; } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadStarted(ExtractingLoadable extractingLoadable, long j, long j2, int i) { StatsDataSource statsDataSource = extractingLoadable.dataSource; this.mediaSourceEventDispatcher.loadStarted(i == 0 ? new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, j) : new LoadEventInfo(extractingLoadable.loadTaskId, extractingLoadable.dataSpec, statsDataSource.getLastOpenedUri(), statsDataSource.getLastResponseHeaders(), j, j2, statsDataSource.getBytesRead()), 1, -1, null, 0, null, extractingLoadable.seekTimeUs, this.durationUs, i); } public void maybeThrowError() throws IOException { this.loader.maybeThrowError(this.loadErrorHandlingPolicy.getMinimumLoadableRetryCount(this.dataType)); } }