package androidx.media3.exoplayer; import F3.L; import F3.M; import F3.O; import F3.p0; import android.os.Handler; import android.os.HandlerThread; import android.os.Looper; import android.os.Message; import android.util.Pair; import androidx.media3.common.Format; import androidx.media3.common.MediaItem; import androidx.media3.common.Metadata; import androidx.media3.common.ParserException; import androidx.media3.common.PlaybackParameters; import androidx.media3.common.Timeline; import androidx.media3.common.util.Assertions; import androidx.media3.common.util.Clock; import androidx.media3.common.util.HandlerWrapper; import androidx.media3.common.util.Log; import androidx.media3.common.util.TraceUtil; import androidx.media3.common.util.Util; import androidx.media3.datasource.DataSourceException; import androidx.media3.exoplayer.DefaultMediaClock; import androidx.media3.exoplayer.ExoPlayer; import androidx.media3.exoplayer.LoadControl; import androidx.media3.exoplayer.MediaSourceList; import androidx.media3.exoplayer.PlayerMessage; import androidx.media3.exoplayer.Renderer; import androidx.media3.exoplayer.RendererCapabilities; import androidx.media3.exoplayer.analytics.AnalyticsCollector; import androidx.media3.exoplayer.analytics.PlayerId; import androidx.media3.exoplayer.drm.DrmSession; import androidx.media3.exoplayer.metadata.MetadataRenderer; import androidx.media3.exoplayer.source.BehindLiveWindowException; import androidx.media3.exoplayer.source.MediaPeriod; import androidx.media3.exoplayer.source.MediaSource; import androidx.media3.exoplayer.source.SampleStream; import androidx.media3.exoplayer.source.ShuffleOrder; import androidx.media3.exoplayer.source.TrackGroupArray; import androidx.media3.exoplayer.text.TextRenderer; import androidx.media3.exoplayer.trackselection.ExoTrackSelection; import androidx.media3.exoplayer.trackselection.TrackSelector; import androidx.media3.exoplayer.trackselection.TrackSelectorResult; import androidx.media3.exoplayer.upstream.BandwidthMeter; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.IdentityHashMap; import java.util.List; import java.util.Set; import java.util.concurrent.atomic.AtomicBoolean; /* JADX INFO: loaded from: classes.dex */ final class ExoPlayerImplInternal implements Handler.Callback, MediaPeriod.Callback, TrackSelector.InvalidationListener, MediaSourceList.MediaSourceListInfoRefreshListener, DefaultMediaClock.PlaybackParametersListener, PlayerMessage.Sender { private static final long BUFFERING_MAXIMUM_INTERVAL_MS = Util.usToMs(10000); private static final int MSG_ADD_MEDIA_SOURCES = 18; private static final int MSG_ATTEMPT_RENDERER_ERROR_RECOVERY = 25; private static final int MSG_DO_SOME_WORK = 2; private static final int MSG_MOVE_MEDIA_SOURCES = 19; private static final int MSG_PERIOD_PREPARED = 8; private static final int MSG_PLAYBACK_PARAMETERS_CHANGED_INTERNAL = 16; private static final int MSG_PLAYLIST_UPDATE_REQUESTED = 22; private static final int MSG_PREPARE = 29; private static final int MSG_RELEASE = 7; private static final int MSG_REMOVE_MEDIA_SOURCES = 20; private static final int MSG_RENDERER_CAPABILITIES_CHANGED = 26; private static final int MSG_SEEK_TO = 3; private static final int MSG_SEND_MESSAGE = 14; private static final int MSG_SEND_MESSAGE_TO_TARGET_THREAD = 15; private static final int MSG_SET_FOREGROUND_MODE = 13; private static final int MSG_SET_MEDIA_SOURCES = 17; private static final int MSG_SET_PAUSE_AT_END_OF_WINDOW = 23; private static final int MSG_SET_PLAYBACK_PARAMETERS = 4; private static final int MSG_SET_PLAY_WHEN_READY = 1; private static final int MSG_SET_PRELOAD_CONFIGURATION = 28; private static final int MSG_SET_REPEAT_MODE = 11; private static final int MSG_SET_SEEK_PARAMETERS = 5; private static final int MSG_SET_SHUFFLE_ENABLED = 12; private static final int MSG_SET_SHUFFLE_ORDER = 21; private static final int MSG_SOURCE_CONTINUE_LOADING_REQUESTED = 9; private static final int MSG_STOP = 6; private static final int MSG_TRACK_SELECTION_INVALIDATED = 10; private static final int MSG_UPDATE_MEDIA_SOURCES_WITH_MEDIA_ITEMS = 27; private static final long PLAYBACK_BUFFER_EMPTY_THRESHOLD_US = 500000; private static final long PLAYBACK_STUCK_AFTER_MS = 4000; private static final long READY_MAXIMUM_INTERVAL_MS = 1000; private static final String TAG = "ExoPlayerImplInternal"; private final long backBufferDurationUs; private final BandwidthMeter bandwidthMeter; private final Clock clock; private boolean deliverPendingMessageAtStartPositionRequired; private final boolean dynamicSchedulingEnabled; private final TrackSelectorResult emptyTrackSelectorResult; private int enabledRendererCount; private boolean foregroundMode; private final HandlerWrapper handler; private final HandlerThread internalPlaybackThread; private boolean isRebuffering; private final LivePlaybackSpeedControl livePlaybackSpeedControl; private final LoadControl loadControl; private final DefaultMediaClock mediaClock; private final MediaSourceList mediaSourceList; private int nextPendingMessageIndexHint; private boolean offloadSchedulingEnabled; private boolean pauseAtEndOfWindow; private SeekPosition pendingInitialSeekPosition; private final ArrayList pendingMessages; private boolean pendingPauseAtEndOfPeriod; private ExoPlaybackException pendingRecoverableRendererError; private final Timeline.Period period; private PlaybackInfo playbackInfo; private PlaybackInfoUpdate playbackInfoUpdate; private final PlaybackInfoUpdateListener playbackInfoUpdateListener; private final Looper playbackLooper; private final PlayerId playerId; private ExoPlayer.PreloadConfiguration preloadConfiguration; private final MediaPeriodQueue queue; private final long releaseTimeoutMs; private boolean released; private final RendererCapabilities[] rendererCapabilities; private long rendererPositionElapsedRealtimeUs; private long rendererPositionUs; private final Renderer[] renderers; private final Set renderersToReset; private int repeatMode; private boolean requestForRendererSleep; private final boolean retainBackBufferFromKeyframe; private SeekParameters seekParameters; private long setForegroundModeTimeoutMs; private boolean shouldContinueLoading; private boolean shuffleModeEnabled; private final TrackSelector trackSelector; private final Timeline.Window window; private long playbackMaybeBecameStuckAtMs = androidx.media3.common.C.TIME_UNSET; private long lastRebufferRealtimeMs = androidx.media3.common.C.TIME_UNSET; private Timeline lastPreloadPoolInvalidationTimeline = Timeline.EMPTY; public static final class MediaSourceListUpdateMessage { private final List mediaSourceHolders; private final long positionUs; private final ShuffleOrder shuffleOrder; private final int windowIndex; private MediaSourceListUpdateMessage(List list, ShuffleOrder shuffleOrder, int i6, long j4) { this.mediaSourceHolders = list; this.shuffleOrder = shuffleOrder; this.windowIndex = i6; this.positionUs = j4; } } public static class MoveMediaItemsMessage { public final int fromIndex; public final int newFromIndex; public final ShuffleOrder shuffleOrder; public final int toIndex; public MoveMediaItemsMessage(int i6, int i7, int i8, ShuffleOrder shuffleOrder) { this.fromIndex = i6; this.toIndex = i7; this.newFromIndex = i8; this.shuffleOrder = shuffleOrder; } } public static final class PendingMessageInfo implements Comparable { public final PlayerMessage message; public int resolvedPeriodIndex; public long resolvedPeriodTimeUs; public Object resolvedPeriodUid; public PendingMessageInfo(PlayerMessage playerMessage) { this.message = playerMessage; } public void setResolvedPosition(int i6, long j4, Object obj) { this.resolvedPeriodIndex = i6; this.resolvedPeriodTimeUs = j4; this.resolvedPeriodUid = obj; } @Override // java.lang.Comparable public int compareTo(PendingMessageInfo pendingMessageInfo) { Object obj = this.resolvedPeriodUid; if ((obj == null) != (pendingMessageInfo.resolvedPeriodUid == null)) { return obj != null ? -1 : 1; } if (obj == null) { return 0; } int i6 = this.resolvedPeriodIndex - pendingMessageInfo.resolvedPeriodIndex; return i6 != 0 ? i6 : Util.compareLong(this.resolvedPeriodTimeUs, pendingMessageInfo.resolvedPeriodTimeUs); } } public static final class PlaybackInfoUpdate { public int discontinuityReason; private boolean hasPendingChange; public int operationAcks; public PlaybackInfo playbackInfo; public boolean positionDiscontinuity; public PlaybackInfoUpdate(PlaybackInfo playbackInfo) { this.playbackInfo = playbackInfo; } public void incrementPendingOperationAcks(int i6) { this.hasPendingChange |= i6 > 0; this.operationAcks += i6; } public void setPlaybackInfo(PlaybackInfo playbackInfo) { this.hasPendingChange |= this.playbackInfo != playbackInfo; this.playbackInfo = playbackInfo; } public void setPositionDiscontinuity(int i6) { if (this.positionDiscontinuity && this.discontinuityReason != 5) { Assertions.checkArgument(i6 == 5); return; } this.hasPendingChange = true; this.positionDiscontinuity = true; this.discontinuityReason = i6; } } public interface PlaybackInfoUpdateListener { void onPlaybackInfoUpdate(PlaybackInfoUpdate playbackInfoUpdate); } public static final class PositionUpdateForPlaylistChange { public final boolean endPlayback; public final boolean forceBufferingState; public final MediaSource.MediaPeriodId periodId; public final long periodPositionUs; public final long requestedContentPositionUs; public final boolean setTargetLiveOffset; public PositionUpdateForPlaylistChange(MediaSource.MediaPeriodId mediaPeriodId, long j4, long j6, boolean z6, boolean z7, boolean z8) { this.periodId = mediaPeriodId; this.periodPositionUs = j4; this.requestedContentPositionUs = j6; this.forceBufferingState = z6; this.endPlayback = z7; this.setTargetLiveOffset = z8; } } public static final class SeekPosition { public final Timeline timeline; public final int windowIndex; public final long windowPositionUs; public SeekPosition(Timeline timeline, int i6, long j4) { this.timeline = timeline; this.windowIndex = i6; this.windowPositionUs = j4; } } public ExoPlayerImplInternal(Renderer[] rendererArr, TrackSelector trackSelector, TrackSelectorResult trackSelectorResult, LoadControl loadControl, BandwidthMeter bandwidthMeter, int i6, boolean z6, AnalyticsCollector analyticsCollector, SeekParameters seekParameters, LivePlaybackSpeedControl livePlaybackSpeedControl, long j4, boolean z7, boolean z8, Looper looper, Clock clock, PlaybackInfoUpdateListener playbackInfoUpdateListener, PlayerId playerId, Looper looper2, ExoPlayer.PreloadConfiguration preloadConfiguration) { this.playbackInfoUpdateListener = playbackInfoUpdateListener; this.renderers = rendererArr; this.trackSelector = trackSelector; this.emptyTrackSelectorResult = trackSelectorResult; this.loadControl = loadControl; this.bandwidthMeter = bandwidthMeter; this.repeatMode = i6; this.shuffleModeEnabled = z6; this.seekParameters = seekParameters; this.livePlaybackSpeedControl = livePlaybackSpeedControl; this.releaseTimeoutMs = j4; this.setForegroundModeTimeoutMs = j4; this.pauseAtEndOfWindow = z7; this.dynamicSchedulingEnabled = z8; this.clock = clock; this.playerId = playerId; this.preloadConfiguration = preloadConfiguration; this.backBufferDurationUs = loadControl.getBackBufferDurationUs(playerId); this.retainBackBufferFromKeyframe = loadControl.retainBackBufferFromKeyframe(playerId); PlaybackInfo playbackInfoCreateDummy = PlaybackInfo.createDummy(trackSelectorResult); this.playbackInfo = playbackInfoCreateDummy; this.playbackInfoUpdate = new PlaybackInfoUpdate(playbackInfoCreateDummy); this.rendererCapabilities = new RendererCapabilities[rendererArr.length]; RendererCapabilities.Listener rendererCapabilitiesListener = trackSelector.getRendererCapabilitiesListener(); for (int i7 = 0; i7 < rendererArr.length; i7++) { rendererArr[i7].init(i7, playerId, clock); this.rendererCapabilities[i7] = rendererArr[i7].getCapabilities(); if (rendererCapabilitiesListener != null) { this.rendererCapabilities[i7].setListener(rendererCapabilitiesListener); } } this.mediaClock = new DefaultMediaClock(this, clock); this.pendingMessages = new ArrayList<>(); this.renderersToReset = Collections.newSetFromMap(new IdentityHashMap()); this.window = new Timeline.Window(); this.period = new Timeline.Period(); trackSelector.init(this, bandwidthMeter); this.deliverPendingMessageAtStartPositionRequired = true; HandlerWrapper handlerWrapperCreateHandler = clock.createHandler(looper, null); this.queue = new MediaPeriodQueue(analyticsCollector, handlerWrapperCreateHandler, new m(this, 9), preloadConfiguration); this.mediaSourceList = new MediaSourceList(this, analyticsCollector, handlerWrapperCreateHandler, playerId); if (looper2 != null) { this.internalPlaybackThread = null; this.playbackLooper = looper2; } else { HandlerThread handlerThread = new HandlerThread("ExoPlayer:Playback", -16); this.internalPlaybackThread = handlerThread; handlerThread.start(); this.playbackLooper = handlerThread.getLooper(); } this.handler = clock.createHandler(this.playbackLooper, this); } private void addMediaItemsInternal(MediaSourceListUpdateMessage mediaSourceListUpdateMessage, int i6) throws Throwable { this.playbackInfoUpdate.incrementPendingOperationAcks(1); MediaSourceList mediaSourceList = this.mediaSourceList; if (i6 == -1) { i6 = mediaSourceList.getSize(); } handleMediaSourceListInfoRefreshed(mediaSourceList.addMediaSources(i6, mediaSourceListUpdateMessage.mediaSourceHolders, mediaSourceListUpdateMessage.shuffleOrder), false); } private void allowRenderersToRenderStartOfStreams() { TrackSelectorResult trackSelectorResult = this.queue.getPlayingPeriod().getTrackSelectorResult(); for (int i6 = 0; i6 < this.renderers.length; i6++) { if (trackSelectorResult.isRendererEnabled(i6)) { this.renderers[i6].enableMayRenderStartOfStream(); } } } private void attemptRendererErrorRecovery() { reselectTracksInternalAndSeek(); } /* JADX INFO: Access modifiers changed from: private */ public MediaPeriodHolder createMediaPeriodHolder(MediaPeriodInfo mediaPeriodInfo, long j4) { return new MediaPeriodHolder(this.rendererCapabilities, j4, this.trackSelector, this.loadControl.getAllocator(), this.mediaSourceList, mediaPeriodInfo, this.emptyTrackSelectorResult); } private void deliverMessage(PlayerMessage playerMessage) { if (playerMessage.isCanceled()) { return; } try { playerMessage.getTarget().handleMessage(playerMessage.getType(), playerMessage.getPayload()); } finally { playerMessage.markAsProcessed(true); } } private void disableRenderer(Renderer renderer) { if (isRendererEnabled(renderer)) { this.mediaClock.onRendererDisabled(renderer); ensureStopped(renderer); renderer.disable(); this.enabledRendererCount--; } } /* JADX WARN: Removed duplicated region for block: B:117:0x01af */ /* JADX WARN: Removed duplicated region for block: B:120:0x01b8 */ /* JADX WARN: Removed duplicated region for block: B:123:0x01c0 */ /* JADX WARN: Removed duplicated region for block: B:126:0x01c5 */ /* JADX WARN: Removed duplicated region for block: B:130:0x01cc */ /* JADX WARN: Removed duplicated region for block: B:133:0x01d3 */ /* JADX WARN: Removed duplicated region for block: B:136:0x01dd */ /* JADX WARN: Removed duplicated region for block: B:65:0x00d9 */ /* JADX WARN: Removed duplicated region for block: B:70:0x00ea */ /* JADX WARN: Removed duplicated region for block: B:73:0x00f7 */ /* JADX WARN: Removed duplicated region for block: B:80:0x011b */ /* JADX WARN: Removed duplicated region for block: B:90:0x013c */ /* JADX WARN: Removed duplicated region for block: B:94:0x014d */ /* Code decompiled incorrectly, please refer to instructions dump. */ private void doSomeWork() { boolean z6; boolean z7; long j4; boolean z8; boolean z9; PlaybackInfo playbackInfo; int i6; long jUptimeMillis = this.clock.uptimeMillis(); this.handler.removeMessages(2); updatePeriods(); int i7 = this.playbackInfo.playbackState; if (i7 == 1 || i7 == 4) { return; } MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); if (playingPeriod == null) { scheduleNextWork(jUptimeMillis); return; } TraceUtil.beginSection("doSomeWork"); updatePlaybackPositions(); if (playingPeriod.prepared) { this.rendererPositionElapsedRealtimeUs = Util.msToUs(this.clock.elapsedRealtime()); playingPeriod.mediaPeriod.discardBuffer(this.playbackInfo.positionUs - this.backBufferDurationUs, this.retainBackBufferFromKeyframe); z6 = true; z7 = true; int i8 = 0; while (true) { Renderer[] rendererArr = this.renderers; if (i8 >= rendererArr.length) { break; } Renderer renderer = rendererArr[i8]; if (isRendererEnabled(renderer)) { renderer.render(this.rendererPositionUs, this.rendererPositionElapsedRealtimeUs); z6 = z6 && renderer.isEnded(); boolean z10 = playingPeriod.sampleStreams[i8] != renderer.getStream(); boolean z11 = z10 || (!z10 && renderer.hasReadStreamToEnd()) || renderer.isReady() || renderer.isEnded(); z7 = z7 && z11; if (!z11) { renderer.maybeThrowStreamError(); } } i8++; } } else { playingPeriod.mediaPeriod.maybeThrowPrepareError(); z6 = true; z7 = true; } long j6 = playingPeriod.info.durationUs; if (z6 && playingPeriod.prepared) { if (j6 != androidx.media3.common.C.TIME_UNSET) { j4 = -9223372036854775807L; if (j6 <= this.playbackInfo.positionUs) { } if (z8 && this.pendingPauseAtEndOfPeriod) { this.pendingPauseAtEndOfPeriod = false; setPlayWhenReadyInternal(false, this.playbackInfo.playbackSuppressionReason, false, 5); } if (z8 && playingPeriod.info.isFinal) { setState(4); stopRenderers(); } else if (this.playbackInfo.playbackState != 2 && shouldTransitionToReadyState(z7)) { setState(3); this.pendingRecoverableRendererError = null; if (shouldPlayWhenReady()) { updateRebufferingState(false, false); this.mediaClock.start(); startRenderers(); } } else if (this.playbackInfo.playbackState == 3 && (this.enabledRendererCount != 0 ? !z7 : !isTimelineReady())) { updateRebufferingState(shouldPlayWhenReady(), false); setState(2); if (this.isRebuffering) { notifyTrackSelectionRebuffer(); this.livePlaybackSpeedControl.notifyRebuffer(); } stopRenderers(); } if (this.playbackInfo.playbackState == 2) { int i9 = 0; while (true) { Renderer[] rendererArr2 = this.renderers; if (i9 >= rendererArr2.length) { break; } if (isRendererEnabled(rendererArr2[i9]) && this.renderers[i9].getStream() == playingPeriod.sampleStreams[i9]) { this.renderers[i9].maybeThrowStreamError(); } i9++; } PlaybackInfo playbackInfo2 = this.playbackInfo; if (playbackInfo2.isLoading || playbackInfo2.totalBufferedDurationUs >= PLAYBACK_BUFFER_EMPTY_THRESHOLD_US || !isLoadingPossible()) { this.playbackMaybeBecameStuckAtMs = j4; } else if (this.playbackMaybeBecameStuckAtMs == j4) { this.playbackMaybeBecameStuckAtMs = this.clock.elapsedRealtime(); } else if (this.clock.elapsedRealtime() - this.playbackMaybeBecameStuckAtMs >= PLAYBACK_STUCK_AFTER_MS) { throw new IllegalStateException("Playback stuck buffering and not loading"); } } boolean z12 = shouldPlayWhenReady() && this.playbackInfo.playbackState == 3; z9 = this.offloadSchedulingEnabled && this.requestForRendererSleep && z12; playbackInfo = this.playbackInfo; if (playbackInfo.sleepingForOffload != z9) { this.playbackInfo = playbackInfo.copyWithSleepingForOffload(z9); } this.requestForRendererSleep = false; if (!z9 && (i6 = this.playbackInfo.playbackState) != 4 && (z12 || i6 == 2 || (i6 == 3 && this.enabledRendererCount != 0))) { scheduleNextWork(jUptimeMillis); } TraceUtil.endSection(); } j4 = -9223372036854775807L; z8 = true; if (z8) { this.pendingPauseAtEndOfPeriod = false; setPlayWhenReadyInternal(false, this.playbackInfo.playbackSuppressionReason, false, 5); } if (z8) { if (this.playbackInfo.playbackState != 2) { if (this.playbackInfo.playbackState == 3) { updateRebufferingState(shouldPlayWhenReady(), false); setState(2); if (this.isRebuffering) { } stopRenderers(); } } } if (this.playbackInfo.playbackState == 2) { } if (shouldPlayWhenReady()) { } if (this.offloadSchedulingEnabled) { } playbackInfo = this.playbackInfo; if (playbackInfo.sleepingForOffload != z9) { } this.requestForRendererSleep = false; if (!z9) { scheduleNextWork(jUptimeMillis); } TraceUtil.endSection(); } j4 = -9223372036854775807L; z8 = false; if (z8) { } if (z8) { } if (this.playbackInfo.playbackState == 2) { } if (shouldPlayWhenReady()) { } if (this.offloadSchedulingEnabled) { } playbackInfo = this.playbackInfo; if (playbackInfo.sleepingForOffload != z9) { } this.requestForRendererSleep = false; if (!z9) { } TraceUtil.endSection(); } private void enableRenderer(int i6, boolean z6, long j4) { Renderer renderer = this.renderers[i6]; if (isRendererEnabled(renderer)) { return; } MediaPeriodHolder readingPeriod = this.queue.getReadingPeriod(); boolean z7 = readingPeriod == this.queue.getPlayingPeriod(); TrackSelectorResult trackSelectorResult = readingPeriod.getTrackSelectorResult(); RendererConfiguration rendererConfiguration = trackSelectorResult.rendererConfigurations[i6]; Format[] formats = getFormats(trackSelectorResult.selections[i6]); boolean z8 = shouldPlayWhenReady() && this.playbackInfo.playbackState == 3; boolean z9 = !z6 && z8; this.enabledRendererCount++; this.renderersToReset.add(renderer); renderer.enable(rendererConfiguration, formats, readingPeriod.sampleStreams[i6], this.rendererPositionUs, z9, z7, j4, readingPeriod.getRendererOffset(), readingPeriod.info.id); renderer.handleMessage(11, new Renderer.WakeupListener() { // from class: androidx.media3.exoplayer.ExoPlayerImplInternal.1 @Override // androidx.media3.exoplayer.Renderer.WakeupListener public void onSleep() { ExoPlayerImplInternal.this.requestForRendererSleep = true; } @Override // androidx.media3.exoplayer.Renderer.WakeupListener public void onWakeup() { if (ExoPlayerImplInternal.this.dynamicSchedulingEnabled || ExoPlayerImplInternal.this.offloadSchedulingEnabled) { ExoPlayerImplInternal.this.handler.sendEmptyMessage(2); } } }); this.mediaClock.onRendererEnabled(renderer); if (z8 && z7) { renderer.start(); } } private void enableRenderers() { enableRenderers(new boolean[this.renderers.length], this.queue.getReadingPeriod().getStartPositionRendererTime()); } private void ensureStopped(Renderer renderer) { if (renderer.getState() == 2) { renderer.stop(); } } private O extractMetadataFromTrackSelectionArray(ExoTrackSelection[] exoTrackSelectionArr) { L l = new L(4); boolean z6 = false; for (ExoTrackSelection exoTrackSelection : exoTrackSelectionArr) { if (exoTrackSelection != null) { Metadata metadata = exoTrackSelection.getFormat(0).metadata; if (metadata == null) { l.a(new Metadata(new Metadata.Entry[0])); } else { l.a(metadata); z6 = true; } } } if (z6) { return l.f(); } M m6 = O.f1509b; return p0.f1586e; } private long getCurrentLiveOffsetUs() { PlaybackInfo playbackInfo = this.playbackInfo; return getLiveOffsetUs(playbackInfo.timeline, playbackInfo.periodId.periodUid, playbackInfo.positionUs); } private static Format[] getFormats(ExoTrackSelection exoTrackSelection) { int length = exoTrackSelection != null ? exoTrackSelection.length() : 0; Format[] formatArr = new Format[length]; for (int i6 = 0; i6 < length; i6++) { formatArr[i6] = exoTrackSelection.getFormat(i6); } return formatArr; } private long getLiveOffsetUs(Timeline timeline, Object obj, long j4) { timeline.getWindow(timeline.getPeriodByUid(obj, this.period).windowIndex, this.window); Timeline.Window window = this.window; if (window.windowStartTimeMs != androidx.media3.common.C.TIME_UNSET && window.isLive()) { Timeline.Window window2 = this.window; if (window2.isDynamic) { return Util.msToUs(window2.getCurrentUnixTimeMs() - this.window.windowStartTimeMs) - (this.period.getPositionInWindowUs() + j4); } } return androidx.media3.common.C.TIME_UNSET; } private long getMaxRendererReadPositionUs() { MediaPeriodHolder readingPeriod = this.queue.getReadingPeriod(); if (readingPeriod == null) { return 0L; } long rendererOffset = readingPeriod.getRendererOffset(); if (!readingPeriod.prepared) { return rendererOffset; } int i6 = 0; while (true) { Renderer[] rendererArr = this.renderers; if (i6 >= rendererArr.length) { return rendererOffset; } if (isRendererEnabled(rendererArr[i6]) && this.renderers[i6].getStream() == readingPeriod.sampleStreams[i6]) { long readingPositionUs = this.renderers[i6].getReadingPositionUs(); if (readingPositionUs == Long.MIN_VALUE) { return Long.MIN_VALUE; } rendererOffset = Math.max(readingPositionUs, rendererOffset); } i6++; } } private Pair getPlaceholderFirstMediaPeriodPositionUs(Timeline timeline) { if (timeline.isEmpty()) { return Pair.create(PlaybackInfo.getDummyPeriodForEmptyTimeline(), 0L); } Pair periodPositionUs = timeline.getPeriodPositionUs(this.window, this.period, timeline.getFirstWindowIndex(this.shuffleModeEnabled), androidx.media3.common.C.TIME_UNSET); MediaSource.MediaPeriodId mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange = this.queue.resolveMediaPeriodIdForAdsAfterPeriodPositionChange(timeline, periodPositionUs.first, 0L); long jLongValue = ((Long) periodPositionUs.second).longValue(); if (mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.isAd()) { timeline.getPeriodByUid(mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.periodUid, this.period); jLongValue = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.adIndexInAdGroup == this.period.getFirstAdIndexToPlay(mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.adGroupIndex) ? this.period.getAdResumePositionUs() : 0L; } return Pair.create(mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange, Long.valueOf(jLongValue)); } private long getTotalBufferedDurationUs() { return getTotalBufferedDurationUs(this.playbackInfo.bufferedPositionUs); } private void handleContinueLoadingRequested(MediaPeriod mediaPeriod) { if (this.queue.isLoading(mediaPeriod)) { this.queue.reevaluateBuffer(this.rendererPositionUs); maybeContinueLoading(); } } private void handleIoException(IOException iOException, int i6) { ExoPlaybackException exoPlaybackExceptionCreateForSource = ExoPlaybackException.createForSource(iOException, i6); MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); if (playingPeriod != null) { exoPlaybackExceptionCreateForSource = exoPlaybackExceptionCreateForSource.copyWithMediaPeriodId(playingPeriod.info.id); } Log.e(TAG, "Playback error", exoPlaybackExceptionCreateForSource); stopInternal(false, false); this.playbackInfo = this.playbackInfo.copyWithPlaybackError(exoPlaybackExceptionCreateForSource); } private void handleLoadingMediaPeriodChanged(boolean z6) { MediaPeriodHolder loadingPeriod = this.queue.getLoadingPeriod(); MediaSource.MediaPeriodId mediaPeriodId = loadingPeriod == null ? this.playbackInfo.periodId : loadingPeriod.info.id; boolean zEquals = this.playbackInfo.loadingMediaPeriodId.equals(mediaPeriodId); if (!zEquals) { this.playbackInfo = this.playbackInfo.copyWithLoadingMediaPeriodId(mediaPeriodId); } PlaybackInfo playbackInfo = this.playbackInfo; playbackInfo.bufferedPositionUs = loadingPeriod == null ? playbackInfo.positionUs : loadingPeriod.getBufferedPositionUs(); this.playbackInfo.totalBufferedDurationUs = getTotalBufferedDurationUs(); if ((!zEquals || z6) && loadingPeriod != null && loadingPeriod.prepared) { updateLoadControlTrackSelection(loadingPeriod.info.id, loadingPeriod.getTrackGroups(), loadingPeriod.getTrackSelectorResult()); } } /* JADX WARN: Removed duplicated region for block: B:101:0x0194 */ /* JADX WARN: Removed duplicated region for block: B:105:0x01b5 */ /* JADX WARN: Removed duplicated region for block: B:82:0x0151 */ /* JADX WARN: Removed duplicated region for block: B:83:0x0153 */ /* JADX WARN: Removed duplicated region for block: B:88:0x0164 */ /* JADX WARN: Removed duplicated region for block: B:96:0x0183 */ /* JADX WARN: Removed duplicated region for block: B:99:0x018f */ /* Code decompiled incorrectly, please refer to instructions dump. */ private void handleMediaSourceListInfoRefreshed(Timeline timeline, boolean z6) throws Throwable { int i6; MediaSource.MediaPeriodId mediaPeriodId; long j4; Timeline timeline2; long j6; boolean z7; long j7; int i7; Timeline timeline3; Timeline timeline4 = timeline; PositionUpdateForPlaylistChange positionUpdateForPlaylistChangeResolvePositionForPlaylistChange = resolvePositionForPlaylistChange(timeline4, this.playbackInfo, this.pendingInitialSeekPosition, this.queue, this.repeatMode, this.shuffleModeEnabled, this.window, this.period); MediaSource.MediaPeriodId mediaPeriodId2 = positionUpdateForPlaylistChangeResolvePositionForPlaylistChange.periodId; long j8 = positionUpdateForPlaylistChangeResolvePositionForPlaylistChange.requestedContentPositionUs; boolean z8 = positionUpdateForPlaylistChangeResolvePositionForPlaylistChange.forceBufferingState; long jSeekToPeriodPosition = positionUpdateForPlaylistChangeResolvePositionForPlaylistChange.periodPositionUs; int i8 = 1; boolean z9 = (this.playbackInfo.periodId.equals(mediaPeriodId2) && jSeekToPeriodPosition == this.playbackInfo.positionUs) ? false : true; try { if (positionUpdateForPlaylistChangeResolvePositionForPlaylistChange.endPlayback) { if (this.playbackInfo.playbackState != 1) { setState(4); } resetInternal(false, false, false, true); } for (Renderer renderer : this.renderers) { renderer.setTimeline(timeline4); } try { if (z9) { i6 = 4; i8 = -1; if (!timeline4.isEmpty()) { for (MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); playingPeriod != null; playingPeriod = playingPeriod.getNext()) { if (playingPeriod.info.id.equals(mediaPeriodId2)) { playingPeriod.info = this.queue.getUpdatedMediaPeriodInfo(timeline4, playingPeriod.info); playingPeriod.updateClipping(); } } jSeekToPeriodPosition = seekToPeriodPosition(mediaPeriodId2, jSeekToPeriodPosition, z8); } } else { try { } catch (Throwable th) { th = th; timeline4 = timeline; i6 = 4; } try { i6 = 4; i8 = -1; try { timeline4 = timeline; if (!this.queue.updateQueuedPeriods(timeline, this.rendererPositionUs, getMaxRendererReadPositionUs())) { seekToCurrentPosition(false); } } catch (Throwable th2) { th = th2; timeline4 = timeline; mediaPeriodId = mediaPeriodId2; j4 = j8; timeline2 = timeline4; PlaybackInfo playbackInfo = this.playbackInfo; updatePlaybackSpeedSettingsForNewPeriod(timeline2, mediaPeriodId, playbackInfo.timeline, playbackInfo.periodId, !positionUpdateForPlaylistChangeResolvePositionForPlaylistChange.setTargetLiveOffset ? jSeekToPeriodPosition : -9223372036854775807L, false); if (!z9 || j4 != this.playbackInfo.requestedContentPositionUs) { PlaybackInfo playbackInfo2 = this.playbackInfo; Object obj = playbackInfo2.periodId.periodUid; Timeline timeline5 = playbackInfo2.timeline; if (z9 || !z6 || timeline5.isEmpty() || timeline5.getPeriodByUid(obj, this.period).isPlaceholder) { j6 = j4; z7 = false; } else { j6 = j4; z7 = true; } this.playbackInfo = handlePositionDiscontinuity(mediaPeriodId, jSeekToPeriodPosition, j6, this.playbackInfo.discontinuityStartPositionUs, z7, timeline2.getIndexOfPeriod(obj) != i8 ? i6 : 3); } resetPendingPauseAtEndOfPeriod(); resolvePendingMessagePositions(timeline2, this.playbackInfo.timeline); this.playbackInfo = this.playbackInfo.copyWithTimeline(timeline2); if (!timeline2.isEmpty()) { this.pendingInitialSeekPosition = null; } handleLoadingMediaPeriodChanged(false); this.handler.sendEmptyMessage(2); throw th; } } catch (Throwable th3) { th = th3; timeline4 = timeline; i6 = 4; i8 = -1; mediaPeriodId = mediaPeriodId2; j4 = j8; timeline2 = timeline4; PlaybackInfo playbackInfo3 = this.playbackInfo; updatePlaybackSpeedSettingsForNewPeriod(timeline2, mediaPeriodId, playbackInfo3.timeline, playbackInfo3.periodId, !positionUpdateForPlaylistChangeResolvePositionForPlaylistChange.setTargetLiveOffset ? jSeekToPeriodPosition : -9223372036854775807L, false); if (!z9) { PlaybackInfo playbackInfo22 = this.playbackInfo; Object obj2 = playbackInfo22.periodId.periodUid; Timeline timeline52 = playbackInfo22.timeline; if (z9) { j6 = j4; z7 = false; this.playbackInfo = handlePositionDiscontinuity(mediaPeriodId, jSeekToPeriodPosition, j6, this.playbackInfo.discontinuityStartPositionUs, z7, timeline2.getIndexOfPeriod(obj2) != i8 ? i6 : 3); } } resetPendingPauseAtEndOfPeriod(); resolvePendingMessagePositions(timeline2, this.playbackInfo.timeline); this.playbackInfo = this.playbackInfo.copyWithTimeline(timeline2); if (!timeline2.isEmpty()) { } handleLoadingMediaPeriodChanged(false); this.handler.sendEmptyMessage(2); throw th; } } PlaybackInfo playbackInfo4 = this.playbackInfo; updatePlaybackSpeedSettingsForNewPeriod(timeline4, mediaPeriodId2, playbackInfo4.timeline, playbackInfo4.periodId, positionUpdateForPlaylistChangeResolvePositionForPlaylistChange.setTargetLiveOffset ? jSeekToPeriodPosition : -9223372036854775807L, false); if (z9 || j8 != this.playbackInfo.requestedContentPositionUs) { PlaybackInfo playbackInfo5 = this.playbackInfo; Object obj3 = playbackInfo5.periodId.periodUid; Timeline timeline6 = playbackInfo5.timeline; boolean z10 = z9 && z6 && !timeline6.isEmpty() && !timeline6.getPeriodByUid(obj3, this.period).isPlaceholder; long j9 = this.playbackInfo.discontinuityStartPositionUs; if (timeline4.getIndexOfPeriod(obj3) == i8) { j7 = j8; i7 = i6; } else { j7 = j8; i7 = 3; } timeline3 = timeline4; this.playbackInfo = handlePositionDiscontinuity(mediaPeriodId2, jSeekToPeriodPosition, j7, j9, z10, i7); } else { timeline3 = timeline4; } resetPendingPauseAtEndOfPeriod(); resolvePendingMessagePositions(timeline3, this.playbackInfo.timeline); this.playbackInfo = this.playbackInfo.copyWithTimeline(timeline3); if (!timeline3.isEmpty()) { this.pendingInitialSeekPosition = null; } handleLoadingMediaPeriodChanged(false); this.handler.sendEmptyMessage(2); } catch (Throwable th4) { th = th4; } } catch (Throwable th5) { th = th5; i6 = 4; mediaPeriodId = mediaPeriodId2; j4 = j8; i8 = -1; } } private void handlePeriodPrepared(MediaPeriod mediaPeriod) { if (this.queue.isLoading(mediaPeriod)) { MediaPeriodHolder loadingPeriod = this.queue.getLoadingPeriod(); loadingPeriod.handlePrepared(this.mediaClock.getPlaybackParameters().speed, this.playbackInfo.timeline); updateLoadControlTrackSelection(loadingPeriod.info.id, loadingPeriod.getTrackGroups(), loadingPeriod.getTrackSelectorResult()); if (loadingPeriod == this.queue.getPlayingPeriod()) { resetRendererPosition(loadingPeriod.info.startPositionUs); enableRenderers(); PlaybackInfo playbackInfo = this.playbackInfo; MediaSource.MediaPeriodId mediaPeriodId = playbackInfo.periodId; long j4 = loadingPeriod.info.startPositionUs; this.playbackInfo = handlePositionDiscontinuity(mediaPeriodId, j4, playbackInfo.requestedContentPositionUs, j4, false, 5); } maybeContinueLoading(); } } private void handlePlaybackParameters(PlaybackParameters playbackParameters, boolean z6) { handlePlaybackParameters(playbackParameters, playbackParameters.speed, true, z6); } private PlaybackInfo handlePositionDiscontinuity(MediaSource.MediaPeriodId mediaPeriodId, long j4, long j6, long j7, boolean z6, int i6) { List list; TrackGroupArray trackGroupArray; TrackSelectorResult trackSelectorResult; this.deliverPendingMessageAtStartPositionRequired = (!this.deliverPendingMessageAtStartPositionRequired && j4 == this.playbackInfo.positionUs && mediaPeriodId.equals(this.playbackInfo.periodId)) ? false : true; resetPendingPauseAtEndOfPeriod(); PlaybackInfo playbackInfo = this.playbackInfo; TrackGroupArray trackGroupArray2 = playbackInfo.trackGroups; TrackSelectorResult trackSelectorResult2 = playbackInfo.trackSelectorResult; List list2 = playbackInfo.staticMetadata; if (this.mediaSourceList.isPrepared()) { MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); TrackGroupArray trackGroups = playingPeriod == null ? TrackGroupArray.EMPTY : playingPeriod.getTrackGroups(); TrackSelectorResult trackSelectorResult3 = playingPeriod == null ? this.emptyTrackSelectorResult : playingPeriod.getTrackSelectorResult(); O oExtractMetadataFromTrackSelectionArray = extractMetadataFromTrackSelectionArray(trackSelectorResult3.selections); if (playingPeriod != null) { MediaPeriodInfo mediaPeriodInfo = playingPeriod.info; if (mediaPeriodInfo.requestedContentPositionUs != j6) { playingPeriod.info = mediaPeriodInfo.copyWithRequestedContentPositionUs(j6); } } maybeUpdateOffloadScheduling(); trackGroupArray = trackGroups; trackSelectorResult = trackSelectorResult3; list = oExtractMetadataFromTrackSelectionArray; } else { if (!mediaPeriodId.equals(this.playbackInfo.periodId)) { trackGroupArray2 = TrackGroupArray.EMPTY; trackSelectorResult2 = this.emptyTrackSelectorResult; M m6 = O.f1509b; list2 = p0.f1586e; } list = list2; trackGroupArray = trackGroupArray2; trackSelectorResult = trackSelectorResult2; } if (z6) { this.playbackInfoUpdate.setPositionDiscontinuity(i6); } return this.playbackInfo.copyWithNewPosition(mediaPeriodId, j4, j6, j7, getTotalBufferedDurationUs(), trackGroupArray, trackSelectorResult, list); } private boolean hasReachedServerSideInsertedAdsTransition(Renderer renderer, MediaPeriodHolder mediaPeriodHolder) { MediaPeriodHolder next = mediaPeriodHolder.getNext(); if (mediaPeriodHolder.info.isFollowedByTransitionToSameStream && next.prepared) { return (renderer instanceof TextRenderer) || (renderer instanceof MetadataRenderer) || renderer.getReadingPositionUs() >= next.getStartPositionRendererTime(); } return false; } private boolean hasReadingPeriodFinishedReading() { MediaPeriodHolder readingPeriod = this.queue.getReadingPeriod(); if (!readingPeriod.prepared) { return false; } int i6 = 0; while (true) { Renderer[] rendererArr = this.renderers; if (i6 >= rendererArr.length) { return true; } Renderer renderer = rendererArr[i6]; SampleStream sampleStream = readingPeriod.sampleStreams[i6]; if (renderer.getStream() != sampleStream || (sampleStream != null && !renderer.hasReadStreamToEnd() && !hasReachedServerSideInsertedAdsTransition(renderer, readingPeriod))) { break; } i6++; } return false; } private static boolean isIgnorableServerSideAdInsertionPeriodChange(boolean z6, MediaSource.MediaPeriodId mediaPeriodId, long j4, MediaSource.MediaPeriodId mediaPeriodId2, Timeline.Period period, long j6) { if (!z6 && j4 == j6 && mediaPeriodId.periodUid.equals(mediaPeriodId2.periodUid)) { if (mediaPeriodId.isAd() && period.isServerSideInsertedAdGroup(mediaPeriodId.adGroupIndex)) { return (period.getAdState(mediaPeriodId.adGroupIndex, mediaPeriodId.adIndexInAdGroup) == 4 || period.getAdState(mediaPeriodId.adGroupIndex, mediaPeriodId.adIndexInAdGroup) == 2) ? false : true; } if (mediaPeriodId2.isAd() && period.isServerSideInsertedAdGroup(mediaPeriodId2.adGroupIndex)) { return true; } } return false; } private boolean isLoadingPossible() { MediaPeriodHolder loadingPeriod = this.queue.getLoadingPeriod(); return (loadingPeriod == null || loadingPeriod.hasLoadingError() || loadingPeriod.getNextLoadPositionUs() == Long.MIN_VALUE) ? false : true; } private static boolean isRendererEnabled(Renderer renderer) { return renderer.getState() != 0; } private boolean isTimelineReady() { MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); long j4 = playingPeriod.info.durationUs; if (playingPeriod.prepared) { return j4 == androidx.media3.common.C.TIME_UNSET || this.playbackInfo.positionUs < j4 || !shouldPlayWhenReady(); } return false; } private static boolean isUsingPlaceholderPeriod(PlaybackInfo playbackInfo, Timeline.Period period) { MediaSource.MediaPeriodId mediaPeriodId = playbackInfo.periodId; Timeline timeline = playbackInfo.timeline; return timeline.isEmpty() || timeline.getPeriodByUid(mediaPeriodId.periodUid, period).isPlaceholder; } /* JADX INFO: Access modifiers changed from: private */ public /* synthetic */ Boolean lambda$release$0() { return Boolean.valueOf(this.released); } /* JADX INFO: Access modifiers changed from: private */ public /* synthetic */ void lambda$sendMessageToTargetThread$1(PlayerMessage playerMessage) { try { deliverMessage(playerMessage); } catch (ExoPlaybackException e6) { Log.e(TAG, "Unexpected error delivering message on external thread.", e6); throw new RuntimeException(e6); } } private void maybeContinueLoading() { boolean zShouldContinueLoading = shouldContinueLoading(); this.shouldContinueLoading = zShouldContinueLoading; if (zShouldContinueLoading) { this.queue.getLoadingPeriod().continueLoading(this.rendererPositionUs, this.mediaClock.getPlaybackParameters().speed, this.lastRebufferRealtimeMs); } updateIsLoading(); } private void maybeNotifyPlaybackInfoChanged() { this.playbackInfoUpdate.setPlaybackInfo(this.playbackInfo); if (this.playbackInfoUpdate.hasPendingChange) { this.playbackInfoUpdateListener.onPlaybackInfoUpdate(this.playbackInfoUpdate); this.playbackInfoUpdate = new PlaybackInfoUpdate(this.playbackInfo); } } /* JADX WARN: Code restructure failed: missing block: B:72:0x0079, code lost: r3 = null; */ /* Code decompiled incorrectly, please refer to instructions dump. */ private void maybeTriggerPendingMessages(long j4, long j6) { PendingMessageInfo pendingMessageInfo; if (this.pendingMessages.isEmpty() || this.playbackInfo.periodId.isAd()) { return; } if (this.deliverPendingMessageAtStartPositionRequired) { j4--; this.deliverPendingMessageAtStartPositionRequired = false; } PlaybackInfo playbackInfo = this.playbackInfo; int indexOfPeriod = playbackInfo.timeline.getIndexOfPeriod(playbackInfo.periodId.periodUid); int iMin = Math.min(this.nextPendingMessageIndexHint, this.pendingMessages.size()); PendingMessageInfo pendingMessageInfo2 = iMin > 0 ? this.pendingMessages.get(iMin - 1) : null; while (pendingMessageInfo2 != null) { int i6 = pendingMessageInfo2.resolvedPeriodIndex; if (i6 <= indexOfPeriod && (i6 != indexOfPeriod || pendingMessageInfo2.resolvedPeriodTimeUs <= j4)) { break; } int i7 = iMin - 1; pendingMessageInfo2 = i7 > 0 ? this.pendingMessages.get(iMin - 2) : null; iMin = i7; } if (iMin < this.pendingMessages.size()) { pendingMessageInfo = this.pendingMessages.get(iMin); while (pendingMessageInfo != null && pendingMessageInfo.resolvedPeriodUid != null) { int i8 = pendingMessageInfo.resolvedPeriodIndex; if (i8 >= indexOfPeriod && (i8 != indexOfPeriod || pendingMessageInfo.resolvedPeriodTimeUs > j4)) { break; } iMin++; if (iMin < this.pendingMessages.size()) { pendingMessageInfo = this.pendingMessages.get(iMin); } } while (pendingMessageInfo != null && pendingMessageInfo.resolvedPeriodUid != null && pendingMessageInfo.resolvedPeriodIndex == indexOfPeriod) { long j7 = pendingMessageInfo.resolvedPeriodTimeUs; if (j7 <= j4 || j7 > j6) { break; } try { sendMessageToTarget(pendingMessageInfo.message); if (pendingMessageInfo.message.getDeleteAfterDelivery() || pendingMessageInfo.message.isCanceled()) { this.pendingMessages.remove(iMin); } else { iMin++; } pendingMessageInfo = iMin < this.pendingMessages.size() ? this.pendingMessages.get(iMin) : null; } catch (Throwable th) { if (pendingMessageInfo.message.getDeleteAfterDelivery() || pendingMessageInfo.message.isCanceled()) { this.pendingMessages.remove(iMin); } throw th; } } this.nextPendingMessageIndexHint = iMin; return; } pendingMessageInfo = null; } private boolean maybeUpdateLoadingPeriod() { MediaPeriodInfo nextMediaPeriodInfo; this.queue.reevaluateBuffer(this.rendererPositionUs); boolean z6 = false; if (this.queue.shouldLoadNextMediaPeriod() && (nextMediaPeriodInfo = this.queue.getNextMediaPeriodInfo(this.rendererPositionUs, this.playbackInfo)) != null) { MediaPeriodHolder mediaPeriodHolderEnqueueNextMediaPeriodHolder = this.queue.enqueueNextMediaPeriodHolder(nextMediaPeriodInfo); mediaPeriodHolderEnqueueNextMediaPeriodHolder.mediaPeriod.prepare(this, nextMediaPeriodInfo.startPositionUs); if (this.queue.getPlayingPeriod() == mediaPeriodHolderEnqueueNextMediaPeriodHolder) { resetRendererPosition(nextMediaPeriodInfo.startPositionUs); } handleLoadingMediaPeriodChanged(false); z6 = true; } if (!this.shouldContinueLoading) { maybeContinueLoading(); return z6; } this.shouldContinueLoading = isLoadingPossible(); updateIsLoading(); return z6; } private void maybeUpdateOffloadScheduling() { boolean z6; MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); if (playingPeriod != null) { TrackSelectorResult trackSelectorResult = playingPeriod.getTrackSelectorResult(); boolean z7 = false; int i6 = 0; boolean z8 = false; while (true) { if (i6 >= this.renderers.length) { z6 = true; break; } if (trackSelectorResult.isRendererEnabled(i6)) { if (this.renderers[i6].getTrackType() != 1) { z6 = false; break; } else if (trackSelectorResult.rendererConfigurations[i6].offloadModePreferred != 0) { z8 = true; } } i6++; } if (z8 && z6) { z7 = true; } setOffloadSchedulingEnabled(z7); } } /* JADX WARN: Removed duplicated region for block: B:16:0x0045 */ /* Code decompiled incorrectly, please refer to instructions dump. */ private void maybeUpdatePlayingPeriod() { boolean z6; boolean z7 = false; while (shouldAdvancePlayingPeriod()) { if (z7) { maybeNotifyPlaybackInfoChanged(); } MediaPeriodHolder mediaPeriodHolder = (MediaPeriodHolder) Assertions.checkNotNull(this.queue.advancePlayingPeriod()); if (this.playbackInfo.periodId.periodUid.equals(mediaPeriodHolder.info.id.periodUid)) { MediaSource.MediaPeriodId mediaPeriodId = this.playbackInfo.periodId; if (mediaPeriodId.adGroupIndex == -1) { MediaSource.MediaPeriodId mediaPeriodId2 = mediaPeriodHolder.info.id; z6 = mediaPeriodId2.adGroupIndex == -1 && mediaPeriodId.nextAdGroupIndex != mediaPeriodId2.nextAdGroupIndex; } } MediaPeriodInfo mediaPeriodInfo = mediaPeriodHolder.info; MediaSource.MediaPeriodId mediaPeriodId3 = mediaPeriodInfo.id; long j4 = mediaPeriodInfo.startPositionUs; this.playbackInfo = handlePositionDiscontinuity(mediaPeriodId3, j4, mediaPeriodInfo.requestedContentPositionUs, j4, !z6, 0); resetPendingPauseAtEndOfPeriod(); updatePlaybackPositions(); if (this.playbackInfo.playbackState == 3) { startRenderers(); } allowRenderersToRenderStartOfStreams(); z7 = true; } } private void maybeUpdatePreloadPeriods(boolean z6) { if (this.preloadConfiguration.targetPreloadDurationUs != androidx.media3.common.C.TIME_UNSET) { if (z6 || !this.playbackInfo.timeline.equals(this.lastPreloadPoolInvalidationTimeline)) { Timeline timeline = this.playbackInfo.timeline; this.lastPreloadPoolInvalidationTimeline = timeline; this.queue.invalidatePreloadPool(timeline); } } } private void maybeUpdateReadingPeriod() { MediaPeriodHolder readingPeriod = this.queue.getReadingPeriod(); if (readingPeriod == null) { return; } int i6 = 0; if (readingPeriod.getNext() != null && !this.pendingPauseAtEndOfPeriod) { if (hasReadingPeriodFinishedReading()) { if (readingPeriod.getNext().prepared || this.rendererPositionUs >= readingPeriod.getNext().getStartPositionRendererTime()) { TrackSelectorResult trackSelectorResult = readingPeriod.getTrackSelectorResult(); MediaPeriodHolder mediaPeriodHolderAdvanceReadingPeriod = this.queue.advanceReadingPeriod(); TrackSelectorResult trackSelectorResult2 = mediaPeriodHolderAdvanceReadingPeriod.getTrackSelectorResult(); Timeline timeline = this.playbackInfo.timeline; updatePlaybackSpeedSettingsForNewPeriod(timeline, mediaPeriodHolderAdvanceReadingPeriod.info.id, timeline, readingPeriod.info.id, androidx.media3.common.C.TIME_UNSET, false); if (mediaPeriodHolderAdvanceReadingPeriod.prepared && mediaPeriodHolderAdvanceReadingPeriod.mediaPeriod.readDiscontinuity() != androidx.media3.common.C.TIME_UNSET) { setAllRendererStreamsFinal(mediaPeriodHolderAdvanceReadingPeriod.getStartPositionRendererTime()); if (mediaPeriodHolderAdvanceReadingPeriod.isFullyBuffered()) { return; } this.queue.removeAfter(mediaPeriodHolderAdvanceReadingPeriod); handleLoadingMediaPeriodChanged(false); maybeContinueLoading(); return; } for (int i7 = 0; i7 < this.renderers.length; i7++) { boolean zIsRendererEnabled = trackSelectorResult.isRendererEnabled(i7); boolean zIsRendererEnabled2 = trackSelectorResult2.isRendererEnabled(i7); if (zIsRendererEnabled && !this.renderers[i7].isCurrentStreamFinal()) { boolean z6 = this.rendererCapabilities[i7].getTrackType() == -2; RendererConfiguration rendererConfiguration = trackSelectorResult.rendererConfigurations[i7]; RendererConfiguration rendererConfiguration2 = trackSelectorResult2.rendererConfigurations[i7]; if (!zIsRendererEnabled2 || !rendererConfiguration2.equals(rendererConfiguration) || z6) { setCurrentStreamFinal(this.renderers[i7], mediaPeriodHolderAdvanceReadingPeriod.getStartPositionRendererTime()); } } } return; } return; } return; } if (!readingPeriod.info.isFinal && !this.pendingPauseAtEndOfPeriod) { return; } while (true) { Renderer[] rendererArr = this.renderers; if (i6 >= rendererArr.length) { return; } Renderer renderer = rendererArr[i6]; SampleStream sampleStream = readingPeriod.sampleStreams[i6]; if (sampleStream != null && renderer.getStream() == sampleStream && renderer.hasReadStreamToEnd()) { long j4 = readingPeriod.info.durationUs; setCurrentStreamFinal(renderer, (j4 == androidx.media3.common.C.TIME_UNSET || j4 == Long.MIN_VALUE) ? -9223372036854775807L : readingPeriod.getRendererOffset() + readingPeriod.info.durationUs); } i6++; } } private void maybeUpdateReadingRenderers() { MediaPeriodHolder readingPeriod = this.queue.getReadingPeriod(); if (readingPeriod == null || this.queue.getPlayingPeriod() == readingPeriod || readingPeriod.allRenderersInCorrectState || !replaceStreamsOrDisableRendererForTransition()) { return; } enableRenderers(); } private void mediaSourceListUpdateRequestedInternal() throws Throwable { handleMediaSourceListInfoRefreshed(this.mediaSourceList.createTimeline(), true); } private void moveMediaItemsInternal(MoveMediaItemsMessage moveMediaItemsMessage) throws Throwable { this.playbackInfoUpdate.incrementPendingOperationAcks(1); handleMediaSourceListInfoRefreshed(this.mediaSourceList.moveMediaSourceRange(moveMediaItemsMessage.fromIndex, moveMediaItemsMessage.toIndex, moveMediaItemsMessage.newFromIndex, moveMediaItemsMessage.shuffleOrder), false); } private void notifyTrackSelectionDiscontinuity() { for (MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); playingPeriod != null; playingPeriod = playingPeriod.getNext()) { for (ExoTrackSelection exoTrackSelection : playingPeriod.getTrackSelectorResult().selections) { if (exoTrackSelection != null) { exoTrackSelection.onDiscontinuity(); } } } } private void notifyTrackSelectionPlayWhenReadyChanged(boolean z6) { for (MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); playingPeriod != null; playingPeriod = playingPeriod.getNext()) { for (ExoTrackSelection exoTrackSelection : playingPeriod.getTrackSelectorResult().selections) { if (exoTrackSelection != null) { exoTrackSelection.onPlayWhenReadyChanged(z6); } } } } private void notifyTrackSelectionRebuffer() { for (MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); playingPeriod != null; playingPeriod = playingPeriod.getNext()) { for (ExoTrackSelection exoTrackSelection : playingPeriod.getTrackSelectorResult().selections) { if (exoTrackSelection != null) { exoTrackSelection.onRebuffer(); } } } } private void prepareInternal() { this.playbackInfoUpdate.incrementPendingOperationAcks(1); resetInternal(false, false, false, true); this.loadControl.onPrepared(this.playerId); setState(this.playbackInfo.timeline.isEmpty() ? 4 : 2); this.mediaSourceList.prepare(this.bandwidthMeter.getTransferListener()); this.handler.sendEmptyMessage(2); } private void releaseInternal() { try { resetInternal(true, false, true, false); releaseRenderers(); this.loadControl.onReleased(this.playerId); setState(1); HandlerThread handlerThread = this.internalPlaybackThread; if (handlerThread != null) { handlerThread.quit(); } synchronized (this) { this.released = true; notifyAll(); } } catch (Throwable th) { HandlerThread handlerThread2 = this.internalPlaybackThread; if (handlerThread2 != null) { handlerThread2.quit(); } synchronized (this) { this.released = true; notifyAll(); throw th; } } } private void releaseRenderers() { for (int i6 = 0; i6 < this.renderers.length; i6++) { this.rendererCapabilities[i6].clearListener(); this.renderers[i6].release(); } } private void removeMediaItemsInternal(int i6, int i7, ShuffleOrder shuffleOrder) throws Throwable { this.playbackInfoUpdate.incrementPendingOperationAcks(1); handleMediaSourceListInfoRefreshed(this.mediaSourceList.removeMediaSourceRange(i6, i7, shuffleOrder), false); } private boolean replaceStreamsOrDisableRendererForTransition() { MediaPeriodHolder readingPeriod = this.queue.getReadingPeriod(); TrackSelectorResult trackSelectorResult = readingPeriod.getTrackSelectorResult(); int i6 = 0; boolean z6 = false; while (true) { Renderer[] rendererArr = this.renderers; if (i6 >= rendererArr.length) { return !z6; } Renderer renderer = rendererArr[i6]; if (isRendererEnabled(renderer)) { boolean z7 = renderer.getStream() != readingPeriod.sampleStreams[i6]; if (!trackSelectorResult.isRendererEnabled(i6) || z7) { if (!renderer.isCurrentStreamFinal()) { renderer.replaceStream(getFormats(trackSelectorResult.selections[i6]), readingPeriod.sampleStreams[i6], readingPeriod.getStartPositionRendererTime(), readingPeriod.getRendererOffset(), readingPeriod.info.id); if (this.offloadSchedulingEnabled) { setOffloadSchedulingEnabled(false); } } else if (renderer.isEnded()) { disableRenderer(renderer); } else { z6 = true; } } } i6++; } } private void reselectTracksInternal() { float f6 = this.mediaClock.getPlaybackParameters().speed; MediaPeriodHolder readingPeriod = this.queue.getReadingPeriod(); TrackSelectorResult trackSelectorResult = null; boolean z6 = true; for (MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); playingPeriod != null && playingPeriod.prepared; playingPeriod = playingPeriod.getNext()) { TrackSelectorResult trackSelectorResultSelectTracks = playingPeriod.selectTracks(f6, this.playbackInfo.timeline); if (playingPeriod == this.queue.getPlayingPeriod()) { trackSelectorResult = trackSelectorResultSelectTracks; } int i6 = 0; if (!trackSelectorResultSelectTracks.isEquivalent(playingPeriod.getTrackSelectorResult())) { if (z6) { MediaPeriodHolder playingPeriod2 = this.queue.getPlayingPeriod(); boolean zRemoveAfter = this.queue.removeAfter(playingPeriod2); boolean[] zArr = new boolean[this.renderers.length]; long jApplyTrackSelection = playingPeriod2.applyTrackSelection((TrackSelectorResult) Assertions.checkNotNull(trackSelectorResult), this.playbackInfo.positionUs, zRemoveAfter, zArr); PlaybackInfo playbackInfo = this.playbackInfo; boolean z7 = (playbackInfo.playbackState == 4 || jApplyTrackSelection == playbackInfo.positionUs) ? false : true; PlaybackInfo playbackInfo2 = this.playbackInfo; this.playbackInfo = handlePositionDiscontinuity(playbackInfo2.periodId, jApplyTrackSelection, playbackInfo2.requestedContentPositionUs, playbackInfo2.discontinuityStartPositionUs, z7, 5); if (z7) { resetRendererPosition(jApplyTrackSelection); } boolean[] zArr2 = new boolean[this.renderers.length]; while (true) { Renderer[] rendererArr = this.renderers; if (i6 >= rendererArr.length) { break; } Renderer renderer = rendererArr[i6]; boolean zIsRendererEnabled = isRendererEnabled(renderer); zArr2[i6] = zIsRendererEnabled; SampleStream sampleStream = playingPeriod2.sampleStreams[i6]; if (zIsRendererEnabled) { if (sampleStream != renderer.getStream()) { disableRenderer(renderer); } else if (zArr[i6]) { renderer.resetPosition(this.rendererPositionUs); } } i6++; } enableRenderers(zArr2, this.rendererPositionUs); } else { this.queue.removeAfter(playingPeriod); if (playingPeriod.prepared) { playingPeriod.applyTrackSelection(trackSelectorResultSelectTracks, Math.max(playingPeriod.info.startPositionUs, playingPeriod.toPeriodTime(this.rendererPositionUs)), false); } } handleLoadingMediaPeriodChanged(true); if (this.playbackInfo.playbackState != 4) { maybeContinueLoading(); updatePlaybackPositions(); this.handler.sendEmptyMessage(2); return; } return; } if (playingPeriod == readingPeriod) { z6 = false; } } } private void reselectTracksInternalAndSeek() { reselectTracksInternal(); seekToCurrentPosition(true); } /* JADX WARN: Removed duplicated region for block: B:34:0x00a2 A[PHI: r5 r6 r8 0x00a2: PHI (r5v3 androidx.media3.exoplayer.source.MediaSource$MediaPeriodId) = (r5v2 androidx.media3.exoplayer.source.MediaSource$MediaPeriodId) (r5v6 androidx.media3.exoplayer.source.MediaSource$MediaPeriodId) binds: [B:30:0x0078, B:32:0x009d] A[DONT_GENERATE, DONT_INLINE] 0x00a2: PHI (r6v2 long) = (r6v1 long), (r6v9 long) binds: [B:30:0x0078, B:32:0x009d] A[DONT_GENERATE, DONT_INLINE] 0x00a2: PHI (r8v3 long) = (r8v2 long), (r8v8 long) binds: [B:30:0x0078, B:32:0x009d] A[DONT_GENERATE, DONT_INLINE]] */ /* JADX WARN: Removed duplicated region for block: B:44:0x00e9 A[PHI: r0 0x00e9: PHI (r0v10 androidx.media3.common.Timeline) = (r0v9 androidx.media3.common.Timeline) (r0v9 androidx.media3.common.Timeline) (r0v16 androidx.media3.common.Timeline) (r0v16 androidx.media3.common.Timeline) binds: [B:36:0x00af, B:38:0x00b3, B:40:0x00c4, B:42:0x00db] A[DONT_GENERATE, DONT_INLINE]] */ /* Code decompiled incorrectly, please refer to instructions dump. */ private void resetInternal(boolean z6, boolean z7, boolean z8, boolean z9) { boolean z10; Timeline timeline; MediaSource.MediaPeriodId mediaPeriodId; List list; this.handler.removeMessages(2); this.pendingRecoverableRendererError = null; updateRebufferingState(false, true); this.mediaClock.stop(); this.rendererPositionUs = MediaPeriodQueue.INITIAL_RENDERER_POSITION_OFFSET_US; for (Renderer renderer : this.renderers) { try { disableRenderer(renderer); } catch (ExoPlaybackException | RuntimeException e6) { Log.e(TAG, "Disable failed.", e6); } } if (z6) { for (Renderer renderer2 : this.renderers) { if (this.renderersToReset.remove(renderer2)) { try { renderer2.reset(); } catch (RuntimeException e7) { Log.e(TAG, "Reset failed.", e7); } } } } this.enabledRendererCount = 0; PlaybackInfo playbackInfo = this.playbackInfo; MediaSource.MediaPeriodId mediaPeriodId2 = playbackInfo.periodId; long jLongValue = playbackInfo.positionUs; long j4 = (this.playbackInfo.periodId.isAd() || isUsingPlaceholderPeriod(this.playbackInfo, this.period)) ? this.playbackInfo.requestedContentPositionUs : this.playbackInfo.positionUs; if (z7) { this.pendingInitialSeekPosition = null; Pair placeholderFirstMediaPeriodPositionUs = getPlaceholderFirstMediaPeriodPositionUs(this.playbackInfo.timeline); mediaPeriodId2 = (MediaSource.MediaPeriodId) placeholderFirstMediaPeriodPositionUs.first; jLongValue = ((Long) placeholderFirstMediaPeriodPositionUs.second).longValue(); boolean zEquals = mediaPeriodId2.equals(this.playbackInfo.periodId); j4 = androidx.media3.common.C.TIME_UNSET; z10 = zEquals ? false : true; } long j6 = jLongValue; long j7 = j4; this.queue.clear(); this.shouldContinueLoading = false; Timeline timelineCopyWithPlaceholderTimeline = this.playbackInfo.timeline; if (z8 && (timelineCopyWithPlaceholderTimeline instanceof PlaylistTimeline)) { timelineCopyWithPlaceholderTimeline = ((PlaylistTimeline) timelineCopyWithPlaceholderTimeline).copyWithPlaceholderTimeline(this.mediaSourceList.getShuffleOrder()); if (mediaPeriodId2.adGroupIndex != -1) { timelineCopyWithPlaceholderTimeline.getPeriodByUid(mediaPeriodId2.periodUid, this.period); if (timelineCopyWithPlaceholderTimeline.getWindow(this.period.windowIndex, this.window).isLive()) { timeline = timelineCopyWithPlaceholderTimeline; mediaPeriodId = new MediaSource.MediaPeriodId(mediaPeriodId2.periodUid, mediaPeriodId2.windowSequenceNumber); } } } else { timeline = timelineCopyWithPlaceholderTimeline; mediaPeriodId = mediaPeriodId2; } PlaybackInfo playbackInfo2 = this.playbackInfo; int i6 = playbackInfo2.playbackState; ExoPlaybackException exoPlaybackException = z9 ? null : playbackInfo2.playbackError; TrackGroupArray trackGroupArray = z10 ? TrackGroupArray.EMPTY : playbackInfo2.trackGroups; TrackSelectorResult trackSelectorResult = z10 ? this.emptyTrackSelectorResult : playbackInfo2.trackSelectorResult; if (z10) { M m6 = O.f1509b; list = p0.f1586e; } else { list = playbackInfo2.staticMetadata; } this.playbackInfo = new PlaybackInfo(timeline, mediaPeriodId, j7, j6, i6, exoPlaybackException, false, trackGroupArray, trackSelectorResult, list, mediaPeriodId, playbackInfo2.playWhenReady, playbackInfo2.playWhenReadyChangeReason, playbackInfo2.playbackSuppressionReason, playbackInfo2.playbackParameters, j6, 0L, j6, 0L, false); if (z8) { this.queue.releasePreloadPool(); this.mediaSourceList.release(); } } private void resetPendingPauseAtEndOfPeriod() { MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); this.pendingPauseAtEndOfPeriod = playingPeriod != null && playingPeriod.info.isLastInTimelineWindow && this.pauseAtEndOfWindow; } private void resetRendererPosition(long j4) { MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); long rendererTime = playingPeriod == null ? j4 + MediaPeriodQueue.INITIAL_RENDERER_POSITION_OFFSET_US : playingPeriod.toRendererTime(j4); this.rendererPositionUs = rendererTime; this.mediaClock.resetPosition(rendererTime); for (Renderer renderer : this.renderers) { if (isRendererEnabled(renderer)) { renderer.resetPosition(this.rendererPositionUs); } } notifyTrackSelectionDiscontinuity(); } private static void resolvePendingMessageEndOfStreamPosition(Timeline timeline, PendingMessageInfo pendingMessageInfo, Timeline.Window window, Timeline.Period period) { int i6 = timeline.getWindow(timeline.getPeriodByUid(pendingMessageInfo.resolvedPeriodUid, period).windowIndex, window).lastPeriodIndex; Object obj = timeline.getPeriod(i6, period, true).uid; long j4 = period.durationUs; pendingMessageInfo.setResolvedPosition(i6, j4 != androidx.media3.common.C.TIME_UNSET ? j4 - 1 : Long.MAX_VALUE, obj); } private static boolean resolvePendingMessagePosition(PendingMessageInfo pendingMessageInfo, Timeline timeline, Timeline timeline2, int i6, boolean z6, Timeline.Window window, Timeline.Period period) { Object obj = pendingMessageInfo.resolvedPeriodUid; if (obj == null) { Pair pairResolveSeekPositionUs = resolveSeekPositionUs(timeline, new SeekPosition(pendingMessageInfo.message.getTimeline(), pendingMessageInfo.message.getMediaItemIndex(), pendingMessageInfo.message.getPositionMs() == Long.MIN_VALUE ? androidx.media3.common.C.TIME_UNSET : Util.msToUs(pendingMessageInfo.message.getPositionMs())), false, i6, z6, window, period); if (pairResolveSeekPositionUs == null) { return false; } pendingMessageInfo.setResolvedPosition(timeline.getIndexOfPeriod(pairResolveSeekPositionUs.first), ((Long) pairResolveSeekPositionUs.second).longValue(), pairResolveSeekPositionUs.first); if (pendingMessageInfo.message.getPositionMs() == Long.MIN_VALUE) { resolvePendingMessageEndOfStreamPosition(timeline, pendingMessageInfo, window, period); } return true; } int indexOfPeriod = timeline.getIndexOfPeriod(obj); if (indexOfPeriod == -1) { return false; } if (pendingMessageInfo.message.getPositionMs() == Long.MIN_VALUE) { resolvePendingMessageEndOfStreamPosition(timeline, pendingMessageInfo, window, period); return true; } pendingMessageInfo.resolvedPeriodIndex = indexOfPeriod; timeline2.getPeriodByUid(pendingMessageInfo.resolvedPeriodUid, period); if (period.isPlaceholder && timeline2.getWindow(period.windowIndex, window).firstPeriodIndex == timeline2.getIndexOfPeriod(pendingMessageInfo.resolvedPeriodUid)) { Pair periodPositionUs = timeline.getPeriodPositionUs(window, period, timeline.getPeriodByUid(pendingMessageInfo.resolvedPeriodUid, period).windowIndex, period.getPositionInWindowUs() + pendingMessageInfo.resolvedPeriodTimeUs); pendingMessageInfo.setResolvedPosition(timeline.getIndexOfPeriod(periodPositionUs.first), ((Long) periodPositionUs.second).longValue(), periodPositionUs.first); } return true; } private void resolvePendingMessagePositions(Timeline timeline, Timeline timeline2) { if (timeline.isEmpty() && timeline2.isEmpty()) { return; } int size = this.pendingMessages.size() - 1; while (size >= 0) { Timeline timeline3 = timeline; Timeline timeline4 = timeline2; if (!resolvePendingMessagePosition(this.pendingMessages.get(size), timeline3, timeline4, this.repeatMode, this.shuffleModeEnabled, this.window, this.period)) { this.pendingMessages.get(size).message.markAsProcessed(false); this.pendingMessages.remove(size); } size--; timeline = timeline3; timeline2 = timeline4; } Collections.sort(this.pendingMessages); } private static PositionUpdateForPlaylistChange resolvePositionForPlaylistChange(Timeline timeline, PlaybackInfo playbackInfo, SeekPosition seekPosition, MediaPeriodQueue mediaPeriodQueue, int i6, boolean z6, Timeline.Window window, Timeline.Period period) { int i7; long j4; long adResumePositionUs; int firstWindowIndex; long jLongValue; boolean z7; boolean z8; boolean z9; int firstWindowIndex2; boolean z10; Timeline timeline2; Timeline.Period period2; long j6; int i8; long jLongValue2; int firstWindowIndex3; boolean z11; boolean z12; boolean z13; if (timeline.isEmpty()) { return new PositionUpdateForPlaylistChange(PlaybackInfo.getDummyPeriodForEmptyTimeline(), 0L, androidx.media3.common.C.TIME_UNSET, false, true, false); } MediaSource.MediaPeriodId mediaPeriodId = playbackInfo.periodId; Object obj = mediaPeriodId.periodUid; boolean zIsUsingPlaceholderPeriod = isUsingPlaceholderPeriod(playbackInfo, period); long j7 = (playbackInfo.periodId.isAd() || zIsUsingPlaceholderPeriod) ? playbackInfo.requestedContentPositionUs : playbackInfo.positionUs; if (seekPosition != null) { i7 = -1; j4 = androidx.media3.common.C.TIME_UNSET; Pair pairResolveSeekPositionUs = resolveSeekPositionUs(timeline, seekPosition, true, i6, z6, window, period); if (pairResolveSeekPositionUs == null) { firstWindowIndex3 = timeline.getFirstWindowIndex(z6); jLongValue2 = j7; z11 = false; z12 = false; z13 = true; } else { if (seekPosition.windowPositionUs == androidx.media3.common.C.TIME_UNSET) { firstWindowIndex3 = timeline.getPeriodByUid(pairResolveSeekPositionUs.first, period).windowIndex; jLongValue2 = j7; z11 = false; } else { obj = pairResolveSeekPositionUs.first; jLongValue2 = ((Long) pairResolveSeekPositionUs.second).longValue(); firstWindowIndex3 = -1; z11 = true; } z12 = playbackInfo.playbackState == 4; z13 = false; } firstWindowIndex = firstWindowIndex3; adResumePositionUs = jLongValue2; z9 = z11; z7 = z12; z8 = z13; } else { i7 = -1; j4 = androidx.media3.common.C.TIME_UNSET; if (playbackInfo.timeline.isEmpty()) { firstWindowIndex = timeline.getFirstWindowIndex(z6); } else if (timeline.getIndexOfPeriod(obj) == -1) { int iResolveSubsequentPeriod = resolveSubsequentPeriod(window, period, i6, z6, obj, playbackInfo.timeline, timeline); if (iResolveSubsequentPeriod == -1) { firstWindowIndex2 = timeline.getFirstWindowIndex(z6); z10 = true; } else { firstWindowIndex2 = iResolveSubsequentPeriod; z10 = false; } firstWindowIndex = firstWindowIndex2; obj = obj; adResumePositionUs = j7; z8 = z10; z7 = false; z9 = false; } else if (j7 == androidx.media3.common.C.TIME_UNSET) { firstWindowIndex = timeline.getPeriodByUid(obj, period).windowIndex; obj = obj; } else if (zIsUsingPlaceholderPeriod) { playbackInfo.timeline.getPeriodByUid(mediaPeriodId.periodUid, period); if (playbackInfo.timeline.getWindow(period.windowIndex, window).firstPeriodIndex == playbackInfo.timeline.getIndexOfPeriod(mediaPeriodId.periodUid)) { Pair periodPositionUs = timeline.getPeriodPositionUs(window, period, timeline.getPeriodByUid(obj, period).windowIndex, period.getPositionInWindowUs() + j7); obj = periodPositionUs.first; jLongValue = ((Long) periodPositionUs.second).longValue(); } else { obj = obj; jLongValue = j7; } adResumePositionUs = jLongValue; firstWindowIndex = -1; z7 = false; z8 = false; z9 = true; } else { obj = obj; adResumePositionUs = j7; firstWindowIndex = -1; z7 = false; z8 = false; z9 = false; } adResumePositionUs = j7; z7 = false; z8 = false; z9 = false; } if (firstWindowIndex != i7) { period2 = period; Pair periodPositionUs2 = timeline.getPeriodPositionUs(window, period2, firstWindowIndex, androidx.media3.common.C.TIME_UNSET); timeline2 = timeline; obj = periodPositionUs2.first; adResumePositionUs = ((Long) periodPositionUs2.second).longValue(); j6 = j4; } else { timeline2 = timeline; period2 = period; j6 = adResumePositionUs; } MediaSource.MediaPeriodId mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange = mediaPeriodQueue.resolveMediaPeriodIdForAdsAfterPeriodPositionChange(timeline2, obj, adResumePositionUs); int i9 = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.nextAdGroupIndex; boolean z14 = mediaPeriodId.periodUid.equals(obj) && !mediaPeriodId.isAd() && !mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.isAd() && (i9 == i7 || ((i8 = mediaPeriodId.nextAdGroupIndex) != i7 && i9 >= i8)); long j8 = j6; MediaSource.MediaPeriodId mediaPeriodId2 = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange; boolean zIsIgnorableServerSideAdInsertionPeriodChange = isIgnorableServerSideAdInsertionPeriodChange(zIsUsingPlaceholderPeriod, mediaPeriodId, j7, mediaPeriodId2, timeline2.getPeriodByUid(obj, period2), j8); if (z14 || zIsIgnorableServerSideAdInsertionPeriodChange) { mediaPeriodId2 = mediaPeriodId; } if (mediaPeriodId2.isAd()) { if (mediaPeriodId2.equals(mediaPeriodId)) { adResumePositionUs = playbackInfo.positionUs; } else { timeline2.getPeriodByUid(mediaPeriodId2.periodUid, period2); adResumePositionUs = mediaPeriodId2.adIndexInAdGroup == period2.getFirstAdIndexToPlay(mediaPeriodId2.adGroupIndex) ? period2.getAdResumePositionUs() : 0L; } } return new PositionUpdateForPlaylistChange(mediaPeriodId2, adResumePositionUs, j8, z7, z8, z9); } private static Pair resolveSeekPositionUs(Timeline timeline, SeekPosition seekPosition, boolean z6, int i6, boolean z7, Timeline.Window window, Timeline.Period period) { Pair periodPositionUs; Timeline timeline2; int iResolveSubsequentPeriod; Timeline timeline3 = seekPosition.timeline; if (timeline.isEmpty()) { return null; } boolean zIsEmpty = timeline3.isEmpty(); Timeline timeline4 = timeline3; if (zIsEmpty) { timeline4 = timeline; } try { periodPositionUs = timeline4.getPeriodPositionUs(window, period, seekPosition.windowIndex, seekPosition.windowPositionUs); timeline2 = timeline4; } catch (IndexOutOfBoundsException unused) { } if (timeline.equals(timeline2)) { return periodPositionUs; } if (timeline.getIndexOfPeriod(periodPositionUs.first) != -1) { return (timeline2.getPeriodByUid(periodPositionUs.first, period).isPlaceholder && timeline2.getWindow(period.windowIndex, window).firstPeriodIndex == timeline2.getIndexOfPeriod(periodPositionUs.first)) ? timeline.getPeriodPositionUs(window, period, timeline.getPeriodByUid(periodPositionUs.first, period).windowIndex, seekPosition.windowPositionUs) : periodPositionUs; } if (z6 && (iResolveSubsequentPeriod = resolveSubsequentPeriod(window, period, i6, z7, periodPositionUs.first, timeline2, timeline)) != -1) { return timeline.getPeriodPositionUs(window, period, iResolveSubsequentPeriod, androidx.media3.common.C.TIME_UNSET); } return null; } public static int resolveSubsequentPeriod(Timeline.Window window, Timeline.Period period, int i6, boolean z6, Object obj, Timeline timeline, Timeline timeline2) { Timeline.Period period2; Object obj2 = timeline.getWindow(timeline.getPeriodByUid(obj, period).windowIndex, window).uid; int i7 = 0; for (int i8 = 0; i8 < timeline2.getWindowCount(); i8++) { if (timeline2.getWindow(i8, window).uid.equals(obj2)) { return i8; } } int indexOfPeriod = timeline.getIndexOfPeriod(obj); int periodCount = timeline.getPeriodCount(); int nextPeriodIndex = indexOfPeriod; int indexOfPeriod2 = -1; while (i7 < periodCount && indexOfPeriod2 == -1) { Timeline.Window window2 = window; period2 = period; int i9 = i6; boolean z7 = z6; Timeline timeline3 = timeline; nextPeriodIndex = timeline3.getNextPeriodIndex(nextPeriodIndex, period2, window2, i9, z7); if (nextPeriodIndex == -1) { break; } indexOfPeriod2 = timeline2.getIndexOfPeriod(timeline3.getUidOfPeriod(nextPeriodIndex)); i7++; timeline = timeline3; period = period2; window = window2; i6 = i9; z6 = z7; } period2 = period; if (indexOfPeriod2 == -1) { return -1; } return timeline2.getPeriod(indexOfPeriod2, period2).windowIndex; } private void scheduleNextWork(long j4) { long jMin = (this.playbackInfo.playbackState != 3 || (!this.dynamicSchedulingEnabled && shouldPlayWhenReady())) ? BUFFERING_MAXIMUM_INTERVAL_MS : 1000L; if (this.dynamicSchedulingEnabled && shouldPlayWhenReady()) { for (Renderer renderer : this.renderers) { if (isRendererEnabled(renderer)) { jMin = Math.min(jMin, Util.usToMs(renderer.getDurationToProgressUs(this.rendererPositionUs, this.rendererPositionElapsedRealtimeUs))); } } } this.handler.sendEmptyMessageAtTime(2, j4 + jMin); } private void seekToCurrentPosition(boolean z6) { MediaSource.MediaPeriodId mediaPeriodId = this.queue.getPlayingPeriod().info.id; long jSeekToPeriodPosition = seekToPeriodPosition(mediaPeriodId, this.playbackInfo.positionUs, true, false); if (jSeekToPeriodPosition != this.playbackInfo.positionUs) { PlaybackInfo playbackInfo = this.playbackInfo; this.playbackInfo = handlePositionDiscontinuity(mediaPeriodId, jSeekToPeriodPosition, playbackInfo.requestedContentPositionUs, playbackInfo.discontinuityStartPositionUs, z6, 5); } } /* JADX WARN: Removed duplicated region for block: B:24:0x00a1 A[Catch: all -> 0x00a4, TryCatch #1 {all -> 0x00a4, blocks: (B:22:0x0097, B:24:0x00a1, B:30:0x00ad, B:32:0x00b3, B:33:0x00b6, B:35:0x00be, B:39:0x00d0, B:43:0x00d8), top: B:91:0x0097 }] */ /* JADX WARN: Removed duplicated region for block: B:28:0x00aa */ /* Code decompiled incorrectly, please refer to instructions dump. */ private void seekToInternal(SeekPosition seekPosition) throws Throwable { long jLongValue; MediaSource.MediaPeriodId mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange; long j4; boolean z6; long j6; boolean z7; MediaSource.MediaPeriodId mediaPeriodId; long j7; MediaSource.MediaPeriodId mediaPeriodId2; long adjustedSeekPositionUs; PlaybackInfo playbackInfo; int i6; int i7; long j8; MediaSource.MediaPeriodId mediaPeriodId3; long j9; long jSeekToPeriodPosition; PlaybackInfo playbackInfo2; Timeline timeline; MediaSource.MediaPeriodId mediaPeriodId4; long j10; ExoPlayerImplInternal exoPlayerImplInternal = this; exoPlayerImplInternal.playbackInfoUpdate.incrementPendingOperationAcks(1); Pair pairResolveSeekPositionUs = resolveSeekPositionUs(exoPlayerImplInternal.playbackInfo.timeline, seekPosition, true, exoPlayerImplInternal.repeatMode, exoPlayerImplInternal.shuffleModeEnabled, exoPlayerImplInternal.window, exoPlayerImplInternal.period); try { if (pairResolveSeekPositionUs == null) { Pair placeholderFirstMediaPeriodPositionUs = exoPlayerImplInternal.getPlaceholderFirstMediaPeriodPositionUs(exoPlayerImplInternal.playbackInfo.timeline); mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange = (MediaSource.MediaPeriodId) placeholderFirstMediaPeriodPositionUs.first; jLongValue = ((Long) placeholderFirstMediaPeriodPositionUs.second).longValue(); z6 = !exoPlayerImplInternal.playbackInfo.timeline.isEmpty(); j6 = -9223372036854775807L; } else { Object obj = pairResolveSeekPositionUs.first; jLongValue = ((Long) pairResolveSeekPositionUs.second).longValue(); long j11 = seekPosition.windowPositionUs == androidx.media3.common.C.TIME_UNSET ? -9223372036854775807L : jLongValue; mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange = exoPlayerImplInternal.queue.resolveMediaPeriodIdForAdsAfterPeriodPositionChange(exoPlayerImplInternal.playbackInfo.timeline, obj, jLongValue); if (!mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.isAd()) { j4 = 0; z6 = seekPosition.windowPositionUs == androidx.media3.common.C.TIME_UNSET; j6 = j11; if (!exoPlayerImplInternal.playbackInfo.timeline.isEmpty()) { exoPlayerImplInternal.pendingInitialSeekPosition = seekPosition; } else if (pairResolveSeekPositionUs == null) { if (exoPlayerImplInternal.playbackInfo.playbackState != 1) { exoPlayerImplInternal.setState(4); } exoPlayerImplInternal.resetInternal(false, true, false, true); } else { try { try { try { if (mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.equals(exoPlayerImplInternal.playbackInfo.periodId)) { try { MediaPeriodHolder playingPeriod = exoPlayerImplInternal.queue.getPlayingPeriod(); adjustedSeekPositionUs = (playingPeriod == null || !playingPeriod.prepared || jLongValue == j4) ? jLongValue : playingPeriod.mediaPeriod.getAdjustedSeekPositionUs(jLongValue, exoPlayerImplInternal.seekParameters); mediaPeriodId2 = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange; try { if (Util.usToMs(adjustedSeekPositionUs) != Util.usToMs(exoPlayerImplInternal.playbackInfo.positionUs) || ((i6 = (playbackInfo = exoPlayerImplInternal.playbackInfo).playbackState) != 2 && i6 != 3)) { z7 = z6; } long j12 = playbackInfo.positionUs; i7 = 2; z7 = z6; j8 = j12; mediaPeriodId3 = mediaPeriodId2; j9 = j12; exoPlayerImplInternal.playbackInfo = exoPlayerImplInternal.handlePositionDiscontinuity(mediaPeriodId3, j9, j6, j8, z7, i7); return; } catch (Throwable th) { th = th; z7 = z6; mediaPeriodId = mediaPeriodId2; j7 = jLongValue; exoPlayerImplInternal.playbackInfo = exoPlayerImplInternal.handlePositionDiscontinuity(mediaPeriodId, j7, j6, j7, z7, 2); throw th; } } catch (Throwable th2) { th = th2; z7 = z6; mediaPeriodId2 = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange; } } else { z7 = z6; mediaPeriodId2 = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange; adjustedSeekPositionUs = jLongValue; } exoPlayerImplInternal.updatePlaybackSpeedSettingsForNewPeriod(timeline, mediaPeriodId4, timeline, playbackInfo2.periodId, j10, true); mediaPeriodId3 = mediaPeriodId4; j6 = j10; j9 = jSeekToPeriodPosition; i7 = 2; j8 = j9; exoPlayerImplInternal = this; exoPlayerImplInternal.playbackInfo = exoPlayerImplInternal.handlePositionDiscontinuity(mediaPeriodId3, j9, j6, j8, z7, i7); return; } catch (Throwable th3) { th = th3; mediaPeriodId = mediaPeriodId4; j6 = j10; j7 = jSeekToPeriodPosition; exoPlayerImplInternal.playbackInfo = exoPlayerImplInternal.handlePositionDiscontinuity(mediaPeriodId, j7, j6, j7, z7, 2); throw th; } playbackInfo2 = exoPlayerImplInternal.playbackInfo; timeline = playbackInfo2.timeline; mediaPeriodId4 = mediaPeriodId2; j10 = j6; } catch (Throwable th4) { th = th4; mediaPeriodId = mediaPeriodId2; } jSeekToPeriodPosition = exoPlayerImplInternal.seekToPeriodPosition(mediaPeriodId2, adjustedSeekPositionUs, exoPlayerImplInternal.playbackInfo.playbackState == 4); z7 |= jLongValue != jSeekToPeriodPosition; } catch (Throwable th5) { th = th5; mediaPeriodId = mediaPeriodId2; j7 = jLongValue; exoPlayerImplInternal.playbackInfo = exoPlayerImplInternal.handlePositionDiscontinuity(mediaPeriodId, j7, j6, j7, z7, 2); throw th; } } z7 = z6; mediaPeriodId3 = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange; j9 = jLongValue; i7 = 2; j8 = j9; exoPlayerImplInternal = this; exoPlayerImplInternal.playbackInfo = exoPlayerImplInternal.handlePositionDiscontinuity(mediaPeriodId3, j9, j6, j8, z7, i7); return; } exoPlayerImplInternal.playbackInfo.timeline.getPeriodByUid(mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.periodUid, exoPlayerImplInternal.period); jLongValue = exoPlayerImplInternal.period.getFirstAdIndexToPlay(mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.adGroupIndex) == mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange.adIndexInAdGroup ? exoPlayerImplInternal.period.getAdResumePositionUs() : 0L; z6 = true; j6 = j11; } if (!exoPlayerImplInternal.playbackInfo.timeline.isEmpty()) { } z7 = z6; mediaPeriodId3 = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange; j9 = jLongValue; i7 = 2; j8 = j9; exoPlayerImplInternal = this; exoPlayerImplInternal.playbackInfo = exoPlayerImplInternal.handlePositionDiscontinuity(mediaPeriodId3, j9, j6, j8, z7, i7); return; } catch (Throwable th6) { th = th6; z7 = z6; mediaPeriodId = mediaPeriodIdResolveMediaPeriodIdForAdsAfterPeriodPositionChange; } j4 = 0; } private long seekToPeriodPosition(MediaSource.MediaPeriodId mediaPeriodId, long j4, boolean z6) { return seekToPeriodPosition(mediaPeriodId, j4, this.queue.getPlayingPeriod() != this.queue.getReadingPeriod(), z6); } private void sendMessageInternal(PlayerMessage playerMessage) { if (playerMessage.getPositionMs() == androidx.media3.common.C.TIME_UNSET) { sendMessageToTarget(playerMessage); return; } if (this.playbackInfo.timeline.isEmpty()) { this.pendingMessages.add(new PendingMessageInfo(playerMessage)); return; } PendingMessageInfo pendingMessageInfo = new PendingMessageInfo(playerMessage); Timeline timeline = this.playbackInfo.timeline; if (!resolvePendingMessagePosition(pendingMessageInfo, timeline, timeline, this.repeatMode, this.shuffleModeEnabled, this.window, this.period)) { playerMessage.markAsProcessed(false); } else { this.pendingMessages.add(pendingMessageInfo); Collections.sort(this.pendingMessages); } } private void sendMessageToTarget(PlayerMessage playerMessage) { if (playerMessage.getLooper() != this.playbackLooper) { this.handler.obtainMessage(15, playerMessage).sendToTarget(); return; } deliverMessage(playerMessage); int i6 = this.playbackInfo.playbackState; if (i6 == 3 || i6 == 2) { this.handler.sendEmptyMessage(2); } } private void sendMessageToTargetThread(PlayerMessage playerMessage) { Looper looper = playerMessage.getLooper(); if (looper.getThread().isAlive()) { this.clock.createHandler(looper, null).post(new t(1, this, playerMessage)); } else { Log.w("TAG", "Trying to send message on a dead thread."); playerMessage.markAsProcessed(false); } } private void setAllRendererStreamsFinal(long j4) { for (Renderer renderer : this.renderers) { if (renderer.getStream() != null) { setCurrentStreamFinal(renderer, j4); } } } private void setCurrentStreamFinal(Renderer renderer, long j4) { renderer.setCurrentStreamFinal(); if (renderer instanceof TextRenderer) { ((TextRenderer) renderer).setFinalStreamEndPositionUs(j4); } } private void setForegroundModeInternal(boolean z6, AtomicBoolean atomicBoolean) { if (this.foregroundMode != z6) { this.foregroundMode = z6; if (!z6) { for (Renderer renderer : this.renderers) { if (!isRendererEnabled(renderer) && this.renderersToReset.remove(renderer)) { renderer.reset(); } } } } if (atomicBoolean != null) { synchronized (this) { atomicBoolean.set(true); notifyAll(); } } } private void setMediaClockPlaybackParameters(PlaybackParameters playbackParameters) { this.handler.removeMessages(16); this.mediaClock.setPlaybackParameters(playbackParameters); } private void setMediaItemsInternal(MediaSourceListUpdateMessage mediaSourceListUpdateMessage) throws Throwable { this.playbackInfoUpdate.incrementPendingOperationAcks(1); if (mediaSourceListUpdateMessage.windowIndex != -1) { this.pendingInitialSeekPosition = new SeekPosition(new PlaylistTimeline(mediaSourceListUpdateMessage.mediaSourceHolders, mediaSourceListUpdateMessage.shuffleOrder), mediaSourceListUpdateMessage.windowIndex, mediaSourceListUpdateMessage.positionUs); } handleMediaSourceListInfoRefreshed(this.mediaSourceList.setMediaSources(mediaSourceListUpdateMessage.mediaSourceHolders, mediaSourceListUpdateMessage.shuffleOrder), false); } private void setOffloadSchedulingEnabled(boolean z6) { if (z6 == this.offloadSchedulingEnabled) { return; } this.offloadSchedulingEnabled = z6; if (z6 || !this.playbackInfo.sleepingForOffload) { return; } this.handler.sendEmptyMessage(2); } private void setPauseAtEndOfWindowInternal(boolean z6) { this.pauseAtEndOfWindow = z6; resetPendingPauseAtEndOfPeriod(); if (!this.pendingPauseAtEndOfPeriod || this.queue.getReadingPeriod() == this.queue.getPlayingPeriod()) { return; } seekToCurrentPosition(true); handleLoadingMediaPeriodChanged(false); } private void setPlayWhenReadyInternal(boolean z6, int i6, boolean z7, int i7) { this.playbackInfoUpdate.incrementPendingOperationAcks(z7 ? 1 : 0); this.playbackInfo = this.playbackInfo.copyWithPlayWhenReady(z6, i7, i6); updateRebufferingState(false, false); notifyTrackSelectionPlayWhenReadyChanged(z6); if (!shouldPlayWhenReady()) { stopRenderers(); updatePlaybackPositions(); return; } int i8 = this.playbackInfo.playbackState; if (i8 == 3) { this.mediaClock.start(); startRenderers(); this.handler.sendEmptyMessage(2); } else if (i8 == 2) { this.handler.sendEmptyMessage(2); } } private void setPlaybackParametersInternal(PlaybackParameters playbackParameters) { setMediaClockPlaybackParameters(playbackParameters); handlePlaybackParameters(this.mediaClock.getPlaybackParameters(), true); } private void setPreloadConfigurationInternal(ExoPlayer.PreloadConfiguration preloadConfiguration) { this.preloadConfiguration = preloadConfiguration; this.queue.updatePreloadConfiguration(this.playbackInfo.timeline, preloadConfiguration); } private void setRepeatModeInternal(int i6) { this.repeatMode = i6; if (!this.queue.updateRepeatMode(this.playbackInfo.timeline, i6)) { seekToCurrentPosition(true); } handleLoadingMediaPeriodChanged(false); } private void setSeekParametersInternal(SeekParameters seekParameters) { this.seekParameters = seekParameters; } private void setShuffleModeEnabledInternal(boolean z6) { this.shuffleModeEnabled = z6; if (!this.queue.updateShuffleModeEnabled(this.playbackInfo.timeline, z6)) { seekToCurrentPosition(true); } handleLoadingMediaPeriodChanged(false); } private void setShuffleOrderInternal(ShuffleOrder shuffleOrder) throws Throwable { this.playbackInfoUpdate.incrementPendingOperationAcks(1); handleMediaSourceListInfoRefreshed(this.mediaSourceList.setShuffleOrder(shuffleOrder), false); } private void setState(int i6) { PlaybackInfo playbackInfo = this.playbackInfo; if (playbackInfo.playbackState != i6) { if (i6 != 2) { this.playbackMaybeBecameStuckAtMs = androidx.media3.common.C.TIME_UNSET; } this.playbackInfo = playbackInfo.copyWithPlaybackState(i6); } } private boolean shouldAdvancePlayingPeriod() { MediaPeriodHolder playingPeriod; MediaPeriodHolder next; return shouldPlayWhenReady() && !this.pendingPauseAtEndOfPeriod && (playingPeriod = this.queue.getPlayingPeriod()) != null && (next = playingPeriod.getNext()) != null && this.rendererPositionUs >= next.getStartPositionRendererTime() && next.allRenderersInCorrectState; } private boolean shouldContinueLoading() { if (!isLoadingPossible()) { return false; } MediaPeriodHolder loadingPeriod = this.queue.getLoadingPeriod(); long totalBufferedDurationUs = getTotalBufferedDurationUs(loadingPeriod.getNextLoadPositionUs()); LoadControl.Parameters parameters = new LoadControl.Parameters(this.playerId, this.playbackInfo.timeline, loadingPeriod.info.id, loadingPeriod == this.queue.getPlayingPeriod() ? loadingPeriod.toPeriodTime(this.rendererPositionUs) : loadingPeriod.toPeriodTime(this.rendererPositionUs) - loadingPeriod.info.startPositionUs, totalBufferedDurationUs, this.mediaClock.getPlaybackParameters().speed, this.playbackInfo.playWhenReady, this.isRebuffering, shouldUseLivePlaybackSpeedControl(this.playbackInfo.timeline, loadingPeriod.info.id) ? this.livePlaybackSpeedControl.getTargetLiveOffsetUs() : androidx.media3.common.C.TIME_UNSET); boolean zShouldContinueLoading = this.loadControl.shouldContinueLoading(parameters); MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); if (zShouldContinueLoading || !playingPeriod.prepared || totalBufferedDurationUs >= PLAYBACK_BUFFER_EMPTY_THRESHOLD_US) { return zShouldContinueLoading; } if (this.backBufferDurationUs <= 0 && !this.retainBackBufferFromKeyframe) { return zShouldContinueLoading; } playingPeriod.mediaPeriod.discardBuffer(this.playbackInfo.positionUs, false); return this.loadControl.shouldContinueLoading(parameters); } private boolean shouldPlayWhenReady() { PlaybackInfo playbackInfo = this.playbackInfo; return playbackInfo.playWhenReady && playbackInfo.playbackSuppressionReason == 0; } private boolean shouldTransitionToReadyState(boolean z6) { if (this.enabledRendererCount == 0) { return isTimelineReady(); } if (!z6) { return false; } if (!this.playbackInfo.isLoading) { return true; } MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); long targetLiveOffsetUs = shouldUseLivePlaybackSpeedControl(this.playbackInfo.timeline, playingPeriod.info.id) ? this.livePlaybackSpeedControl.getTargetLiveOffsetUs() : androidx.media3.common.C.TIME_UNSET; MediaPeriodHolder loadingPeriod = this.queue.getLoadingPeriod(); return (loadingPeriod.isFullyBuffered() && loadingPeriod.info.isFinal) || (loadingPeriod.info.id.isAd() && !loadingPeriod.prepared) || this.loadControl.shouldStartPlayback(new LoadControl.Parameters(this.playerId, this.playbackInfo.timeline, playingPeriod.info.id, playingPeriod.toPeriodTime(this.rendererPositionUs), getTotalBufferedDurationUs(), this.mediaClock.getPlaybackParameters().speed, this.playbackInfo.playWhenReady, this.isRebuffering, targetLiveOffsetUs)); } private boolean shouldUseLivePlaybackSpeedControl(Timeline timeline, MediaSource.MediaPeriodId mediaPeriodId) { if (!mediaPeriodId.isAd() && !timeline.isEmpty()) { timeline.getWindow(timeline.getPeriodByUid(mediaPeriodId.periodUid, this.period).windowIndex, this.window); if (this.window.isLive()) { Timeline.Window window = this.window; if (window.isDynamic && window.windowStartTimeMs != androidx.media3.common.C.TIME_UNSET) { return true; } } } return false; } private void startRenderers() { MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); if (playingPeriod == null) { return; } TrackSelectorResult trackSelectorResult = playingPeriod.getTrackSelectorResult(); for (int i6 = 0; i6 < this.renderers.length; i6++) { if (trackSelectorResult.isRendererEnabled(i6) && this.renderers[i6].getState() == 1) { this.renderers[i6].start(); } } } private void stopInternal(boolean z6, boolean z7) { resetInternal(z6 || !this.foregroundMode, false, true, false); this.playbackInfoUpdate.incrementPendingOperationAcks(z7 ? 1 : 0); this.loadControl.onStopped(this.playerId); setState(1); } private void stopRenderers() { this.mediaClock.stop(); for (Renderer renderer : this.renderers) { if (isRendererEnabled(renderer)) { ensureStopped(renderer); } } } private void updateIsLoading() { MediaPeriodHolder loadingPeriod = this.queue.getLoadingPeriod(); boolean z6 = this.shouldContinueLoading || (loadingPeriod != null && loadingPeriod.mediaPeriod.isLoading()); PlaybackInfo playbackInfo = this.playbackInfo; if (z6 != playbackInfo.isLoading) { this.playbackInfo = playbackInfo.copyWithIsLoading(z6); } } private void updateLoadControlTrackSelection(MediaSource.MediaPeriodId mediaPeriodId, TrackGroupArray trackGroupArray, TrackSelectorResult trackSelectorResult) { this.loadControl.onTracksSelected(this.playerId, this.playbackInfo.timeline, mediaPeriodId, this.renderers, trackGroupArray, trackSelectorResult.selections); } private void updateMediaSourcesWithMediaItemsInternal(int i6, int i7, List list) throws Throwable { this.playbackInfoUpdate.incrementPendingOperationAcks(1); handleMediaSourceListInfoRefreshed(this.mediaSourceList.updateMediaSourcesWithMediaItems(i6, i7, list), false); } private void updatePeriods() { if (this.playbackInfo.timeline.isEmpty() || !this.mediaSourceList.isPrepared()) { return; } boolean zMaybeUpdateLoadingPeriod = maybeUpdateLoadingPeriod(); maybeUpdateReadingPeriod(); maybeUpdateReadingRenderers(); maybeUpdatePlayingPeriod(); maybeUpdatePreloadPeriods(zMaybeUpdateLoadingPeriod); } private void updatePlaybackPositions() { MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); if (playingPeriod == null) { return; } long discontinuity = playingPeriod.prepared ? playingPeriod.mediaPeriod.readDiscontinuity() : -9223372036854775807L; if (discontinuity != androidx.media3.common.C.TIME_UNSET) { if (!playingPeriod.isFullyBuffered()) { this.queue.removeAfter(playingPeriod); handleLoadingMediaPeriodChanged(false); maybeContinueLoading(); } resetRendererPosition(discontinuity); if (discontinuity != this.playbackInfo.positionUs) { PlaybackInfo playbackInfo = this.playbackInfo; long j4 = discontinuity; this.playbackInfo = handlePositionDiscontinuity(playbackInfo.periodId, j4, playbackInfo.requestedContentPositionUs, j4, true, 5); } } else { long jSyncAndGetPositionUs = this.mediaClock.syncAndGetPositionUs(playingPeriod != this.queue.getReadingPeriod()); this.rendererPositionUs = jSyncAndGetPositionUs; long periodTime = playingPeriod.toPeriodTime(jSyncAndGetPositionUs); maybeTriggerPendingMessages(this.playbackInfo.positionUs, periodTime); if (this.mediaClock.hasSkippedSilenceSinceLastCall()) { boolean z6 = !this.playbackInfoUpdate.positionDiscontinuity; PlaybackInfo playbackInfo2 = this.playbackInfo; this.playbackInfo = handlePositionDiscontinuity(playbackInfo2.periodId, periodTime, playbackInfo2.requestedContentPositionUs, periodTime, z6, 6); } else { this.playbackInfo.updatePositionUs(periodTime); } } this.playbackInfo.bufferedPositionUs = this.queue.getLoadingPeriod().getBufferedPositionUs(); this.playbackInfo.totalBufferedDurationUs = getTotalBufferedDurationUs(); PlaybackInfo playbackInfo3 = this.playbackInfo; if (playbackInfo3.playWhenReady && playbackInfo3.playbackState == 3 && shouldUseLivePlaybackSpeedControl(playbackInfo3.timeline, playbackInfo3.periodId) && this.playbackInfo.playbackParameters.speed == 1.0f) { float adjustedPlaybackSpeed = this.livePlaybackSpeedControl.getAdjustedPlaybackSpeed(getCurrentLiveOffsetUs(), getTotalBufferedDurationUs()); if (this.mediaClock.getPlaybackParameters().speed != adjustedPlaybackSpeed) { setMediaClockPlaybackParameters(this.playbackInfo.playbackParameters.withSpeed(adjustedPlaybackSpeed)); handlePlaybackParameters(this.playbackInfo.playbackParameters, this.mediaClock.getPlaybackParameters().speed, false, false); } } } private void updatePlaybackSpeedSettingsForNewPeriod(Timeline timeline, MediaSource.MediaPeriodId mediaPeriodId, Timeline timeline2, MediaSource.MediaPeriodId mediaPeriodId2, long j4, boolean z6) { if (!shouldUseLivePlaybackSpeedControl(timeline, mediaPeriodId)) { PlaybackParameters playbackParameters = mediaPeriodId.isAd() ? PlaybackParameters.DEFAULT : this.playbackInfo.playbackParameters; if (this.mediaClock.getPlaybackParameters().equals(playbackParameters)) { return; } setMediaClockPlaybackParameters(playbackParameters); handlePlaybackParameters(this.playbackInfo.playbackParameters, playbackParameters.speed, false, false); return; } timeline.getWindow(timeline.getPeriodByUid(mediaPeriodId.periodUid, this.period).windowIndex, this.window); this.livePlaybackSpeedControl.setLiveConfiguration((MediaItem.LiveConfiguration) Util.castNonNull(this.window.liveConfiguration)); if (j4 != androidx.media3.common.C.TIME_UNSET) { this.livePlaybackSpeedControl.setTargetLiveOffsetOverrideUs(getLiveOffsetUs(timeline, mediaPeriodId.periodUid, j4)); return; } if (!Util.areEqual(!timeline2.isEmpty() ? timeline2.getWindow(timeline2.getPeriodByUid(mediaPeriodId2.periodUid, this.period).windowIndex, this.window).uid : null, this.window.uid) || z6) { this.livePlaybackSpeedControl.setTargetLiveOffsetOverrideUs(androidx.media3.common.C.TIME_UNSET); } } private void updateRebufferingState(boolean z6, boolean z7) { this.isRebuffering = z6; this.lastRebufferRealtimeMs = (!z6 || z7) ? androidx.media3.common.C.TIME_UNSET : this.clock.elapsedRealtime(); } private void updateTrackSelectionPlaybackSpeed(float f6) { for (MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); playingPeriod != null; playingPeriod = playingPeriod.getNext()) { for (ExoTrackSelection exoTrackSelection : playingPeriod.getTrackSelectorResult().selections) { if (exoTrackSelection != null) { exoTrackSelection.onPlaybackSpeed(f6); } } } } private synchronized void waitUninterruptibly(E3.q qVar, long j4) { long jElapsedRealtime = this.clock.elapsedRealtime() + j4; boolean z6 = false; while (!((Boolean) qVar.get()).booleanValue() && j4 > 0) { try { this.clock.onThreadBlocked(); wait(j4); } catch (InterruptedException unused) { z6 = true; } j4 = jElapsedRealtime - this.clock.elapsedRealtime(); } if (z6) { Thread.currentThread().interrupt(); } } public void addMediaSources(int i6, List list, ShuffleOrder shuffleOrder) { this.handler.obtainMessage(18, i6, 0, new MediaSourceListUpdateMessage(list, shuffleOrder, -1, androidx.media3.common.C.TIME_UNSET)).sendToTarget(); } public void experimentalSetForegroundModeTimeoutMs(long j4) { this.setForegroundModeTimeoutMs = j4; } public Looper getPlaybackLooper() { return this.playbackLooper; } @Override // android.os.Handler.Callback public boolean handleMessage(Message message) throws Throwable { int i6; MediaPeriodHolder readingPeriod; int i7; try { switch (message.what) { case 1: boolean z6 = message.arg1 != 0; int i8 = message.arg2; setPlayWhenReadyInternal(z6, i8 >> 4, true, i8 & 15); break; case 2: doSomeWork(); break; case 3: seekToInternal((SeekPosition) message.obj); break; case 4: setPlaybackParametersInternal((PlaybackParameters) message.obj); break; case 5: setSeekParametersInternal((SeekParameters) message.obj); break; case 6: stopInternal(false, true); break; case 7: releaseInternal(); return true; case 8: handlePeriodPrepared((MediaPeriod) message.obj); break; case 9: handleContinueLoadingRequested((MediaPeriod) message.obj); break; case 10: reselectTracksInternal(); break; case 11: setRepeatModeInternal(message.arg1); break; case 12: setShuffleModeEnabledInternal(message.arg1 != 0); break; case 13: setForegroundModeInternal(message.arg1 != 0, (AtomicBoolean) message.obj); break; case 14: sendMessageInternal((PlayerMessage) message.obj); break; case 15: sendMessageToTargetThread((PlayerMessage) message.obj); break; case 16: handlePlaybackParameters((PlaybackParameters) message.obj, false); break; case 17: setMediaItemsInternal((MediaSourceListUpdateMessage) message.obj); break; case 18: addMediaItemsInternal((MediaSourceListUpdateMessage) message.obj, message.arg1); break; case 19: moveMediaItemsInternal((MoveMediaItemsMessage) message.obj); break; case 20: removeMediaItemsInternal(message.arg1, message.arg2, (ShuffleOrder) message.obj); break; case 21: setShuffleOrderInternal((ShuffleOrder) message.obj); break; case 22: mediaSourceListUpdateRequestedInternal(); break; case 23: setPauseAtEndOfWindowInternal(message.arg1 != 0); break; case 24: default: return false; case 25: attemptRendererErrorRecovery(); break; case 26: reselectTracksInternalAndSeek(); break; case 27: updateMediaSourcesWithMediaItemsInternal(message.arg1, message.arg2, (List) message.obj); break; case 28: setPreloadConfigurationInternal((ExoPlayer.PreloadConfiguration) message.obj); break; case 29: prepareInternal(); break; } } catch (ParserException e6) { int i9 = e6.dataType; if (i9 == 1) { i7 = e6.contentIsMalformed ? 3001 : 3003; } else { if (i9 == 4) { i7 = e6.contentIsMalformed ? 3002 : 3004; } handleIoException(e6, i); } i = i7; handleIoException(e6, i); } catch (DataSourceException e7) { handleIoException(e7, e7.reason); } catch (ExoPlaybackException e8) { e = e8; if (e.type == 1 && (readingPeriod = this.queue.getReadingPeriod()) != null) { e = e.copyWithMediaPeriodId(readingPeriod.info.id); } if (e.isRecoverable && (this.pendingRecoverableRendererError == null || (i6 = e.errorCode) == 5004 || i6 == 5003)) { Log.w(TAG, "Recoverable renderer error", e); ExoPlaybackException exoPlaybackException = this.pendingRecoverableRendererError; if (exoPlaybackException != null) { exoPlaybackException.addSuppressed(e); e = this.pendingRecoverableRendererError; } else { this.pendingRecoverableRendererError = e; } HandlerWrapper handlerWrapper = this.handler; handlerWrapper.sendMessageAtFrontOfQueue(handlerWrapper.obtainMessage(25, e)); } else { ExoPlaybackException exoPlaybackException2 = this.pendingRecoverableRendererError; if (exoPlaybackException2 != null) { exoPlaybackException2.addSuppressed(e); e = this.pendingRecoverableRendererError; } Log.e(TAG, "Playback error", e); if (e.type == 1 && this.queue.getPlayingPeriod() != this.queue.getReadingPeriod()) { while (this.queue.getPlayingPeriod() != this.queue.getReadingPeriod()) { this.queue.advancePlayingPeriod(); } MediaPeriodHolder mediaPeriodHolder = (MediaPeriodHolder) Assertions.checkNotNull(this.queue.getPlayingPeriod()); maybeNotifyPlaybackInfoChanged(); MediaPeriodInfo mediaPeriodInfo = mediaPeriodHolder.info; MediaSource.MediaPeriodId mediaPeriodId = mediaPeriodInfo.id; long j4 = mediaPeriodInfo.startPositionUs; this.playbackInfo = handlePositionDiscontinuity(mediaPeriodId, j4, mediaPeriodInfo.requestedContentPositionUs, j4, true, 0); } stopInternal(true, false); this.playbackInfo = this.playbackInfo.copyWithPlaybackError(e); } } catch (DrmSession.DrmSessionException e9) { handleIoException(e9, e9.errorCode); } catch (BehindLiveWindowException e10) { handleIoException(e10, 1002); } catch (IOException e11) { handleIoException(e11, 2000); } catch (RuntimeException e12) { ExoPlaybackException exoPlaybackExceptionCreateForUnexpected = ExoPlaybackException.createForUnexpected(e12, ((e12 instanceof IllegalStateException) || (e12 instanceof IllegalArgumentException)) ? 1004 : 1000); Log.e(TAG, "Playback error", exoPlaybackExceptionCreateForUnexpected); stopInternal(true, false); this.playbackInfo = this.playbackInfo.copyWithPlaybackError(exoPlaybackExceptionCreateForUnexpected); } maybeNotifyPlaybackInfoChanged(); return true; } public void moveMediaSources(int i6, int i7, int i8, ShuffleOrder shuffleOrder) { this.handler.obtainMessage(19, new MoveMediaItemsMessage(i6, i7, i8, shuffleOrder)).sendToTarget(); } @Override // androidx.media3.exoplayer.DefaultMediaClock.PlaybackParametersListener public void onPlaybackParametersChanged(PlaybackParameters playbackParameters) { this.handler.obtainMessage(16, playbackParameters).sendToTarget(); } @Override // androidx.media3.exoplayer.MediaSourceList.MediaSourceListInfoRefreshListener public void onPlaylistUpdateRequested() { this.handler.removeMessages(2); this.handler.sendEmptyMessage(22); } @Override // androidx.media3.exoplayer.source.MediaPeriod.Callback public void onPrepared(MediaPeriod mediaPeriod) { this.handler.obtainMessage(8, mediaPeriod).sendToTarget(); } @Override // androidx.media3.exoplayer.trackselection.TrackSelector.InvalidationListener public void onRendererCapabilitiesChanged(Renderer renderer) { this.handler.sendEmptyMessage(26); } @Override // androidx.media3.exoplayer.trackselection.TrackSelector.InvalidationListener public void onTrackSelectionsInvalidated() { this.handler.sendEmptyMessage(10); } public void prepare() { this.handler.obtainMessage(29).sendToTarget(); } public synchronized boolean release() { if (!this.released && this.playbackLooper.getThread().isAlive()) { this.handler.sendEmptyMessage(7); waitUninterruptibly(new x(this, 0), this.releaseTimeoutMs); return this.released; } return true; } public void removeMediaSources(int i6, int i7, ShuffleOrder shuffleOrder) { this.handler.obtainMessage(20, i6, i7, shuffleOrder).sendToTarget(); } public void seekTo(Timeline timeline, int i6, long j4) { this.handler.obtainMessage(3, new SeekPosition(timeline, i6, j4)).sendToTarget(); } @Override // androidx.media3.exoplayer.PlayerMessage.Sender public synchronized void sendMessage(PlayerMessage playerMessage) { if (!this.released && this.playbackLooper.getThread().isAlive()) { this.handler.obtainMessage(14, playerMessage).sendToTarget(); return; } Log.w(TAG, "Ignoring messages sent after release."); playerMessage.markAsProcessed(false); } public synchronized boolean setForegroundMode(boolean z6) { if (!this.released && this.playbackLooper.getThread().isAlive()) { if (z6) { this.handler.obtainMessage(13, 1, 0).sendToTarget(); return true; } AtomicBoolean atomicBoolean = new AtomicBoolean(); this.handler.obtainMessage(13, 0, 0, atomicBoolean).sendToTarget(); waitUninterruptibly(new x(atomicBoolean, 1), this.setForegroundModeTimeoutMs); return atomicBoolean.get(); } return true; } public void setMediaSources(List list, int i6, long j4, ShuffleOrder shuffleOrder) { this.handler.obtainMessage(17, new MediaSourceListUpdateMessage(list, shuffleOrder, i6, j4)).sendToTarget(); } public void setPauseAtEndOfWindow(boolean z6) { this.handler.obtainMessage(23, z6 ? 1 : 0, 0).sendToTarget(); } public void setPlayWhenReady(boolean z6, int i6, int i7) { this.handler.obtainMessage(1, z6 ? 1 : 0, i6 | (i7 << 4)).sendToTarget(); } public void setPlaybackParameters(PlaybackParameters playbackParameters) { this.handler.obtainMessage(4, playbackParameters).sendToTarget(); } public void setPreloadConfiguration(ExoPlayer.PreloadConfiguration preloadConfiguration) { this.handler.obtainMessage(28, preloadConfiguration).sendToTarget(); } public void setRepeatMode(int i6) { this.handler.obtainMessage(11, i6, 0).sendToTarget(); } public void setSeekParameters(SeekParameters seekParameters) { this.handler.obtainMessage(5, seekParameters).sendToTarget(); } public void setShuffleModeEnabled(boolean z6) { this.handler.obtainMessage(12, z6 ? 1 : 0, 0).sendToTarget(); } public void setShuffleOrder(ShuffleOrder shuffleOrder) { this.handler.obtainMessage(21, shuffleOrder).sendToTarget(); } public void stop() { this.handler.obtainMessage(6).sendToTarget(); } public void updateMediaSourcesWithMediaItems(int i6, int i7, List list) { this.handler.obtainMessage(27, i6, i7, list).sendToTarget(); } private long getTotalBufferedDurationUs(long j4) { MediaPeriodHolder loadingPeriod = this.queue.getLoadingPeriod(); if (loadingPeriod == null) { return 0L; } return Math.max(0L, j4 - loadingPeriod.toPeriodTime(this.rendererPositionUs)); } private void handlePlaybackParameters(PlaybackParameters playbackParameters, float f6, boolean z6, boolean z7) { if (z6) { if (z7) { this.playbackInfoUpdate.incrementPendingOperationAcks(1); } this.playbackInfo = this.playbackInfo.copyWithPlaybackParameters(playbackParameters); } updateTrackSelectionPlaybackSpeed(playbackParameters.speed); for (Renderer renderer : this.renderers) { if (renderer != null) { renderer.setPlaybackSpeed(f6, playbackParameters.speed); } } } @Override // androidx.media3.exoplayer.source.SequenceableLoader.Callback public void onContinueLoadingRequested(MediaPeriod mediaPeriod) { this.handler.obtainMessage(9, mediaPeriod).sendToTarget(); } private void enableRenderers(boolean[] zArr, long j4) { MediaPeriodHolder readingPeriod = this.queue.getReadingPeriod(); TrackSelectorResult trackSelectorResult = readingPeriod.getTrackSelectorResult(); for (int i6 = 0; i6 < this.renderers.length; i6++) { if (!trackSelectorResult.isRendererEnabled(i6) && this.renderersToReset.remove(this.renderers[i6])) { this.renderers[i6].reset(); } } for (int i7 = 0; i7 < this.renderers.length; i7++) { if (trackSelectorResult.isRendererEnabled(i7)) { enableRenderer(i7, zArr[i7], j4); } } readingPeriod.allRenderersInCorrectState = true; } private long seekToPeriodPosition(MediaSource.MediaPeriodId mediaPeriodId, long j4, boolean z6, boolean z7) { stopRenderers(); updateRebufferingState(false, true); if (z7 || this.playbackInfo.playbackState == 3) { setState(2); } MediaPeriodHolder playingPeriod = this.queue.getPlayingPeriod(); MediaPeriodHolder next = playingPeriod; while (next != null && !mediaPeriodId.equals(next.info.id)) { next = next.getNext(); } if (z6 || playingPeriod != next || (next != null && next.toRendererTime(j4) < 0)) { for (Renderer renderer : this.renderers) { disableRenderer(renderer); } if (next != null) { while (this.queue.getPlayingPeriod() != next) { this.queue.advancePlayingPeriod(); } this.queue.removeAfter(next); next.setRendererOffset(MediaPeriodQueue.INITIAL_RENDERER_POSITION_OFFSET_US); enableRenderers(); } } if (next != null) { this.queue.removeAfter(next); if (!next.prepared) { next.info = next.info.copyWithStartPositionUs(j4); } else if (next.hasEnabledTracks) { j4 = next.mediaPeriod.seekToUs(j4); next.mediaPeriod.discardBuffer(j4 - this.backBufferDurationUs, this.retainBackBufferFromKeyframe); } resetRendererPosition(j4); maybeContinueLoading(); } else { this.queue.clear(); resetRendererPosition(j4); } handleLoadingMediaPeriodChanged(false); this.handler.sendEmptyMessage(2); return j4; } }