package androidx.media3.exoplayer.dash; import android.net.Uri; import android.os.Handler; import android.os.Looper; import android.os.SystemClock; import android.text.TextUtils; import android.util.SparseArray; import androidx.media3.common.C; import androidx.media3.common.MediaItem; import androidx.media3.common.MediaLibraryInfo; import androidx.media3.common.MimeTypes; import androidx.media3.common.ParserException; import androidx.media3.common.StreamKey; import androidx.media3.common.Timeline; import androidx.media3.common.util.Log; import androidx.media3.common.util.UnstableApi; import androidx.media3.common.util.Util; import androidx.media3.datasource.DataSource; import androidx.media3.datasource.DataSpec; import androidx.media3.datasource.TransferListener; import androidx.media3.exoplayer.audio.SilenceSkippingAudioProcessor; import androidx.media3.exoplayer.dash.DashChunkSource; import androidx.media3.exoplayer.dash.DashMediaSource; import androidx.media3.exoplayer.dash.DefaultDashChunkSource; import androidx.media3.exoplayer.dash.PlayerEmsgHandler; import androidx.media3.exoplayer.dash.manifest.AdaptationSet; import androidx.media3.exoplayer.dash.manifest.DashManifest; import androidx.media3.exoplayer.dash.manifest.DashManifestParser; import androidx.media3.exoplayer.dash.manifest.Period; import androidx.media3.exoplayer.dash.manifest.Representation; import androidx.media3.exoplayer.dash.manifest.ServiceDescriptionElement; import androidx.media3.exoplayer.dash.manifest.UtcTimingElement; import androidx.media3.exoplayer.drm.DefaultDrmSessionManagerProvider; import androidx.media3.exoplayer.drm.DrmSessionManager; import androidx.media3.exoplayer.drm.DrmSessionManagerProvider; import androidx.media3.exoplayer.offline.FilteringManifestParser; import androidx.media3.exoplayer.source.BaseMediaSource; import androidx.media3.exoplayer.source.CompositeSequenceableLoaderFactory; import androidx.media3.exoplayer.source.DefaultCompositeSequenceableLoaderFactory; import androidx.media3.exoplayer.source.LoadEventInfo; import androidx.media3.exoplayer.source.MediaLoadData; import androidx.media3.exoplayer.source.MediaPeriod; import androidx.media3.exoplayer.source.MediaSource; import androidx.media3.exoplayer.source.MediaSourceEventListener; import androidx.media3.exoplayer.source.MediaSourceFactory; import androidx.media3.exoplayer.upstream.Allocator; import androidx.media3.exoplayer.upstream.CmcdConfiguration; import androidx.media3.exoplayer.upstream.CmcdData; import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy; import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy; import androidx.media3.exoplayer.upstream.Loader; import androidx.media3.exoplayer.upstream.LoaderErrorThrower; import androidx.media3.exoplayer.upstream.ParsingLoadable; import androidx.media3.exoplayer.util.ReleasableExecutor; import androidx.media3.exoplayer.util.SntpClient; import androidx.media3.extractor.text.SubtitleParser; import defpackage.ae9; import defpackage.hs0; import defpackage.if7; import defpackage.qy3; import defpackage.rq6; import defpackage.xi5; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.math.RoundingMode; import java.nio.charset.StandardCharsets; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.List; import java.util.Locale; import java.util.Objects; import java.util.TimeZone; import java.util.regex.Matcher; import java.util.regex.Pattern; /* JADX INFO: loaded from: classes.dex */ @UnstableApi public final class DashMediaSource extends BaseMediaSource { public static final long DEFAULT_FALLBACK_TARGET_LIVE_OFFSET_MS = 30000; public static final String DEFAULT_MEDIA_ID = "DashMediaSource"; private static final long DEFAULT_NOTIFY_MANIFEST_INTERVAL_US = 5000000; public static final long MIN_LIVE_DEFAULT_START_POSITION_US = 5000000; private static final String TAG = "DashMediaSource"; private final BaseUrlExclusionList baseUrlExclusionList; private final DashChunkSource.Factory chunkSourceFactory; @rq6 private final CmcdConfiguration cmcdConfiguration; private final CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory; private DataSource dataSource; @rq6 private final ae9 downloadExecutorSupplier; private final DrmSessionManager drmSessionManager; private long elapsedRealtimeOffsetMs; private long expiredManifestPublishTimeUs; private final long fallbackTargetLiveOffsetMs; private int firstPeriodId; private Handler handler; private Uri initialManifestUri; @qy3 private MediaItem.LiveConfiguration liveConfiguration; private final LoadErrorHandlingPolicy loadErrorHandlingPolicy; private Loader loader; private DashManifest manifest; private final ManifestCallback manifestCallback; private final DataSource.Factory manifestDataSourceFactory; private final MediaSourceEventListener.EventDispatcher manifestEventDispatcher; private IOException manifestFatalError; private long manifestLoadEndTimestampMs; private final LoaderErrorThrower manifestLoadErrorThrower; private boolean manifestLoadPending; private long manifestLoadStartTimestampMs; private final ParsingLoadable.Parser manifestParser; private Uri manifestUri; private final Object manifestUriLock; @qy3 private MediaItem mediaItem; @rq6 private TransferListener mediaTransferListener; private final long minLiveStartPositionUs; private final SparseArray periodsById; private final PlayerEmsgHandler.PlayerEmsgCallback playerEmsgCallback; private final Runnable refreshManifestRunnable; private final boolean sideloadedManifest; private final Runnable simulateManifestRefreshRunnable; private int staleManifestReloadAttempt; public static final class DashTimeline extends Timeline { private final long elapsedRealtimeEpochOffsetMs; private final int firstPeriodId; @rq6 private final MediaItem.LiveConfiguration liveConfiguration; private final DashManifest manifest; private final MediaItem mediaItem; private final long offsetInFirstPeriodUs; private final long presentationStartTimeMs; private final long windowDefaultStartPositionUs; private final long windowDurationUs; private final long windowStartTimeMs; public DashTimeline(long j, long j2, long j3, int i, long j4, long j5, long j6, DashManifest dashManifest, MediaItem mediaItem, @rq6 MediaItem.LiveConfiguration liveConfiguration) { if7.o(dashManifest.dynamic == (liveConfiguration != null)); this.presentationStartTimeMs = j; this.windowStartTimeMs = j2; this.elapsedRealtimeEpochOffsetMs = j3; this.firstPeriodId = i; this.offsetInFirstPeriodUs = j4; this.windowDurationUs = j5; this.windowDefaultStartPositionUs = j6; this.manifest = dashManifest; this.mediaItem = mediaItem; this.liveConfiguration = liveConfiguration; } private long getAdjustedWindowDefaultStartPositionUs(long j) { DashSegmentIndex index; long j2 = this.windowDefaultStartPositionUs; if (!isMovingLiveWindow(this.manifest)) { return j2; } if (j > 0) { j2 += j; if (j2 > this.windowDurationUs) { return C.TIME_UNSET; } } long j3 = this.offsetInFirstPeriodUs + j2; long periodDurationUs = this.manifest.getPeriodDurationUs(0); int i = 0; while (i < this.manifest.getPeriodCount() - 1 && j3 >= periodDurationUs) { j3 -= periodDurationUs; i++; periodDurationUs = this.manifest.getPeriodDurationUs(i); } Period period = this.manifest.getPeriod(i); int adaptationSetIndex = period.getAdaptationSetIndex(2); return (adaptationSetIndex == -1 || (index = period.adaptationSets.get(adaptationSetIndex).representations.get(0).getIndex()) == null || index.getSegmentCount(periodDurationUs) == 0) ? j2 : (index.getTimeUs(index.getSegmentNum(j3, periodDurationUs)) + j2) - j3; } private static boolean isMovingLiveWindow(DashManifest dashManifest) { return dashManifest.dynamic && dashManifest.minUpdatePeriodMs != C.TIME_UNSET && dashManifest.durationMs == C.TIME_UNSET; } @Override // androidx.media3.common.Timeline public int getIndexOfPeriod(Object obj) { int iIntValue; if ((obj instanceof Integer) && (iIntValue = ((Integer) obj).intValue() - this.firstPeriodId) >= 0 && iIntValue < getPeriodCount()) { return iIntValue; } return -1; } @Override // androidx.media3.common.Timeline public Timeline.Period getPeriod(int i, Timeline.Period period, boolean z) { if7.j(i, getPeriodCount()); return period.set(z ? this.manifest.getPeriod(i).id : null, z ? Integer.valueOf(this.firstPeriodId + i) : null, 0, this.manifest.getPeriodDurationUs(i), Util.msToUs(this.manifest.getPeriod(i).startMs - this.manifest.getPeriod(0).startMs) - this.offsetInFirstPeriodUs); } @Override // androidx.media3.common.Timeline public int getPeriodCount() { return this.manifest.getPeriodCount(); } @Override // androidx.media3.common.Timeline public Object getUidOfPeriod(int i) { if7.j(i, getPeriodCount()); return Integer.valueOf(this.firstPeriodId + i); } @Override // androidx.media3.common.Timeline public Timeline.Window getWindow(int i, Timeline.Window window, long j) { if7.j(i, 1); long adjustedWindowDefaultStartPositionUs = getAdjustedWindowDefaultStartPositionUs(j); Object obj = Timeline.Window.SINGLE_WINDOW_UID; MediaItem mediaItem = this.mediaItem; DashManifest dashManifest = this.manifest; return window.set(obj, mediaItem, dashManifest, this.presentationStartTimeMs, this.windowStartTimeMs, this.elapsedRealtimeEpochOffsetMs, true, isMovingLiveWindow(dashManifest), this.liveConfiguration, adjustedWindowDefaultStartPositionUs, this.windowDurationUs, 0, getPeriodCount() - 1, this.offsetInFirstPeriodUs); } @Override // androidx.media3.common.Timeline public int getWindowCount() { return 1; } } public final class DefaultPlayerEmsgCallback implements PlayerEmsgHandler.PlayerEmsgCallback { private DefaultPlayerEmsgCallback() { } @Override // androidx.media3.exoplayer.dash.PlayerEmsgHandler.PlayerEmsgCallback public void onDashManifestPublishTimeExpired(long j) { DashMediaSource.this.onDashManifestPublishTimeExpired(j); } @Override // androidx.media3.exoplayer.dash.PlayerEmsgHandler.PlayerEmsgCallback public void onDashManifestRefreshRequested() { DashMediaSource.this.onDashManifestRefreshRequested(); } } public static final class Factory implements MediaSourceFactory { public static final /* synthetic */ int a = 0; private final DashChunkSource.Factory chunkSourceFactory; @rq6 private CmcdConfiguration.Factory cmcdConfigurationFactory; private CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory; @rq6 private ae9 downloadExecutorSupplier; private DrmSessionManagerProvider drmSessionManagerProvider; private long fallbackTargetLiveOffsetMs; private LoadErrorHandlingPolicy loadErrorHandlingPolicy; @rq6 private final DataSource.Factory manifestDataSourceFactory; @rq6 private ParsingLoadable.Parser manifestParser; private long minLiveStartPositionUs; public Factory(DataSource.Factory factory) { this(new DefaultDashChunkSource.Factory(factory), factory); } @Override // androidx.media3.exoplayer.source.MediaSource.Factory public int[] getSupportedTypes() { return new int[]{0}; } @hs0 public Factory setCompositeSequenceableLoaderFactory(CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory) { if7.l(compositeSequenceableLoaderFactory, "DashMediaSource.Factory#setCompositeSequenceableLoaderFactory no longer handles null by instantiating a new DefaultCompositeSequenceableLoaderFactory. Explicitly construct and pass an instance in order to retain the old behavior."); this.compositeSequenceableLoaderFactory = compositeSequenceableLoaderFactory; return this; } @Override // androidx.media3.exoplayer.source.MediaSource.Factory @hs0 public /* bridge */ /* synthetic */ MediaSource.Factory setDownloadExecutor(ae9 ae9Var) { return setDownloadExecutor((ae9) ae9Var); } @hs0 public Factory setFallbackTargetLiveOffsetMs(long j) { this.fallbackTargetLiveOffsetMs = j; return this; } @hs0 public Factory setManifestParser(@rq6 ParsingLoadable.Parser parser) { this.manifestParser = parser; return this; } @hs0 public Factory setMinLiveStartPositionUs(long j) { this.minLiveStartPositionUs = j; return this; } public Factory(DashChunkSource.Factory factory, @rq6 DataSource.Factory factory2) { factory.getClass(); this.chunkSourceFactory = factory; this.manifestDataSourceFactory = factory2; this.drmSessionManagerProvider = new DefaultDrmSessionManagerProvider(); this.loadErrorHandlingPolicy = new DefaultLoadErrorHandlingPolicy(); this.fallbackTargetLiveOffsetMs = 30000L; this.minLiveStartPositionUs = 5000000L; this.compositeSequenceableLoaderFactory = new DefaultCompositeSequenceableLoaderFactory(); experimentalParseSubtitlesDuringExtraction(true); this.downloadExecutorSupplier = null; } public DashMediaSource createMediaSource(DashManifest dashManifest) { return createMediaSource(dashManifest, new MediaItem.Builder().setUri(Uri.EMPTY).setMediaId("DashMediaSource").setMimeType(MimeTypes.APPLICATION_MPD).build()); } @Override // androidx.media3.exoplayer.source.MediaSource.Factory @hs0 @Deprecated public Factory experimentalParseSubtitlesDuringExtraction(boolean z) { this.chunkSourceFactory.experimentalParseSubtitlesDuringExtraction(z); return this; } @Override // androidx.media3.exoplayer.source.MediaSource.Factory @hs0 public Factory experimentalSetCodecsToParseWithinGopSampleDependencies(int i) { this.chunkSourceFactory.experimentalSetCodecsToParseWithinGopSampleDependencies(i); return this; } @Override // androidx.media3.exoplayer.source.MediaSource.Factory @hs0 public Factory setCmcdConfigurationFactory(CmcdConfiguration.Factory factory) { factory.getClass(); this.cmcdConfigurationFactory = factory; return this; } @Override // androidx.media3.exoplayer.source.MediaSource.Factory @hs0 public Factory setDownloadExecutor(ae9 ae9Var) { this.downloadExecutorSupplier = ae9Var; return this; } @Override // androidx.media3.exoplayer.source.MediaSource.Factory @hs0 public Factory setDrmSessionManagerProvider(DrmSessionManagerProvider drmSessionManagerProvider) { if7.l(drmSessionManagerProvider, "MediaSource.Factory#setDrmSessionManagerProvider no longer handles null by instantiating a new DefaultDrmSessionManagerProvider. Explicitly construct and pass an instance in order to retain the old behavior."); this.drmSessionManagerProvider = drmSessionManagerProvider; return this; } @Override // androidx.media3.exoplayer.source.MediaSource.Factory @hs0 public Factory setLoadErrorHandlingPolicy(LoadErrorHandlingPolicy loadErrorHandlingPolicy) { if7.l(loadErrorHandlingPolicy, "MediaSource.Factory#setLoadErrorHandlingPolicy no longer handles null by instantiating a new DefaultLoadErrorHandlingPolicy. Explicitly construct and pass an instance in order to retain the old behavior."); this.loadErrorHandlingPolicy = loadErrorHandlingPolicy; return this; } @Override // androidx.media3.exoplayer.source.MediaSource.Factory @hs0 public Factory setSubtitleParserFactory(SubtitleParser.Factory factory) { DashChunkSource.Factory factory2 = this.chunkSourceFactory; factory.getClass(); factory2.setSubtitleParserFactory(factory); return this; } public DashMediaSource createMediaSource(DashManifest dashManifest, MediaItem mediaItem) { if7.e(!dashManifest.dynamic); MediaItem.Builder mimeType = mediaItem.buildUpon().setMimeType(MimeTypes.APPLICATION_MPD); if (mediaItem.localConfiguration == null) { mimeType.setUri(Uri.EMPTY); } MediaItem mediaItemBuild = mimeType.build(); CmcdConfiguration.Factory factory = this.cmcdConfigurationFactory; return new DashMediaSource(mediaItemBuild, dashManifest, null, null, this.chunkSourceFactory, this.compositeSequenceableLoaderFactory, factory == null ? null : factory.createCmcdConfiguration(mediaItemBuild), this.drmSessionManagerProvider.get(mediaItemBuild), this.loadErrorHandlingPolicy, this.fallbackTargetLiveOffsetMs, this.minLiveStartPositionUs, this.downloadExecutorSupplier); } @Override // androidx.media3.exoplayer.source.MediaSource.Factory public DashMediaSource createMediaSource(MediaItem mediaItem) { mediaItem.localConfiguration.getClass(); ParsingLoadable.Parser dashManifestParser = this.manifestParser; if (dashManifestParser == null) { dashManifestParser = new DashManifestParser(); } List list = mediaItem.localConfiguration.streamKeys; ParsingLoadable.Parser filteringManifestParser = !list.isEmpty() ? new FilteringManifestParser(dashManifestParser, list) : dashManifestParser; CmcdConfiguration.Factory factory = this.cmcdConfigurationFactory; return new DashMediaSource(mediaItem, null, this.manifestDataSourceFactory, filteringManifestParser, this.chunkSourceFactory, this.compositeSequenceableLoaderFactory, factory == null ? null : factory.createCmcdConfiguration(mediaItem), this.drmSessionManagerProvider.get(mediaItem), this.loadErrorHandlingPolicy, this.fallbackTargetLiveOffsetMs, this.minLiveStartPositionUs, this.downloadExecutorSupplier); } } public static final class Iso8601Parser implements ParsingLoadable.Parser { private static final Pattern TIMESTAMP_WITH_TIMEZONE_PATTERN = Pattern.compile("(.+?)(Z|((\\+|-|−)(\\d\\d)(:?(\\d\\d))?))"); /* JADX WARN: Can't rename method to resolve collision */ @Override // androidx.media3.exoplayer.upstream.ParsingLoadable.Parser public Long parse(Uri uri, InputStream inputStream) throws IOException { String line = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)).readLine(); try { Matcher matcher = TIMESTAMP_WITH_TIMEZONE_PATTERN.matcher(line); if (!matcher.matches()) { throw ParserException.createForMalformedManifest("Couldn't parse timestamp: " + line, null); } String strGroup = matcher.group(1); SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.US); simpleDateFormat.setTimeZone(TimeZone.getTimeZone("UTC")); long time = simpleDateFormat.parse(strGroup).getTime(); if (!"Z".equals(matcher.group(2))) { long j = "+".equals(matcher.group(4)) ? 1L : -1L; long j2 = Long.parseLong(matcher.group(5)); String strGroup2 = matcher.group(7); time -= (((j2 * 60) + (TextUtils.isEmpty(strGroup2) ? 0L : Long.parseLong(strGroup2))) * 60000) * j; } return Long.valueOf(time); } catch (ParseException e) { throw ParserException.createForMalformedManifest(null, e); } } } public final class ManifestCallback implements Loader.Callback> { private ManifestCallback() { } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadCanceled(ParsingLoadable parsingLoadable, long j, long j2, boolean z) { DashMediaSource.this.onLoadCanceled(parsingLoadable, j, j2); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadCompleted(ParsingLoadable parsingLoadable, long j, long j2) { DashMediaSource.this.onManifestLoadCompleted(parsingLoadable, j, j2); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public Loader.LoadErrorAction onLoadError(ParsingLoadable parsingLoadable, long j, long j2, IOException iOException, int i) { return DashMediaSource.this.onManifestLoadError(parsingLoadable, j, j2, iOException, i); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadStarted(ParsingLoadable parsingLoadable, long j, long j2, int i) { DashMediaSource.this.onManifestLoadStarted(parsingLoadable, j, j2, i); } } public final class UtcTimestampCallback implements Loader.Callback> { private UtcTimestampCallback() { } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadCanceled(ParsingLoadable parsingLoadable, long j, long j2, boolean z) { DashMediaSource.this.onLoadCanceled(parsingLoadable, j, j2); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public void onLoadCompleted(ParsingLoadable parsingLoadable, long j, long j2) { DashMediaSource.this.onUtcTimestampLoadCompleted(parsingLoadable, j, j2); } @Override // androidx.media3.exoplayer.upstream.Loader.Callback public Loader.LoadErrorAction onLoadError(ParsingLoadable parsingLoadable, long j, long j2, IOException iOException, int i) { return DashMediaSource.this.onUtcTimestampLoadError(parsingLoadable, j, j2, iOException); } } public static final class XsDateTimeParser implements ParsingLoadable.Parser { private XsDateTimeParser() { } /* JADX WARN: Can't rename method to resolve collision */ @Override // androidx.media3.exoplayer.upstream.ParsingLoadable.Parser public Long parse(Uri uri, InputStream inputStream) throws IOException { return Long.valueOf(Util.parseXsDateTime(new BufferedReader(new InputStreamReader(inputStream)).readLine())); } } static { MediaLibraryInfo.registerModule("media3.exoplayer.dash"); } private static long getAvailableEndTimeInManifestUs(Period period, long j, long j2) { long jMsToUs = Util.msToUs(period.startMs); boolean zHasVideoOrAudioAdaptationSets = hasVideoOrAudioAdaptationSets(period); long jMin = Long.MAX_VALUE; for (int i = 0; i < period.adaptationSets.size(); i++) { AdaptationSet adaptationSet = period.adaptationSets.get(i); List list = adaptationSet.representations; int i2 = adaptationSet.type; boolean z = (i2 == 1 || i2 == 2) ? false : true; if ((!zHasVideoOrAudioAdaptationSets || !z) && !list.isEmpty()) { DashSegmentIndex index = list.get(0).getIndex(); if (index == null) { return jMsToUs + j; } long availableSegmentCount = index.getAvailableSegmentCount(j, j2); if (availableSegmentCount == 0) { return jMsToUs; } long firstAvailableSegmentNum = (index.getFirstAvailableSegmentNum(j, j2) + availableSegmentCount) - 1; jMin = Math.min(jMin, index.getDurationUs(firstAvailableSegmentNum, j) + index.getTimeUs(firstAvailableSegmentNum) + jMsToUs); } } return jMin; } private static long getAvailableStartTimeInManifestUs(Period period, long j, long j2) { long jMsToUs = Util.msToUs(period.startMs); boolean zHasVideoOrAudioAdaptationSets = hasVideoOrAudioAdaptationSets(period); long jMax = jMsToUs; for (int i = 0; i < period.adaptationSets.size(); i++) { AdaptationSet adaptationSet = period.adaptationSets.get(i); List list = adaptationSet.representations; int i2 = adaptationSet.type; boolean z = (i2 == 1 || i2 == 2) ? false : true; if ((!zHasVideoOrAudioAdaptationSets || !z) && !list.isEmpty()) { DashSegmentIndex index = list.get(0).getIndex(); if (index == null || index.getAvailableSegmentCount(j, j2) == 0) { return jMsToUs; } jMax = Math.max(jMax, index.getTimeUs(index.getFirstAvailableSegmentNum(j, j2)) + jMsToUs); } } return jMax; } private static long getIntervalUntilNextManifestRefreshMs(DashManifest dashManifest, long j) { DashSegmentIndex index; int periodCount = dashManifest.getPeriodCount() - 1; Period period = dashManifest.getPeriod(periodCount); long jMsToUs = Util.msToUs(period.startMs); long periodDurationUs = dashManifest.getPeriodDurationUs(periodCount); long jMsToUs2 = Util.msToUs(j); long jMsToUs3 = Util.msToUs(dashManifest.availabilityStartTimeMs); long jMsToUs4 = Util.msToUs(dashManifest.minUpdatePeriodMs); if (jMsToUs4 == C.TIME_UNSET || jMsToUs4 >= 5000000) { jMsToUs4 = 5000000; } for (int i = 0; i < period.adaptationSets.size(); i++) { List list = period.adaptationSets.get(i).representations; if (!list.isEmpty() && (index = list.get(0).getIndex()) != null) { long nextSegmentAvailableTimeUs = (index.getNextSegmentAvailableTimeUs(periodDurationUs, jMsToUs2) + (jMsToUs3 + jMsToUs)) - jMsToUs2; if (nextSegmentAvailableTimeUs > 0 && (nextSegmentAvailableTimeUs < jMsToUs4 - SilenceSkippingAudioProcessor.DEFAULT_MINIMUM_SILENCE_DURATION_US || (nextSegmentAvailableTimeUs > jMsToUs4 && nextSegmentAvailableTimeUs < SilenceSkippingAudioProcessor.DEFAULT_MINIMUM_SILENCE_DURATION_US + jMsToUs4))) { jMsToUs4 = nextSegmentAvailableTimeUs; } } } return xi5.b(jMsToUs4, 1000L, RoundingMode.CEILING); } private synchronized MediaItem.LiveConfiguration getLiveConfiguration() { return this.liveConfiguration; } private long getManifestLoadRetryDelayMillis() { return Math.min((this.staleManifestReloadAttempt - 1) * 1000, 5000); } private static boolean hasVideoOrAudioAdaptationSets(Period period) { for (int i = 0; i < period.adaptationSets.size(); i++) { int i2 = period.adaptationSets.get(i).type; if (i2 == 1 || i2 == 2) { return true; } } return false; } private static boolean isIndexExplicit(Period period) { for (int i = 0; i < period.adaptationSets.size(); i++) { DashSegmentIndex index = period.adaptationSets.get(i).representations.get(0).getIndex(); if (index == null || index.isExplicit()) { return true; } } return false; } private void loadNtpTimeOffset() { SntpClient.initialize(this.loader, new SntpClient.InitializationCallback() { // from class: androidx.media3.exoplayer.dash.DashMediaSource.1 @Override // androidx.media3.exoplayer.util.SntpClient.InitializationCallback public void onInitializationFailed(IOException iOException) { DashMediaSource.this.onUtcTimestampResolutionError(iOException); } @Override // androidx.media3.exoplayer.util.SntpClient.InitializationCallback public void onInitialized() { DashMediaSource.this.onUtcTimestampResolved(SntpClient.getElapsedRealtimeOffsetMs()); } }); } /* JADX INFO: Access modifiers changed from: private */ public void onUtcTimestampResolutionError(IOException iOException) { Log.e("DashMediaSource", "Failed to resolve time offset.", iOException); this.elapsedRealtimeOffsetMs = System.currentTimeMillis() - SystemClock.elapsedRealtime(); processManifest(true); } /* JADX INFO: Access modifiers changed from: private */ public void onUtcTimestampResolved(long j) { this.elapsedRealtimeOffsetMs = j; processManifest(true); } private void processManifest(boolean z) { long j; long j2; long j3; for (int i = 0; i < this.periodsById.size(); i++) { int iKeyAt = this.periodsById.keyAt(i); if (iKeyAt >= this.firstPeriodId) { this.periodsById.valueAt(i).updateManifest(this.manifest, iKeyAt - this.firstPeriodId); } } Period period = this.manifest.getPeriod(0); int periodCount = this.manifest.getPeriodCount() - 1; Period period2 = this.manifest.getPeriod(periodCount); long periodDurationUs = this.manifest.getPeriodDurationUs(periodCount); long jMsToUs = Util.msToUs(Util.getNowUnixTimeMs(this.elapsedRealtimeOffsetMs)); long availableStartTimeInManifestUs = getAvailableStartTimeInManifestUs(period, this.manifest.getPeriodDurationUs(0), jMsToUs); long availableEndTimeInManifestUs = getAvailableEndTimeInManifestUs(period2, periodDurationUs, jMsToUs); boolean z2 = this.manifest.dynamic && !isIndexExplicit(period2); if (z2) { long j4 = this.manifest.timeShiftBufferDepthMs; if (j4 != C.TIME_UNSET) { availableStartTimeInManifestUs = Math.max(availableStartTimeInManifestUs, availableEndTimeInManifestUs - Util.msToUs(j4)); } } long j5 = availableEndTimeInManifestUs - availableStartTimeInManifestUs; DashManifest dashManifest = this.manifest; if (dashManifest.dynamic) { if7.o(dashManifest.availabilityStartTimeMs != C.TIME_UNSET); long jMsToUs2 = (jMsToUs - Util.msToUs(this.manifest.availabilityStartTimeMs)) - availableStartTimeInManifestUs; updateLiveConfiguration(jMsToUs2, j5); long jUsToMs = Util.usToMs(availableStartTimeInManifestUs) + this.manifest.availabilityStartTimeMs; long jMsToUs3 = jMsToUs2 - Util.msToUs(getLiveConfiguration().targetOffsetMs); j = 0; long jMin = Math.min(this.minLiveStartPositionUs, j5 / 2); j3 = jMsToUs3 < jMin ? jMin : jMsToUs3; j2 = jUsToMs; } else { j = 0; j2 = -9223372036854775807L; j3 = 0; } long jMsToUs4 = availableStartTimeInManifestUs - Util.msToUs(period.startMs); DashManifest dashManifest2 = this.manifest; refreshSourceInfo(new DashTimeline(dashManifest2.availabilityStartTimeMs, j2, this.elapsedRealtimeOffsetMs, this.firstPeriodId, jMsToUs4, j5, j3, dashManifest2, getMediaItem(), this.manifest.dynamic ? getLiveConfiguration() : null)); if (this.sideloadedManifest) { return; } this.handler.removeCallbacks(this.simulateManifestRefreshRunnable); if (z2) { this.handler.postDelayed(this.simulateManifestRefreshRunnable, getIntervalUntilNextManifestRefreshMs(this.manifest, Util.getNowUnixTimeMs(this.elapsedRealtimeOffsetMs))); } if (this.manifestLoadPending) { startLoadingManifest(); return; } if (z) { DashManifest dashManifest3 = this.manifest; if (dashManifest3.dynamic) { long j6 = dashManifest3.minUpdatePeriodMs; if (j6 != C.TIME_UNSET) { if (j6 == j) { j6 = 5000; } scheduleManifestRefresh(Math.max(j, (this.manifestLoadStartTimestampMs + j6) - SystemClock.elapsedRealtime())); } } } } private void resolveUtcTimingElement(UtcTimingElement utcTimingElement) { String str = utcTimingElement.schemeIdUri; if (Objects.equals(str, "urn:mpeg:dash:utc:direct:2014") || Objects.equals(str, "urn:mpeg:dash:utc:direct:2012")) { resolveUtcTimingElementDirect(utcTimingElement); return; } if (Objects.equals(str, "urn:mpeg:dash:utc:http-iso:2014") || Objects.equals(str, "urn:mpeg:dash:utc:http-iso:2012")) { resolveUtcTimingElementHttp(utcTimingElement, new Iso8601Parser()); return; } if (Objects.equals(str, "urn:mpeg:dash:utc:http-xsdate:2014") || Objects.equals(str, "urn:mpeg:dash:utc:http-xsdate:2012")) { resolveUtcTimingElementHttp(utcTimingElement, new XsDateTimeParser()); } else if (Objects.equals(str, "urn:mpeg:dash:utc:ntp:2014") || Objects.equals(str, "urn:mpeg:dash:utc:ntp:2012")) { loadNtpTimeOffset(); } else { onUtcTimestampResolutionError(new IOException("Unsupported UTC timing scheme")); } } private void resolveUtcTimingElementDirect(UtcTimingElement utcTimingElement) { try { onUtcTimestampResolved(Util.parseXsDateTime(utcTimingElement.value) - this.manifestLoadEndTimestampMs); } catch (ParserException e) { onUtcTimestampResolutionError(e); } } private void resolveUtcTimingElementHttp(UtcTimingElement utcTimingElement, ParsingLoadable.Parser parser) { startLoading(new ParsingLoadable(this.dataSource, Uri.parse(utcTimingElement.value), 5, parser), new UtcTimestampCallback(), 1); } private void scheduleManifestRefresh(long j) { this.handler.postDelayed(this.refreshManifestRunnable, j); } private synchronized void setLiveConfiguration(MediaItem.LiveConfiguration liveConfiguration) { this.liveConfiguration = liveConfiguration; } /* JADX INFO: Access modifiers changed from: private */ public void simulateManifestRefresh() { try { processManifest(false); } catch (Exception e) { this.manifestFatalError = new IOException(e); } } private void startLoading(ParsingLoadable parsingLoadable, Loader.Callback> callback, int i) { this.loader.startLoading(parsingLoadable, callback, i); } /* JADX INFO: Access modifiers changed from: private */ public void startLoadingManifest() { Uri uri; this.handler.removeCallbacks(this.refreshManifestRunnable); if (this.loader.hasFatalError()) { return; } if (this.loader.isLoading()) { this.manifestLoadPending = true; return; } synchronized (this.manifestUriLock) { uri = this.manifestUri; } this.manifestLoadPending = false; DataSpec dataSpecBuild = new DataSpec.Builder().setUri(uri).setFlags(1).build(); if (this.cmcdConfiguration != null) { CmcdData.Factory objectType = new CmcdData.Factory(this.cmcdConfiguration, "d").setObjectType(CmcdData.OBJECT_TYPE_MANIFEST); DashManifest dashManifest = this.manifest; if (dashManifest != null) { objectType.setIsLive(dashManifest.dynamic); } dataSpecBuild = objectType.createCmcdData().addToDataSpec(dataSpecBuild); } startLoading(new ParsingLoadable(this.dataSource, dataSpecBuild, 4, this.manifestParser), this.manifestCallback, this.loadErrorHandlingPolicy.getMinimumLoadableRetryCount(4)); } /* JADX WARN: Removed duplicated region for block: B:19:0x0048 */ /* JADX WARN: Removed duplicated region for block: B:22:0x0054 */ /* JADX WARN: Removed duplicated region for block: B:24:0x005a */ /* JADX WARN: Removed duplicated region for block: B:31:0x006f */ /* JADX WARN: Removed duplicated region for block: B:32:0x0072 */ /* JADX WARN: Removed duplicated region for block: B:36:0x007f */ /* JADX WARN: Removed duplicated region for block: B:41:0x008d */ /* JADX WARN: Removed duplicated region for block: B:47:0x009a */ /* JADX WARN: Removed duplicated region for block: B:50:0x009f */ /* JADX WARN: Removed duplicated region for block: B:54:0x00bf */ /* JADX WARN: Removed duplicated region for block: B:61:0x00d0 */ /* Code decompiled incorrectly, please refer to instructions dump. */ private void updateLiveConfiguration(long j, long j2) { long j3; long jMin; long jUsToMs; long j4; long j5; long j6; long j7; long jConstrainValue; float f; float f2; ServiceDescriptionElement serviceDescriptionElement; MediaItem.LiveConfiguration liveConfiguration = getMediaItem().liveConfiguration; long jUsToMs2 = Util.usToMs(j); long j8 = liveConfiguration.maxOffsetMs; if (j8 == C.TIME_UNSET) { ServiceDescriptionElement serviceDescriptionElement2 = this.manifest.serviceDescription; if (serviceDescriptionElement2 != null) { long j9 = serviceDescriptionElement2.maxOffsetMs; if (j9 != C.TIME_UNSET) { jMin = Math.min(jUsToMs2, j9); } } j3 = jUsToMs2; jUsToMs = Util.usToMs(j - j2); if (jUsToMs < 0 && j3 > 0) { jUsToMs = 0; } j4 = this.manifest.minBufferTimeMs; if (j4 != C.TIME_UNSET) { jUsToMs = Math.min(jUsToMs + j4, jUsToMs2); } long jConstrainValue2 = jUsToMs; j5 = liveConfiguration.minOffsetMs; if (j5 == C.TIME_UNSET) { jConstrainValue2 = Util.constrainValue(j5, jConstrainValue2, jUsToMs2); } else { ServiceDescriptionElement serviceDescriptionElement3 = this.manifest.serviceDescription; if (serviceDescriptionElement3 != null) { long j10 = serviceDescriptionElement3.minOffsetMs; if (j10 != C.TIME_UNSET) { jConstrainValue2 = Util.constrainValue(j10, jConstrainValue2, jUsToMs2); } } } j6 = jConstrainValue2; j7 = j6 <= j3 ? j6 : j3; jConstrainValue = getLiveConfiguration().targetOffsetMs; if (jConstrainValue == C.TIME_UNSET) { DashManifest dashManifest = this.manifest; ServiceDescriptionElement serviceDescriptionElement4 = dashManifest.serviceDescription; if (serviceDescriptionElement4 != null) { long j11 = serviceDescriptionElement4.targetOffsetMs; if (j11 != C.TIME_UNSET) { jConstrainValue = j11; } else { jConstrainValue = dashManifest.suggestedPresentationDelayMs; if (jConstrainValue == C.TIME_UNSET) { jConstrainValue = this.fallbackTargetLiveOffsetMs; } } } } if (jConstrainValue < j6) { jConstrainValue = j6; } if (jConstrainValue > j7) { jConstrainValue = Util.constrainValue(Util.usToMs(j - Math.min(this.minLiveStartPositionUs, j2 / 2)), j6, j7); } long j12 = j7; f = liveConfiguration.minPlaybackSpeed; if (f == -3.4028235E38f) { ServiceDescriptionElement serviceDescriptionElement5 = this.manifest.serviceDescription; f = serviceDescriptionElement5 != null ? serviceDescriptionElement5.minPlaybackSpeed : -3.4028235E38f; } f2 = liveConfiguration.maxPlaybackSpeed; if (f2 == -3.4028235E38f) { ServiceDescriptionElement serviceDescriptionElement6 = this.manifest.serviceDescription; f2 = serviceDescriptionElement6 != null ? serviceDescriptionElement6.maxPlaybackSpeed : -3.4028235E38f; } if (f == -3.4028235E38f && f2 == -3.4028235E38f && ((serviceDescriptionElement = this.manifest.serviceDescription) == null || serviceDescriptionElement.targetOffsetMs == C.TIME_UNSET)) { f = 1.0f; f2 = 1.0f; } setLiveConfiguration(new MediaItem.LiveConfiguration.Builder().setTargetOffsetMs(jConstrainValue).setMinOffsetMs(j6).setMaxOffsetMs(j12).setMinPlaybackSpeed(f).setMaxPlaybackSpeed(f2).build()); } jMin = Math.min(jUsToMs2, j8); j3 = jMin; jUsToMs = Util.usToMs(j - j2); if (jUsToMs < 0) { jUsToMs = 0; } j4 = this.manifest.minBufferTimeMs; if (j4 != C.TIME_UNSET) { } long jConstrainValue22 = jUsToMs; j5 = liveConfiguration.minOffsetMs; if (j5 == C.TIME_UNSET) { } j6 = jConstrainValue22; if (j6 <= j3) { } jConstrainValue = getLiveConfiguration().targetOffsetMs; if (jConstrainValue == C.TIME_UNSET) { } if (jConstrainValue < j6) { } if (jConstrainValue > j7) { } long j122 = j7; f = liveConfiguration.minPlaybackSpeed; if (f == -3.4028235E38f) { } f2 = liveConfiguration.maxPlaybackSpeed; if (f2 == -3.4028235E38f) { } if (f == -3.4028235E38f) { f = 1.0f; f2 = 1.0f; } setLiveConfiguration(new MediaItem.LiveConfiguration.Builder().setTargetOffsetMs(jConstrainValue).setMinOffsetMs(j6).setMaxOffsetMs(j122).setMinPlaybackSpeed(f).setMaxPlaybackSpeed(f2).build()); } @Override // androidx.media3.exoplayer.source.MediaSource public boolean canUpdateMediaItem(MediaItem mediaItem) { MediaItem.LocalConfiguration localConfiguration = getMediaItem().localConfiguration; localConfiguration.getClass(); MediaItem.LocalConfiguration localConfiguration2 = mediaItem.localConfiguration; return localConfiguration2 != null && localConfiguration2.uri.equals(localConfiguration.uri) && localConfiguration2.streamKeys.equals(localConfiguration.streamKeys) && Objects.equals(localConfiguration2.drmConfiguration, localConfiguration.drmConfiguration); } @Override // androidx.media3.exoplayer.source.MediaSource public MediaPeriod createPeriod(MediaSource.MediaPeriodId mediaPeriodId, Allocator allocator, long j) { int iIntValue = ((Integer) mediaPeriodId.periodUid).intValue() - this.firstPeriodId; MediaSourceEventListener.EventDispatcher eventDispatcherCreateEventDispatcher = createEventDispatcher(mediaPeriodId); DashMediaPeriod dashMediaPeriod = new DashMediaPeriod(this.firstPeriodId + iIntValue, this.manifest, this.baseUrlExclusionList, iIntValue, this.chunkSourceFactory, this.mediaTransferListener, this.cmcdConfiguration, this.drmSessionManager, createDrmEventDispatcher(mediaPeriodId), this.loadErrorHandlingPolicy, eventDispatcherCreateEventDispatcher, this.elapsedRealtimeOffsetMs, this.manifestLoadErrorThrower, allocator, this.compositeSequenceableLoaderFactory, this.playerEmsgCallback, getPlayerId(), this.downloadExecutorSupplier); this.periodsById.put(dashMediaPeriod.id, dashMediaPeriod); return dashMediaPeriod; } @Override // androidx.media3.exoplayer.source.MediaSource public synchronized MediaItem getMediaItem() { return this.mediaItem; } @Override // androidx.media3.exoplayer.source.MediaSource public void maybeThrowSourceInfoRefreshError() throws IOException { this.manifestLoadErrorThrower.maybeThrowError(); } public void onDashManifestPublishTimeExpired(long j) { long j2 = this.expiredManifestPublishTimeUs; if (j2 == C.TIME_UNSET || j2 < j) { this.expiredManifestPublishTimeUs = j; } } public void onDashManifestRefreshRequested() { this.handler.removeCallbacks(this.simulateManifestRefreshRunnable); startLoadingManifest(); } public void onLoadCanceled(ParsingLoadable parsingLoadable, long j, long j2) { LoadEventInfo loadEventInfo = new LoadEventInfo(parsingLoadable.loadTaskId, parsingLoadable.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded()); this.loadErrorHandlingPolicy.onLoadTaskConcluded(parsingLoadable.loadTaskId); this.manifestEventDispatcher.loadCanceled(loadEventInfo, parsingLoadable.type); } public void onManifestLoadCompleted(ParsingLoadable parsingLoadable, long j, long j2) { LoadEventInfo loadEventInfo = new LoadEventInfo(parsingLoadable.loadTaskId, parsingLoadable.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded()); this.loadErrorHandlingPolicy.onLoadTaskConcluded(parsingLoadable.loadTaskId); this.manifestEventDispatcher.loadCompleted(loadEventInfo, parsingLoadable.type); DashManifest result = parsingLoadable.getResult(); DashManifest dashManifest = this.manifest; int periodCount = dashManifest == null ? 0 : dashManifest.getPeriodCount(); long j3 = result.getPeriod(0).startMs; int i = 0; while (i < periodCount && this.manifest.getPeriod(i).startMs < j3) { i++; } if (result.dynamic) { if (periodCount - i > result.getPeriodCount()) { Log.w("DashMediaSource", "Loaded out of sync manifest"); } else { long j4 = this.expiredManifestPublishTimeUs; if (j4 == C.TIME_UNSET || result.publishTimeMs * 1000 > j4) { this.staleManifestReloadAttempt = 0; } else { Log.w("DashMediaSource", "Loaded stale dynamic manifest: " + result.publishTimeMs + ", " + this.expiredManifestPublishTimeUs); } } int i2 = this.staleManifestReloadAttempt; this.staleManifestReloadAttempt = i2 + 1; if (i2 < this.loadErrorHandlingPolicy.getMinimumLoadableRetryCount(parsingLoadable.type)) { scheduleManifestRefresh(getManifestLoadRetryDelayMillis()); return; } else { this.manifestFatalError = new DashManifestStaleException(); return; } } this.manifest = result; this.manifestLoadPending = result.dynamic & this.manifestLoadPending; this.manifestLoadStartTimestampMs = j - j2; this.manifestLoadEndTimestampMs = j; this.firstPeriodId += i; synchronized (this.manifestUriLock) { try { if (parsingLoadable.dataSpec.uri.equals(this.manifestUri) || (this.cmcdConfiguration != null && CmcdData.removeFromUri(parsingLoadable.dataSpec.uri).equals(this.manifestUri))) { Uri uriRemoveFromUri = this.manifest.location; if (uriRemoveFromUri == null) { uriRemoveFromUri = CmcdData.removeFromUri(parsingLoadable.getUri()); } this.manifestUri = uriRemoveFromUri; } } catch (Throwable th) { throw th; } } DashManifest dashManifest2 = this.manifest; if (!dashManifest2.dynamic || this.elapsedRealtimeOffsetMs != C.TIME_UNSET) { processManifest(true); return; } UtcTimingElement utcTimingElement = dashManifest2.utcTiming; if (utcTimingElement != null) { resolveUtcTimingElement(utcTimingElement); } else { loadNtpTimeOffset(); } } public Loader.LoadErrorAction onManifestLoadError(ParsingLoadable parsingLoadable, long j, long j2, IOException iOException, int i) { LoadEventInfo loadEventInfo = new LoadEventInfo(parsingLoadable.loadTaskId, parsingLoadable.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded()); long retryDelayMsFor = this.loadErrorHandlingPolicy.getRetryDelayMsFor(new LoadErrorHandlingPolicy.LoadErrorInfo(loadEventInfo, new MediaLoadData(parsingLoadable.type), iOException, i)); Loader.LoadErrorAction loadErrorActionCreateRetryAction = retryDelayMsFor == C.TIME_UNSET ? Loader.DONT_RETRY_FATAL : Loader.createRetryAction(false, retryDelayMsFor); boolean zIsRetry = loadErrorActionCreateRetryAction.isRetry(); this.manifestEventDispatcher.loadError(loadEventInfo, parsingLoadable.type, iOException, !zIsRetry); if (!zIsRetry) { this.loadErrorHandlingPolicy.onLoadTaskConcluded(parsingLoadable.loadTaskId); } return loadErrorActionCreateRetryAction; } public void onManifestLoadStarted(ParsingLoadable parsingLoadable, long j, long j2, int i) { this.manifestEventDispatcher.loadStarted(i == 0 ? new LoadEventInfo(parsingLoadable.loadTaskId, parsingLoadable.dataSpec, j) : new LoadEventInfo(parsingLoadable.loadTaskId, parsingLoadable.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded()), parsingLoadable.type, i); } public void onUtcTimestampLoadCompleted(ParsingLoadable parsingLoadable, long j, long j2) { LoadEventInfo loadEventInfo = new LoadEventInfo(parsingLoadable.loadTaskId, parsingLoadable.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded()); this.loadErrorHandlingPolicy.onLoadTaskConcluded(parsingLoadable.loadTaskId); this.manifestEventDispatcher.loadCompleted(loadEventInfo, parsingLoadable.type); onUtcTimestampResolved(parsingLoadable.getResult().longValue() - j); } public Loader.LoadErrorAction onUtcTimestampLoadError(ParsingLoadable parsingLoadable, long j, long j2, IOException iOException) { this.manifestEventDispatcher.loadError(new LoadEventInfo(parsingLoadable.loadTaskId, parsingLoadable.dataSpec, parsingLoadable.getUri(), parsingLoadable.getResponseHeaders(), j, j2, parsingLoadable.bytesLoaded()), parsingLoadable.type, iOException, true); this.loadErrorHandlingPolicy.onLoadTaskConcluded(parsingLoadable.loadTaskId); onUtcTimestampResolutionError(iOException); return Loader.DONT_RETRY; } @Override // androidx.media3.exoplayer.source.BaseMediaSource public void prepareSourceInternal(@rq6 TransferListener transferListener) { this.mediaTransferListener = transferListener; this.drmSessionManager.setPlayer(Looper.myLooper(), getPlayerId()); this.drmSessionManager.prepare(); if (this.sideloadedManifest) { processManifest(false); return; } this.dataSource = this.manifestDataSourceFactory.createDataSource(); this.loader = this.downloadExecutorSupplier != null ? new Loader((ReleasableExecutor) this.downloadExecutorSupplier.get()) : new Loader("DashMediaSource"); this.handler = Util.createHandlerForCurrentLooper(); startLoadingManifest(); } @Override // androidx.media3.exoplayer.source.MediaSource public void releasePeriod(MediaPeriod mediaPeriod) { DashMediaPeriod dashMediaPeriod = (DashMediaPeriod) mediaPeriod; dashMediaPeriod.release(); this.periodsById.remove(dashMediaPeriod.id); } @Override // androidx.media3.exoplayer.source.BaseMediaSource public void releaseSourceInternal() { this.manifestLoadPending = false; this.dataSource = null; Loader loader = this.loader; if (loader != null) { loader.release(); this.loader = null; } setLiveConfiguration(getMediaItem().liveConfiguration); this.manifestLoadStartTimestampMs = 0L; this.manifestLoadEndTimestampMs = 0L; this.manifestUri = this.initialManifestUri; this.manifestFatalError = null; Handler handler = this.handler; if (handler != null) { handler.removeCallbacksAndMessages(null); this.handler = null; } this.elapsedRealtimeOffsetMs = C.TIME_UNSET; this.staleManifestReloadAttempt = 0; this.expiredManifestPublishTimeUs = C.TIME_UNSET; this.periodsById.clear(); this.baseUrlExclusionList.reset(); this.drmSessionManager.release(); } public void replaceManifestUri(Uri uri) { synchronized (this.manifestUriLock) { this.manifestUri = uri; this.initialManifestUri = uri; } } @Override // androidx.media3.exoplayer.source.MediaSource public synchronized void updateMediaItem(MediaItem mediaItem) { this.mediaItem = mediaItem; this.liveConfiguration = mediaItem.liveConfiguration; } public final class ManifestLoadErrorThrower implements LoaderErrorThrower { public ManifestLoadErrorThrower() { } private void maybeThrowManifestError() throws IOException { if (DashMediaSource.this.manifestFatalError != null) { throw DashMediaSource.this.manifestFatalError; } } @Override // androidx.media3.exoplayer.upstream.LoaderErrorThrower public void maybeThrowError() throws IOException { DashMediaSource.this.loader.maybeThrowError(); maybeThrowManifestError(); } @Override // androidx.media3.exoplayer.upstream.LoaderErrorThrower public void maybeThrowError(int i) throws IOException { DashMediaSource.this.loader.maybeThrowError(i); maybeThrowManifestError(); } } private DashMediaSource(MediaItem mediaItem, @rq6 DashManifest dashManifest, @rq6 DataSource.Factory factory, @rq6 ParsingLoadable.Parser parser, DashChunkSource.Factory factory2, CompositeSequenceableLoaderFactory compositeSequenceableLoaderFactory, @rq6 CmcdConfiguration cmcdConfiguration, DrmSessionManager drmSessionManager, LoadErrorHandlingPolicy loadErrorHandlingPolicy, long j, long j2, @rq6 ae9 ae9Var) { this.mediaItem = mediaItem; this.liveConfiguration = mediaItem.liveConfiguration; MediaItem.LocalConfiguration localConfiguration = mediaItem.localConfiguration; localConfiguration.getClass(); this.manifestUri = localConfiguration.uri; this.initialManifestUri = mediaItem.localConfiguration.uri; this.manifest = dashManifest; this.manifestDataSourceFactory = factory; this.manifestParser = parser; this.chunkSourceFactory = factory2; this.cmcdConfiguration = cmcdConfiguration; this.drmSessionManager = drmSessionManager; this.loadErrorHandlingPolicy = loadErrorHandlingPolicy; this.fallbackTargetLiveOffsetMs = j; this.minLiveStartPositionUs = j2; this.compositeSequenceableLoaderFactory = compositeSequenceableLoaderFactory; this.downloadExecutorSupplier = ae9Var; this.baseUrlExclusionList = new BaseUrlExclusionList(); boolean z = dashManifest != null; this.sideloadedManifest = z; this.manifestEventDispatcher = createEventDispatcher(null); this.manifestUriLock = new Object(); this.periodsById = new SparseArray<>(); this.playerEmsgCallback = new DefaultPlayerEmsgCallback(); this.expiredManifestPublishTimeUs = C.TIME_UNSET; this.elapsedRealtimeOffsetMs = C.TIME_UNSET; if (z) { if7.o(true ^ dashManifest.dynamic); this.manifestCallback = null; this.refreshManifestRunnable = null; this.simulateManifestRefreshRunnable = null; this.manifestLoadErrorThrower = new LoaderErrorThrower.Placeholder(); return; } this.manifestCallback = new ManifestCallback(); this.manifestLoadErrorThrower = new ManifestLoadErrorThrower(); final int i = 0; this.refreshManifestRunnable = new Runnable(this) { // from class: wp1 public final /* synthetic */ DashMediaSource b; { this.b = this; } @Override // java.lang.Runnable public final void run() { switch (i) { case 0: this.b.startLoadingManifest(); break; default: this.b.simulateManifestRefresh(); break; } } }; final int i2 = 1; this.simulateManifestRefreshRunnable = new Runnable(this) { // from class: wp1 public final /* synthetic */ DashMediaSource b; { this.b = this; } @Override // java.lang.Runnable public final void run() { switch (i2) { case 0: this.b.startLoadingManifest(); break; default: this.b.simulateManifestRefresh(); break; } } }; } }