package androidx.media3.exoplayer.hls.playlist; import android.net.Uri; import android.text.TextUtils; import android.util.Base64; import androidx.annotation.Nullable; import androidx.media3.common.C; import androidx.media3.common.DrmInitData; import androidx.media3.common.Format; import androidx.media3.common.Metadata; import androidx.media3.common.MimeTypes; import androidx.media3.common.ParserException; import androidx.media3.common.util.Assertions; import androidx.media3.common.util.Log; import androidx.media3.common.util.UnstableApi; import androidx.media3.common.util.UriUtil; import androidx.media3.common.util.Util; import androidx.media3.exoplayer.hls.HlsTrackMetadataEntry; import androidx.media3.exoplayer.hls.playlist.HlsMediaPlaylist; import androidx.media3.exoplayer.hls.playlist.HlsMultivariantPlaylist; import androidx.media3.exoplayer.upstream.ParsingLoadable; import com.google.android.gms.measurement.internal.u1; import com.google.common.collect.z0; import defpackage.e; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.math.BigDecimal; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.NoSuchElementException; import java.util.Queue; import java.util.TreeMap; import java.util.UUID; import java.util.regex.Matcher; import java.util.regex.Pattern; import l2.w; import org.checkerframework.checker.nullness.qual.EnsuresNonNullIf; /* JADX INFO: loaded from: classes.dex */ @UnstableApi public final class HlsPlaylistParser implements ParsingLoadable.Parser { private static final String ATTR_CLOSED_CAPTIONS_NONE = "CLOSED-CAPTIONS=NONE"; private static final String ATTR_QUOTED_STRING_VALUE_PATTERN = "\"((?:.|\f)+?)\""; private static final String BOOLEAN_FALSE = "NO"; private static final String BOOLEAN_TRUE = "YES"; private static final String DATERANGE_CLASS_INTERSTITIALS = "com.apple.hls.interstitial"; private static final String KEYFORMAT_IDENTITY = "identity"; private static final String KEYFORMAT_PLAYREADY = "com.microsoft.playready"; private static final String KEYFORMAT_WIDEVINE_PSSH_BINARY = "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed"; private static final String KEYFORMAT_WIDEVINE_PSSH_JSON = "com.widevine"; private static final String LOG_TAG = "HlsPlaylistParser"; private static final String METHOD_AES_128 = "AES-128"; private static final String METHOD_NONE = "NONE"; private static final String METHOD_SAMPLE_AES = "SAMPLE-AES"; private static final String METHOD_SAMPLE_AES_CENC = "SAMPLE-AES-CENC"; private static final String METHOD_SAMPLE_AES_CTR = "SAMPLE-AES-CTR"; private static final String PLAYLIST_HEADER = "#EXTM3U"; private static final String TAG_BYTERANGE = "#EXT-X-BYTERANGE"; private static final String TAG_DATERANGE = "#EXT-X-DATERANGE"; private static final String TAG_DEFINE = "#EXT-X-DEFINE"; private static final String TAG_DISCONTINUITY = "#EXT-X-DISCONTINUITY"; private static final String TAG_DISCONTINUITY_SEQUENCE = "#EXT-X-DISCONTINUITY-SEQUENCE"; private static final String TAG_ENDLIST = "#EXT-X-ENDLIST"; private static final String TAG_GAP = "#EXT-X-GAP"; private static final String TAG_IFRAME = "#EXT-X-I-FRAMES-ONLY"; private static final String TAG_INDEPENDENT_SEGMENTS = "#EXT-X-INDEPENDENT-SEGMENTS"; private static final String TAG_INIT_SEGMENT = "#EXT-X-MAP"; private static final String TAG_I_FRAME_STREAM_INF = "#EXT-X-I-FRAME-STREAM-INF"; private static final String TAG_KEY = "#EXT-X-KEY"; private static final String TAG_MEDIA = "#EXT-X-MEDIA"; private static final String TAG_MEDIA_DURATION = "#EXTINF"; private static final String TAG_MEDIA_SEQUENCE = "#EXT-X-MEDIA-SEQUENCE"; private static final String TAG_PART = "#EXT-X-PART"; private static final String TAG_PART_INF = "#EXT-X-PART-INF"; private static final String TAG_PLAYLIST_TYPE = "#EXT-X-PLAYLIST-TYPE"; private static final String TAG_PREFIX = "#EXT"; private static final String TAG_PRELOAD_HINT = "#EXT-X-PRELOAD-HINT"; private static final String TAG_PROGRAM_DATE_TIME = "#EXT-X-PROGRAM-DATE-TIME"; private static final String TAG_RENDITION_REPORT = "#EXT-X-RENDITION-REPORT"; private static final String TAG_SERVER_CONTROL = "#EXT-X-SERVER-CONTROL"; private static final String TAG_SESSION_KEY = "#EXT-X-SESSION-KEY"; private static final String TAG_SKIP = "#EXT-X-SKIP"; private static final String TAG_START = "#EXT-X-START"; private static final String TAG_STREAM_INF = "#EXT-X-STREAM-INF"; private static final String TAG_TARGET_DURATION = "#EXT-X-TARGETDURATION"; private static final String TAG_VERSION = "#EXT-X-VERSION"; private static final String TYPE_AUDIO = "AUDIO"; private static final String TYPE_CLOSED_CAPTIONS = "CLOSED-CAPTIONS"; private static final String TYPE_MAP = "MAP"; private static final String TYPE_PART = "PART"; private static final String TYPE_SUBTITLES = "SUBTITLES"; private static final String TYPE_VIDEO = "VIDEO"; private final HlsMultivariantPlaylist multivariantPlaylist; @Nullable private final HlsMediaPlaylist previousMediaPlaylist; private static final Pattern REGEX_AVERAGE_BANDWIDTH = Pattern.compile("AVERAGE-BANDWIDTH=(\\d+)\\b"); private static final Pattern REGEX_VIDEO = Pattern.compile("VIDEO=\"((?:.|\f)+?)\""); private static final Pattern REGEX_AUDIO = Pattern.compile("AUDIO=\"((?:.|\f)+?)\""); private static final Pattern REGEX_SUBTITLES = Pattern.compile("SUBTITLES=\"((?:.|\f)+?)\""); private static final Pattern REGEX_CLOSED_CAPTIONS = Pattern.compile("CLOSED-CAPTIONS=\"((?:.|\f)+?)\""); private static final Pattern REGEX_BANDWIDTH = Pattern.compile("[^-]BANDWIDTH=(\\d+)\\b"); private static final Pattern REGEX_CHANNELS = Pattern.compile("CHANNELS=\"((?:.|\f)+?)\""); private static final Pattern REGEX_VIDEO_RANGE = Pattern.compile("VIDEO-RANGE=(SDR|PQ|HLG)"); private static final Pattern REGEX_CODECS = Pattern.compile("CODECS=\"((?:.|\f)+?)\""); private static final Pattern REGEX_SUPPLEMENTAL_CODECS = Pattern.compile("SUPPLEMENTAL-CODECS=\"((?:.|\f)+?)\""); private static final Pattern REGEX_RESOLUTION = Pattern.compile("RESOLUTION=(\\d+x\\d+)"); private static final Pattern REGEX_FRAME_RATE = Pattern.compile("FRAME-RATE=([\\d\\.]+)\\b"); private static final Pattern REGEX_TARGET_DURATION = Pattern.compile("#EXT-X-TARGETDURATION:(\\d+)\\b"); private static final Pattern REGEX_ATTR_DURATION = Pattern.compile("DURATION=([\\d\\.]+)\\b"); private static final Pattern REGEX_ATTR_DURATION_PREFIXED = Pattern.compile("[:,]DURATION=([\\d\\.]+)\\b"); private static final Pattern REGEX_PART_TARGET_DURATION = Pattern.compile("PART-TARGET=([\\d\\.]+)\\b"); private static final Pattern REGEX_VERSION = Pattern.compile("#EXT-X-VERSION:(\\d+)\\b"); private static final Pattern REGEX_PLAYLIST_TYPE = Pattern.compile("#EXT-X-PLAYLIST-TYPE:(.+)\\b"); private static final Pattern REGEX_CAN_SKIP_UNTIL = Pattern.compile("CAN-SKIP-UNTIL=([\\d\\.]+)\\b"); private static final Pattern REGEX_CAN_SKIP_DATE_RANGES = compileBooleanAttrPattern("CAN-SKIP-DATERANGES"); private static final Pattern REGEX_SKIPPED_SEGMENTS = Pattern.compile("SKIPPED-SEGMENTS=(\\d+)\\b"); private static final Pattern REGEX_HOLD_BACK = Pattern.compile("[:|,]HOLD-BACK=([\\d\\.]+)\\b"); private static final Pattern REGEX_PART_HOLD_BACK = Pattern.compile("PART-HOLD-BACK=([\\d\\.]+)\\b"); private static final Pattern REGEX_CAN_BLOCK_RELOAD = compileBooleanAttrPattern("CAN-BLOCK-RELOAD"); private static final Pattern REGEX_MEDIA_SEQUENCE = Pattern.compile("#EXT-X-MEDIA-SEQUENCE:(\\d+)\\b"); private static final Pattern REGEX_MEDIA_DURATION = Pattern.compile("#EXTINF:([\\d\\.]+)\\b"); private static final Pattern REGEX_MEDIA_TITLE = Pattern.compile("#EXTINF:[\\d\\.]+\\b,(.+)"); private static final Pattern REGEX_LAST_MSN = Pattern.compile("LAST-MSN=(\\d+)\\b"); private static final Pattern REGEX_LAST_PART = Pattern.compile("LAST-PART=(\\d+)\\b"); private static final Pattern REGEX_TIME_OFFSET = Pattern.compile("TIME-OFFSET=(-?[\\d\\.]+)\\b"); private static final Pattern REGEX_BYTERANGE = Pattern.compile("#EXT-X-BYTERANGE:(\\d+(?:@\\d+)?)\\b"); private static final Pattern REGEX_ATTR_BYTERANGE = Pattern.compile("BYTERANGE=\"(\\d+(?:@\\d+)?)\\b\""); private static final Pattern REGEX_BYTERANGE_START = Pattern.compile("BYTERANGE-START=(\\d+)\\b"); private static final Pattern REGEX_BYTERANGE_LENGTH = Pattern.compile("BYTERANGE-LENGTH=(\\d+)\\b"); private static final Pattern REGEX_METHOD = Pattern.compile("METHOD=(NONE|AES-128|SAMPLE-AES|SAMPLE-AES-CENC|SAMPLE-AES-CTR)\\s*(?:,|$)"); private static final Pattern REGEX_KEYFORMAT = Pattern.compile("KEYFORMAT=\"((?:.|\f)+?)\""); private static final Pattern REGEX_KEYFORMATVERSIONS = Pattern.compile("KEYFORMATVERSIONS=\"((?:.|\f)+?)\""); private static final Pattern REGEX_URI = Pattern.compile("URI=\"((?:.|\f)+?)\""); private static final Pattern REGEX_IV = Pattern.compile("IV=([^,.*]+)"); private static final Pattern REGEX_TYPE = Pattern.compile("TYPE=(AUDIO|VIDEO|SUBTITLES|CLOSED-CAPTIONS)"); private static final Pattern REGEX_PRELOAD_HINT_TYPE = Pattern.compile("TYPE=(PART|MAP)"); private static final Pattern REGEX_LANGUAGE = Pattern.compile("LANGUAGE=\"((?:.|\f)+?)\""); private static final Pattern REGEX_NAME = Pattern.compile("NAME=\"((?:.|\f)+?)\""); private static final Pattern REGEX_GROUP_ID = Pattern.compile("GROUP-ID=\"((?:.|\f)+?)\""); private static final Pattern REGEX_CHARACTERISTICS = Pattern.compile("CHARACTERISTICS=\"((?:.|\f)+?)\""); private static final Pattern REGEX_INSTREAM_ID = Pattern.compile("INSTREAM-ID=\"((?:CC|SERVICE)\\d+)\""); private static final Pattern REGEX_AUTOSELECT = compileBooleanAttrPattern("AUTOSELECT"); private static final Pattern REGEX_DEFAULT = compileBooleanAttrPattern("DEFAULT"); private static final Pattern REGEX_FORCED = compileBooleanAttrPattern("FORCED"); private static final Pattern REGEX_INDEPENDENT = compileBooleanAttrPattern("INDEPENDENT"); private static final Pattern REGEX_GAP = compileBooleanAttrPattern("GAP"); private static final Pattern REGEX_PRECISE = compileBooleanAttrPattern("PRECISE"); private static final Pattern REGEX_VALUE = Pattern.compile("VALUE=\"((?:.|\f)+?)\""); private static final Pattern REGEX_IMPORT = Pattern.compile("IMPORT=\"((?:.|\f)+?)\""); private static final Pattern REGEX_ID = Pattern.compile("[:,]ID=\"((?:.|\f)+?)\""); private static final Pattern REGEX_CLASS = Pattern.compile("CLASS=\"((?:.|\f)+?)\""); private static final Pattern REGEX_START_DATE = Pattern.compile("START-DATE=\"((?:.|\f)+?)\""); private static final Pattern REGEX_CUE = Pattern.compile("CUE=\"((?:.|\f)+?)\""); private static final Pattern REGEX_END_DATE = Pattern.compile("END-DATE=\"((?:.|\f)+?)\""); private static final Pattern REGEX_PLANNED_DURATION = Pattern.compile("PLANNED-DURATION=([\\d\\.]+)\\b"); private static final Pattern REGEX_END_ON_NEXT = compileBooleanAttrPattern("END-ON-NEXT"); private static final Pattern REGEX_ASSET_URI = Pattern.compile("X-ASSET-URI=\"((?:.|\f)+?)\""); private static final Pattern REGEX_ASSET_LIST_URI = Pattern.compile("X-ASSET-LIST=\"((?:.|\f)+?)\""); private static final Pattern REGEX_RESUME_OFFSET = Pattern.compile("X-RESUME-OFFSET=(-?[\\d\\.]+)\\b"); private static final Pattern REGEX_PLAYOUT_LIMIT = Pattern.compile("X-PLAYOUT-LIMIT=([\\d\\.]+)\\b"); private static final Pattern REGEX_SNAP = Pattern.compile("X-SNAP=\"((?:.|\f)+?)\""); private static final Pattern REGEX_RESTRICT = Pattern.compile("X-RESTRICT=\"((?:.|\f)+?)\""); private static final Pattern REGEX_CONTENT_MAY_VARY = Pattern.compile("X-CONTENT-MAY-VARY=\"((?:.|\f)+?)\""); private static final Pattern REGEX_TIMELINE_OCCUPIES = Pattern.compile("X-TIMELINE-OCCUPIES=\"((?:.|\f)+?)\""); private static final Pattern REGEX_TIMELINE_STYLE = Pattern.compile("X-TIMELINE-STYLE=\"((?:.|\f)+?)\""); private static final Pattern REGEX_VARIABLE_REFERENCE = Pattern.compile("\\{\\$([a-zA-Z0-9\\-_]+)\\}"); private static final Pattern REGEX_CLIENT_DEFINED_ATTRIBUTE_PREFIX = Pattern.compile("\\b(X-[A-Z0-9-]+)="); public static final class DeltaUpdateException extends IOException { } public static class LineIterator { private final Queue extraLines; @Nullable private String next; private final BufferedReader reader; public LineIterator(Queue queue, BufferedReader bufferedReader) { this.extraLines = queue; this.reader = bufferedReader; } @EnsuresNonNullIf(expression = {"next"}, result = true) public boolean hasNext() throws IOException { String strTrim; if (this.next != null) { return true; } if (!this.extraLines.isEmpty()) { this.next = (String) Assertions.checkNotNull(this.extraLines.poll()); return true; } do { String line = this.reader.readLine(); this.next = line; if (line == null) { return false; } strTrim = line.trim(); this.next = strTrim; } while (strTrim.isEmpty()); return true; } public String next() throws IOException { if (!hasNext()) { throw new NoSuchElementException(); } String str = this.next; this.next = null; return str; } } public HlsPlaylistParser() { this(HlsMultivariantPlaylist.EMPTY, null); } private static boolean checkPlaylistHeader(BufferedReader bufferedReader) throws IOException { int i10 = bufferedReader.read(); if (i10 == 239) { if (bufferedReader.read() != 187 || bufferedReader.read() != 191) { return false; } i10 = bufferedReader.read(); } int iSkipIgnorableWhitespace = skipIgnorableWhitespace(bufferedReader, true, i10); for (int i11 = 0; i11 < 7; i11++) { if (iSkipIgnorableWhitespace != PLAYLIST_HEADER.charAt(i11)) { return false; } iSkipIgnorableWhitespace = bufferedReader.read(); } return Util.isLinebreak(skipIgnorableWhitespace(bufferedReader, false, iSkipIgnorableWhitespace)); } private static Pattern compileBooleanAttrPattern(String str) { return Pattern.compile(str + "=(NO|YES)"); } private static DrmInitData getPlaylistProtectionSchemes(@Nullable String str, DrmInitData.SchemeData[] schemeDataArr) { DrmInitData.SchemeData[] schemeDataArr2 = new DrmInitData.SchemeData[schemeDataArr.length]; for (int i10 = 0; i10 < schemeDataArr.length; i10++) { schemeDataArr2[i10] = schemeDataArr[i10].copyWithData(null); } return new DrmInitData(str, schemeDataArr2); } @Nullable private static String getSegmentEncryptionIV(long j10, @Nullable String str, @Nullable String str2) { if (str == null) { return null; } return str2 != null ? str2 : Long.toHexString(j10); } @Nullable private static HlsMultivariantPlaylist.Variant getVariantWithAudioGroup(ArrayList arrayList, String str) { for (int i10 = 0; i10 < arrayList.size(); i10++) { HlsMultivariantPlaylist.Variant variant = arrayList.get(i10); if (str.equals(variant.audioGroupId)) { return variant; } } return null; } @Nullable private static HlsMultivariantPlaylist.Variant getVariantWithSubtitleGroup(ArrayList arrayList, String str) { for (int i10 = 0; i10 < arrayList.size(); i10++) { HlsMultivariantPlaylist.Variant variant = arrayList.get(i10); if (str.equals(variant.subtitleGroupId)) { return variant; } } return null; } @Nullable private static HlsMultivariantPlaylist.Variant getVariantWithVideoGroup(ArrayList arrayList, String str) { for (int i10 = 0; i10 < arrayList.size(); i10++) { HlsMultivariantPlaylist.Variant variant = arrayList.get(i10); if (str.equals(variant.videoGroupId)) { return variant; } } return null; } private static boolean isDolbyVisionFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, @Nullable String str4) { if (!MimeTypes.isDolbyVisionCodec(str2, str3)) { return false; } if (str3 == null) { return true; } if (str == null || str4 == null) { return false; } return (!str.equals("PQ") || str4.equals("db1p")) && (!str.equals("SDR") || str4.equals("db2g")) && (!str.equals("HLG") || str4.startsWith("db4")); } private static HlsMediaPlaylist.ClientDefinedAttribute parseClientDefinedAttribute(String str, String str2, Map map) throws ParserException { String strJ = u1.j(str2, "="); int length = strJ.length() + str.indexOf(strJ); String strSubstring = str.substring(length, (str.length() == length + 1 ? 1 : 2) + length); if (strSubstring.startsWith("\"")) { return new HlsMediaPlaylist.ClientDefinedAttribute(str2, parseStringAttr(str, Pattern.compile(str2 + "=\"((?:.|\f)+?)\""), map), 0); } if (strSubstring.equals("0x") || strSubstring.equals("0X")) { return new HlsMediaPlaylist.ClientDefinedAttribute(str2, parseStringAttr(str, Pattern.compile(str2 + "=(0[xX][A-F0-9]+)"), map), 1); } return new HlsMediaPlaylist.ClientDefinedAttribute(str2, parseDoubleAttr(str, Pattern.compile(str2 + "=([\\d\\.]+)\\b"))); } private static double parseDoubleAttr(String str, Pattern pattern) throws ParserException { return Double.parseDouble(parseStringAttr(str, pattern, Collections.emptyMap())); } @Nullable private static DrmInitData.SchemeData parseDrmSchemeData(String str, String str2, Map map) throws ParserException { String optionalStringAttr = parseOptionalStringAttr(str, REGEX_KEYFORMATVERSIONS, "1", map); if (KEYFORMAT_WIDEVINE_PSSH_BINARY.equals(str2)) { String stringAttr = parseStringAttr(str, REGEX_URI, map); return new DrmInitData.SchemeData(C.WIDEVINE_UUID, MimeTypes.VIDEO_MP4, Base64.decode(stringAttr.substring(stringAttr.indexOf(44)), 0)); } if (KEYFORMAT_WIDEVINE_PSSH_JSON.equals(str2)) { return new DrmInitData.SchemeData(C.WIDEVINE_UUID, "hls", Util.getUtf8Bytes(str)); } if (!KEYFORMAT_PLAYREADY.equals(str2) || !"1".equals(optionalStringAttr)) { return null; } String stringAttr2 = parseStringAttr(str, REGEX_URI, map); byte[] bArrDecode = Base64.decode(stringAttr2.substring(stringAttr2.indexOf(44)), 0); UUID uuid = C.PLAYREADY_UUID; return new DrmInitData.SchemeData(uuid, MimeTypes.VIDEO_MP4, w.buildPsshAtom(uuid, bArrDecode)); } private static String parseEncryptionScheme(String str) { return (METHOD_SAMPLE_AES_CENC.equals(str) || METHOD_SAMPLE_AES_CTR.equals(str)) ? C.CENC_TYPE_cenc : C.CENC_TYPE_cbcs; } private static int parseIntAttr(String str, Pattern pattern) throws ParserException { return Integer.parseInt(parseStringAttr(str, pattern, Collections.emptyMap())); } private static long parseLongAttr(String str, Pattern pattern) throws ParserException { return Long.parseLong(parseStringAttr(str, pattern, Collections.emptyMap())); } /* JADX WARN: Code restructure failed: missing block: B:235:0x06a4, code lost: r48 = r8; */ /* JADX WARN: Code restructure failed: missing block: B:236:0x06a7, code lost: r48 = r8; */ /* JADX WARN: Code restructure failed: missing block: B:240:0x06b5, code lost: r48 = r8; */ /* JADX WARN: Code restructure failed: missing block: B:244:0x06c3, code lost: r48 = r8; */ /* JADX WARN: Code restructure failed: missing block: B:319:0x0846, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:320:0x084a, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:324:0x085a, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:328:0x086a, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:332:0x0878, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:336:0x0886, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:340:0x0894, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:344:0x08a2, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:348:0x08b0, code lost: r70 = r14; */ /* JADX WARN: Code restructure failed: missing block: B:352:0x08be, code lost: r70 = r14; */ /* JADX WARN: Removed duplicated region for block: B:112:0x032e A[PHI: r80 0x032e: PHI (r80v11 java.lang.String) = (r80v9 java.lang.String), (r80v1 java.lang.String) binds: [B:118:0x0342, B:110:0x0323] A[DONT_GENERATE, DONT_INLINE]] */ /* JADX WARN: Removed duplicated region for block: B:304:0x07f8 */ /* JADX WARN: Removed duplicated region for block: B:313:0x0816 */ /* Code decompiled incorrectly, please refer to instructions dump. */ private static HlsMediaPlaylist parseMediaPlaylist(HlsMultivariantPlaylist hlsMultivariantPlaylist, @Nullable HlsMediaPlaylist hlsMediaPlaylist, LineIterator lineIterator, String str) throws IOException { ArrayList arrayList; int i10; ArrayList arrayList2; ArrayList arrayList3; TreeMap treeMap; String str2; String str3; long j10; ArrayList arrayList4; HlsMediaPlaylist.Part part; ArrayList arrayList5; HashMap map; LinkedHashMap linkedHashMap; String stringAttr; ArrayList arrayList6; long j11; long j12; HashMap map2; String str4; long j13; String str5; String str6; long j14; DrmInitData drmInitData; long jMsToUs; long jMsToUs2; boolean z10; String strGroup; Matcher matcher; ArrayList arrayList7; String strTrim; int i11; HlsMultivariantPlaylist hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; HlsMediaPlaylist hlsMediaPlaylist2 = hlsMediaPlaylist; boolean z11 = hlsMultivariantPlaylist2.hasIndependentSegments; HashMap map3 = new HashMap(); HashMap map4 = new HashMap(); ArrayList arrayList8 = new ArrayList(); ArrayList arrayList9 = new ArrayList(); ArrayList arrayList10 = new ArrayList(); ArrayList arrayList11 = new ArrayList(); LinkedHashMap linkedHashMap2 = new LinkedHashMap(); HlsMediaPlaylist.ServerControl serverControl = new HlsMediaPlaylist.ServerControl(-9223372036854775807L, false, -9223372036854775807L, -9223372036854775807L, false); TreeMap treeMap2 = new TreeMap(); boolean z12 = false; String str7 = ""; boolean z13 = z11; HlsMediaPlaylist.ServerControl serverControl2 = serverControl; int i12 = 0; boolean optionalBooleanAttribute = false; boolean z14 = false; int i13 = 0; boolean z15 = false; boolean z16 = false; int i14 = 0; boolean z17 = false; long jMsToUs3 = 0; long j15 = 0; long j16 = 0; long j17 = 0; long j18 = 0; long longAttr = 0; long timeSecondsToUs = 0; long j19 = 0; String optionalStringAttr = str7; long j20 = -9223372036854775807L; int intAttr = 1; long intAttr2 = -9223372036854775807L; long doubleAttr = -9223372036854775807L; DrmInitData playlistProtectionSchemes = null; DrmInitData drmInitData2 = null; String str8 = null; long j21 = -1; String str9 = null; String encryptionScheme = null; HlsMediaPlaylist.Segment segment = null; ArrayList arrayList12 = arrayList9; HlsMediaPlaylist.Part part2 = null; while (lineIterator.hasNext()) { String next = lineIterator.next(); if (next.startsWith(TAG_PREFIX)) { arrayList11.add(next); } if (next.startsWith(TAG_PLAYLIST_TYPE)) { String stringAttr2 = parseStringAttr(next, REGEX_PLAYLIST_TYPE, map3); if ("VOD".equals(stringAttr2)) { i12 = 1; } else if ("EVENT".equals(stringAttr2)) { i12 = 2; } } else if (next.equals(TAG_IFRAME)) { z17 = true; } else { if (next.startsWith(TAG_START)) { arrayList = arrayList8; long doubleAttr2 = (long) (parseDoubleAttr(next, REGEX_TIME_OFFSET) * 1000000.0d); optionalBooleanAttribute = parseOptionalBooleanAttribute(next, REGEX_PRECISE, z12); j20 = doubleAttr2; } else { arrayList = arrayList8; if (next.startsWith(TAG_SERVER_CONTROL)) { serverControl2 = parseServerControl(next); } else if (next.startsWith(TAG_PART_INF)) { doubleAttr = (long) (parseDoubleAttr(next, REGEX_PART_TARGET_DURATION) * 1000000.0d); } else if (next.startsWith(TAG_INIT_SEGMENT)) { String stringAttr3 = parseStringAttr(next, REGEX_URI, map3); String optionalStringAttr2 = parseOptionalStringAttr(next, REGEX_ATTR_BYTERANGE, map3); if (optionalStringAttr2 != null) { String[] strArrSplit = Util.split(optionalStringAttr2, "@"); j21 = Long.parseLong(strArrSplit[z12 ? 1 : 0]); if (strArrSplit.length > 1) { j16 = Long.parseLong(strArrSplit[1]); } } if (j21 == -1) { j16 = 0; } String str10 = str8; String str11 = str9; if (str10 != null && str11 == null) { throw ParserException.createForMalformedManifest("The encryption IV attribute must be present when an initialization segment is encrypted with METHOD=AES-128.", null); } segment = new HlsMediaPlaylist.Segment(stringAttr3, j16, j21, str10, str11); if (j21 != -1) { j16 += j21; } str8 = str10; str9 = str11; arrayList8 = arrayList; j21 = -1; } else { String str12 = str8; String str13 = str9; if (next.startsWith(TAG_TARGET_DURATION)) { intAttr2 = 1000000 * ((long) parseIntAttr(next, REGEX_TARGET_DURATION)); } else { if (next.startsWith(TAG_MEDIA_SEQUENCE)) { longAttr = parseLongAttr(next, REGEX_MEDIA_SEQUENCE); str9 = str13; str8 = str12; j15 = longAttr; } else if (next.startsWith(TAG_VERSION)) { intAttr = parseIntAttr(next, REGEX_VERSION); } else { if (next.startsWith(TAG_DEFINE)) { String optionalStringAttr3 = parseOptionalStringAttr(next, REGEX_IMPORT, map3); if (optionalStringAttr3 != null) { String str14 = hlsMultivariantPlaylist2.variableDefinitions.get(optionalStringAttr3); if (str14 != null) { map3.put(optionalStringAttr3, str14); } } else { map3.put(parseStringAttr(next, REGEX_NAME, map3), parseStringAttr(next, REGEX_VALUE, map3)); } i10 = i12; arrayList2 = arrayList10; arrayList3 = arrayList12; treeMap = treeMap2; str2 = str7; str3 = encryptionScheme; j10 = longAttr; arrayList4 = arrayList; z12 = false; part = part2; arrayList5 = arrayList11; map = map4; linkedHashMap = linkedHashMap2; } else if (next.startsWith(TAG_MEDIA_DURATION)) { timeSecondsToUs = parseTimeSecondsToUs(next, REGEX_MEDIA_DURATION); optionalStringAttr = parseOptionalStringAttr(next, REGEX_MEDIA_TITLE, str7, map3); } else { String str15 = str7; if (next.startsWith(TAG_SKIP)) { int intAttr3 = parseIntAttr(next, REGEX_SKIPPED_SEGMENTS); Assertions.checkState(hlsMediaPlaylist2 != null && arrayList.isEmpty()); int i15 = (int) (j15 - ((HlsMediaPlaylist) Util.castNonNull(hlsMediaPlaylist)).mediaSequence); int i16 = intAttr3 + i15; if (i15 < 0 || i16 > hlsMediaPlaylist2.segments.size()) { throw new DeltaUpdateException(); } str9 = str13; String str16 = str12; long j22 = j18; while (i15 < i16) { HlsMediaPlaylist.Segment segmentCopyWith = hlsMediaPlaylist2.segments.get(i15); LinkedHashMap linkedHashMap3 = linkedHashMap2; ArrayList arrayList13 = arrayList11; if (j15 != hlsMediaPlaylist2.mediaSequence) { segmentCopyWith = segmentCopyWith.copyWith(j22, (hlsMediaPlaylist2.discontinuitySequence - i13) + segmentCopyWith.relativeDiscontinuitySequence); } ArrayList arrayList14 = arrayList; arrayList14.add(segmentCopyWith); int i17 = i16; long j23 = j22 + segmentCopyWith.durationUs; long j24 = segmentCopyWith.byteRangeLength; if (j24 != -1) { j16 = segmentCopyWith.byteRangeOffset + j24; } int i18 = segmentCopyWith.relativeDiscontinuitySequence; HlsMediaPlaylist.Segment segment2 = segmentCopyWith.initializationSegment; DrmInitData drmInitData3 = segmentCopyWith.drmInitData; String str17 = segmentCopyWith.fullSegmentEncryptionKeyUri; String str18 = segmentCopyWith.encryptionIV; if (str18 == null || !str18.equals(Long.toHexString(longAttr))) { str9 = segmentCopyWith.encryptionIV; } longAttr++; i15++; hlsMediaPlaylist2 = hlsMediaPlaylist; i16 = i17; arrayList = arrayList14; str16 = str17; arrayList11 = arrayList13; i14 = i18; j17 = j23; segment = segment2; linkedHashMap2 = linkedHashMap3; drmInitData2 = drmInitData3; j22 = j17; } hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; str7 = str15; str8 = str16; j18 = j22; } else { LinkedHashMap linkedHashMap4 = linkedHashMap2; arrayList5 = arrayList11; if (next.startsWith(TAG_KEY)) { String stringAttr4 = parseStringAttr(next, REGEX_METHOD, map3); String optionalStringAttr4 = parseOptionalStringAttr(next, REGEX_KEYFORMAT, KEYFORMAT_IDENTITY, map3); if (METHOD_NONE.equals(stringAttr4)) { treeMap2.clear(); stringAttr = null; drmInitData2 = null; str9 = null; } else { String optionalStringAttr5 = parseOptionalStringAttr(next, REGEX_IV, map3); if (!KEYFORMAT_IDENTITY.equals(optionalStringAttr4)) { String str19 = encryptionScheme; encryptionScheme = str19 == null ? parseEncryptionScheme(stringAttr4) : str19; DrmInitData.SchemeData drmSchemeData = parseDrmSchemeData(next, optionalStringAttr4, map3); if (drmSchemeData != null) { treeMap2.put(optionalStringAttr4, drmSchemeData); str9 = optionalStringAttr5; stringAttr = null; drmInitData2 = null; } } else if (METHOD_AES_128.equals(stringAttr4)) { stringAttr = parseStringAttr(next, REGEX_URI, map3); str9 = optionalStringAttr5; } else { str9 = optionalStringAttr5; stringAttr = null; } } hlsMediaPlaylist2 = hlsMediaPlaylist; str8 = stringAttr; arrayList8 = arrayList; arrayList11 = arrayList5; linkedHashMap2 = linkedHashMap4; hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; } else { String str20 = encryptionScheme; if (next.startsWith(TAG_BYTERANGE)) { String[] strArrSplit2 = Util.split(parseStringAttr(next, REGEX_BYTERANGE, map3), "@"); j21 = Long.parseLong(strArrSplit2[0]); if (strArrSplit2.length > 1) { j16 = Long.parseLong(strArrSplit2[1]); } } else { if (next.startsWith(TAG_DISCONTINUITY_SEQUENCE)) { i13 = Integer.parseInt(next.substring(next.indexOf(58) + 1)); hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; encryptionScheme = str20; str9 = str13; str8 = str12; linkedHashMap2 = linkedHashMap4; z14 = true; } else if (next.equals(TAG_DISCONTINUITY)) { i14++; } else { if (next.startsWith(TAG_PROGRAM_DATE_TIME)) { if (jMsToUs3 == 0) { jMsToUs3 = Util.msToUs(Util.parseXsDateTime(next.substring(next.indexOf(58) + 1))) - j18; } else { i10 = i12; part = part2; arrayList2 = arrayList10; str3 = str20; arrayList4 = arrayList; arrayList3 = arrayList12; treeMap = treeMap2; str2 = str15; j10 = longAttr; } } else if (next.equals(TAG_GAP)) { hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; encryptionScheme = str20; str9 = str13; str8 = str12; linkedHashMap2 = linkedHashMap4; z16 = true; } else if (next.equals(TAG_INDEPENDENT_SEGMENTS)) { hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; encryptionScheme = str20; str9 = str13; str8 = str12; linkedHashMap2 = linkedHashMap4; z13 = true; } else if (next.equals(TAG_ENDLIST)) { hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; encryptionScheme = str20; str9 = str13; str8 = str12; linkedHashMap2 = linkedHashMap4; z15 = true; } else { if (next.startsWith(TAG_RENDITION_REPORT)) { i10 = i12; arrayList6 = arrayList; arrayList3 = arrayList12; arrayList10.add(new HlsMediaPlaylist.RenditionReport(Uri.parse(UriUtil.resolve(str, parseStringAttr(next, REGEX_URI, map3))), parseOptionalLongAttr(next, REGEX_LAST_MSN, -1L), parseOptionalIntAttr(next, REGEX_LAST_PART, -1))); } else { i10 = i12; arrayList6 = arrayList; arrayList3 = arrayList12; if (!next.startsWith(TAG_PRELOAD_HINT)) { long j25 = longAttr; if (next.startsWith(TAG_PART)) { String segmentEncryptionIV = getSegmentEncryptionIV(j25, str12, str13); String stringAttr5 = parseStringAttr(next, REGEX_URI, map3); long doubleAttr3 = (long) (parseDoubleAttr(next, REGEX_ATTR_DURATION) * 1000000.0d); HlsMediaPlaylist.Part part3 = part2; boolean optionalBooleanAttribute2 = parseOptionalBooleanAttribute(next, REGEX_INDEPENDENT, false) | (z13 && arrayList3.isEmpty()); boolean optionalBooleanAttribute3 = parseOptionalBooleanAttribute(next, REGEX_GAP, false); String optionalStringAttr6 = parseOptionalStringAttr(next, REGEX_ATTR_BYTERANGE, map3); if (optionalStringAttr6 != null) { String[] strArrSplit3 = Util.split(optionalStringAttr6, "@"); j12 = Long.parseLong(strArrSplit3[0]); if (strArrSplit3.length > 1) { j19 = Long.parseLong(strArrSplit3[1]); } j11 = -1; } else { j11 = -1; j12 = -1; } if (j12 == j11) { j19 = 0; } if (drmInitData2 == null && !treeMap2.isEmpty()) { DrmInitData.SchemeData[] schemeDataArr = (DrmInitData.SchemeData[]) treeMap2.values().toArray(new DrmInitData.SchemeData[0]); DrmInitData drmInitData4 = new DrmInitData(str20, schemeDataArr); if (playlistProtectionSchemes == null) { playlistProtectionSchemes = getPlaylistProtectionSchemes(str20, schemeDataArr); } drmInitData2 = drmInitData4; } arrayList3.add(new HlsMediaPlaylist.Part(stringAttr5, segment, doubleAttr3, i14, j17, drmInitData2, str12, segmentEncryptionIV, j19, j12, optionalBooleanAttribute3, optionalBooleanAttribute2, false)); j17 += doubleAttr3; if (j12 != j11) { j19 += j12; } hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; longAttr = j25; arrayList12 = arrayList3; str8 = str12; arrayList11 = arrayList5; i12 = i10; part2 = part3; arrayList8 = arrayList6; encryptionScheme = str20; str7 = str15; str9 = str13; linkedHashMap2 = linkedHashMap4; } else { part = part2; if (next.startsWith(TAG_DATERANGE) && parseOptionalStringAttr(next, REGEX_CLASS, str15, map3).equals(DATERANGE_CLASS_INTERSTITIALS)) { String stringAttr6 = parseStringAttr(next, REGEX_ID, map3); String optionalStringAttr7 = parseOptionalStringAttr(next, REGEX_ASSET_URI, map3); Uri uri = optionalStringAttr7 != null ? Uri.parse(optionalStringAttr7) : null; String optionalStringAttr8 = parseOptionalStringAttr(next, REGEX_ASSET_LIST_URI, map3); Uri uri2 = optionalStringAttr8 != null ? Uri.parse(optionalStringAttr8) : null; String optionalStringAttr9 = parseOptionalStringAttr(next, REGEX_START_DATE, map3); if (optionalStringAttr9 != null) { arrayList2 = arrayList10; str2 = str15; jMsToUs = Util.msToUs(Util.parseXsDateTime(optionalStringAttr9)); } else { arrayList2 = arrayList10; str2 = str15; jMsToUs = -9223372036854775807L; } String optionalStringAttr10 = parseOptionalStringAttr(next, REGEX_END_DATE, map3); if (optionalStringAttr10 != null) { treeMap = treeMap2; arrayList3 = arrayList3; jMsToUs2 = Util.msToUs(Util.parseXsDateTime(optionalStringAttr10)); } else { treeMap = treeMap2; arrayList3 = arrayList3; jMsToUs2 = -9223372036854775807L; } ArrayList arrayList15 = new ArrayList(); str4 = str20; String optionalStringAttr11 = parseOptionalStringAttr(next, REGEX_CUE, map3); map2 = map4; if (optionalStringAttr11 != null) { String[] strArrSplit4 = Util.split(optionalStringAttr11, ","); j13 = j25; int length = strArrSplit4.length; int i19 = 0; while (i19 < length) { String[] strArr = strArrSplit4; strTrim = strArrSplit4[i19].trim(); strTrim.getClass(); strTrim.hashCode(); switch (strTrim) { case "PRE": case "ONCE": case "POST": arrayList15.add(strTrim); break; } i19++; strArrSplit4 = strArr; length = i11; } } else { j13 = j25; } double optionalDoubleAttr = parseOptionalDoubleAttr(next, REGEX_ATTR_DURATION_PREFIXED, -1.0d); long j26 = optionalDoubleAttr >= 0.0d ? (long) (optionalDoubleAttr * 1000000.0d) : -9223372036854775807L; str6 = str12; double optionalDoubleAttr2 = parseOptionalDoubleAttr(next, REGEX_PLANNED_DURATION, -1.0d); long j27 = optionalDoubleAttr2 >= 0.0d ? (long) (optionalDoubleAttr2 * 1000000.0d) : -9223372036854775807L; str5 = str13; boolean optionalBooleanAttribute4 = parseOptionalBooleanAttribute(next, REGEX_END_ON_NEXT, false); long j28 = j27; double optionalDoubleAttr3 = parseOptionalDoubleAttr(next, REGEX_RESUME_OFFSET, Double.MIN_VALUE); long j29 = optionalDoubleAttr3 != Double.MIN_VALUE ? (long) (optionalDoubleAttr3 * 1000000.0d) : -9223372036854775807L; double optionalDoubleAttr4 = parseOptionalDoubleAttr(next, REGEX_PLAYOUT_LIMIT, -1.0d); long j30 = optionalDoubleAttr4 >= 0.0d ? (long) (optionalDoubleAttr4 * 1000000.0d) : -9223372036854775807L; ArrayList arrayList16 = new ArrayList(); long j31 = j30; String optionalStringAttr12 = parseOptionalStringAttr(next, REGEX_SNAP, map3); if (optionalStringAttr12 != null) { String[] strArrSplit5 = Util.split(optionalStringAttr12, ","); int length2 = strArrSplit5.length; z10 = optionalBooleanAttribute4; int i20 = 0; while (i20 < length2) { String[] strArr2 = strArrSplit5; String strTrim2 = strArrSplit5[i20].trim(); strTrim2.getClass(); int i21 = length2; if (strTrim2.equals(HlsMediaPlaylist.Interstitial.SNAP_TYPE_IN) || strTrim2.equals(HlsMediaPlaylist.Interstitial.SNAP_TYPE_OUT)) { arrayList16.add(strTrim2); } i20++; length2 = i21; strArrSplit5 = strArr2; } } else { z10 = optionalBooleanAttribute4; } ArrayList arrayList17 = new ArrayList(); String optionalStringAttr13 = parseOptionalStringAttr(next, REGEX_RESTRICT, map3); if (optionalStringAttr13 != null) { String[] strArrSplit6 = Util.split(optionalStringAttr13, ","); int length3 = strArrSplit6.length; int i22 = 0; while (i22 < length3) { String[] strArr3 = strArrSplit6; String strTrim3 = strArrSplit6[i22].trim(); strTrim3.getClass(); int i23 = length3; if (strTrim3.equals(HlsMediaPlaylist.Interstitial.NAVIGATION_RESTRICTION_JUMP) || strTrim3.equals(HlsMediaPlaylist.Interstitial.NAVIGATION_RESTRICTION_SKIP)) { arrayList17.add(strTrim3); } i22++; length3 = i23; strArrSplit6 = strArr3; } } Boolean boolValueOf = parseOptionalStringAttr(next, REGEX_CONTENT_MAY_VARY, map3) != null ? Boolean.valueOf(!r4.equals(BOOLEAN_FALSE)) : null; String optionalStringAttr14 = parseOptionalStringAttr(next, REGEX_TIMELINE_OCCUPIES, map3); if (optionalStringAttr14 != null) { String str21 = HlsMediaPlaylist.Interstitial.TIMELINE_OCCUPIES_RANGE; if (!optionalStringAttr14.equals(HlsMediaPlaylist.Interstitial.TIMELINE_OCCUPIES_RANGE)) { str21 = HlsMediaPlaylist.Interstitial.TIMELINE_OCCUPIES_POINT; if (!optionalStringAttr14.equals(HlsMediaPlaylist.Interstitial.TIMELINE_OCCUPIES_POINT)) { str21 = null; } } String optionalStringAttr15 = parseOptionalStringAttr(next, REGEX_TIMELINE_STYLE, map3); String str22 = str21; if (optionalStringAttr15 != null) { String str23 = HlsMediaPlaylist.Interstitial.TIMELINE_STYLE_PRIMARY; if (!optionalStringAttr15.equals(HlsMediaPlaylist.Interstitial.TIMELINE_STYLE_PRIMARY)) { str23 = HlsMediaPlaylist.Interstitial.TIMELINE_STYLE_HIGHLIGHT; if (!optionalStringAttr15.equals(HlsMediaPlaylist.Interstitial.TIMELINE_STYLE_HIGHLIGHT)) { str23 = null; } } ArrayList arrayList18 = new ArrayList(); String str24 = str23; String strSubstring = next.substring(17); Matcher matcher2 = REGEX_CLIENT_DEFINED_ATTRIBUTE_PREFIX.matcher(strSubstring); while (matcher2.find()) { Boolean bool = boolValueOf; strGroup = matcher2.group(); strGroup.getClass(); strGroup.hashCode(); switch (strGroup) { case "X-SNAP=": case "X-CONTENT-MAY-VARY=": case "X-PLAYOUT-LIMIT=": case "X-TIMELINE-STYLE=": case "X-ASSET-LIST=": case "X-TIMELINE-OCCUPIES=": case "X-RESTRICT=": case "X-RESUME-OFFSET=": case "X-ASSET-URI=": arrayList7 = arrayList17; break; default: arrayList7 = arrayList17; arrayList18.add(parseClientDefinedAttribute(strSubstring, u1.h(strGroup, 1, 0), map3)); break; } arrayList17 = arrayList7; boolValueOf = bool; matcher2 = matcher; } Boolean bool2 = boolValueOf; linkedHashMap = linkedHashMap4; linkedHashMap.put(stringAttr6, (linkedHashMap.containsKey(stringAttr6) ? (HlsMediaPlaylist.Interstitial.Builder) linkedHashMap.get(stringAttr6) : new HlsMediaPlaylist.Interstitial.Builder(stringAttr6)).setAssetUri(uri).setAssetListUri(uri2).setStartDateUnixUs(jMsToUs).setEndDateUnixUs(jMsToUs2).setDurationUs(j26).setPlannedDurationUs(j28).setCue(arrayList15).setEndOnNext(z10).setResumeOffsetUs(j29).setPlayoutLimitUs(j31).setSnapTypes(arrayList16).setRestrictions(arrayList17).setClientDefinedAttributes(arrayList18).setContentMayVary(bool2).setTimelineOccupies(str22).setTimelineStyle(str24)); } } } else { map2 = map4; arrayList2 = arrayList10; str4 = str20; j13 = j25; treeMap = treeMap2; str2 = str15; str5 = str13; arrayList3 = arrayList3; str6 = str12; linkedHashMap = linkedHashMap4; if (!next.startsWith("#")) { str13 = str5; String segmentEncryptionIV2 = getSegmentEncryptionIV(j13, str6, str13); longAttr = j13 + 1; String strReplaceVariableReferences = replaceVariableReferences(next, map3); HlsMediaPlaylist.Segment segment3 = (HlsMediaPlaylist.Segment) map2.get(strReplaceVariableReferences); if (j21 == -1) { j14 = 0; } else { if (z17 && segment == null && segment3 == null) { segment3 = new HlsMediaPlaylist.Segment(strReplaceVariableReferences, 0L, j16, null, null); map2.put(strReplaceVariableReferences, segment3); } j14 = j16; } if (drmInitData2 != null || treeMap.isEmpty()) { str3 = str4; z12 = false; drmInitData = drmInitData2; } else { z12 = false; z12 = false; DrmInitData.SchemeData[] schemeDataArr2 = (DrmInitData.SchemeData[]) treeMap.values().toArray(new DrmInitData.SchemeData[0]); str3 = str4; drmInitData = new DrmInitData(str3, schemeDataArr2); if (playlistProtectionSchemes == null) { playlistProtectionSchemes = getPlaylistProtectionSchemes(str3, schemeDataArr2); } } HlsMediaPlaylist.Segment segment4 = new HlsMediaPlaylist.Segment(strReplaceVariableReferences, segment != null ? segment : segment3, optionalStringAttr, timeSecondsToUs, i14, j18, drmInitData, str6, segmentEncryptionIV2, j14, j21, z16, arrayList3); arrayList4 = arrayList6; arrayList4.add(segment4); j17 = j18 + timeSecondsToUs; ArrayList arrayList19 = new ArrayList(); if (j21 != -1) { j14 += j21; } j16 = j14; hlsMediaPlaylist2 = hlsMediaPlaylist; arrayList12 = arrayList19; linkedHashMap2 = linkedHashMap; map4 = map2; z16 = z12 ? 1 : 0; drmInitData2 = drmInitData; str8 = str6; timeSecondsToUs = 0; arrayList11 = arrayList5; j18 = j17; arrayList10 = arrayList2; str7 = str2; optionalStringAttr = str7; treeMap2 = treeMap; part2 = part; j21 = -1; hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; arrayList8 = arrayList4; encryptionScheme = str3; i12 = i10; str9 = str13; } } j10 = j13; str3 = str4; map = map2; str12 = str6; str13 = str5; arrayList4 = arrayList6; z12 = false; } } else if (part2 == null && TYPE_PART.equals(parseStringAttr(next, REGEX_PRELOAD_HINT_TYPE, map3))) { String stringAttr7 = parseStringAttr(next, REGEX_URI, map3); long optionalLongAttr = parseOptionalLongAttr(next, REGEX_BYTERANGE_START, -1L); long optionalLongAttr2 = parseOptionalLongAttr(next, REGEX_BYTERANGE_LENGTH, -1L); long j32 = longAttr; String segmentEncryptionIV3 = getSegmentEncryptionIV(j32, str12, str13); if (drmInitData2 == null && !treeMap2.isEmpty()) { DrmInitData.SchemeData[] schemeDataArr3 = (DrmInitData.SchemeData[]) treeMap2.values().toArray(new DrmInitData.SchemeData[0]); DrmInitData drmInitData5 = new DrmInitData(str20, schemeDataArr3); if (playlistProtectionSchemes == null) { playlistProtectionSchemes = getPlaylistProtectionSchemes(str20, schemeDataArr3); } drmInitData2 = drmInitData5; } if (optionalLongAttr == -1 || optionalLongAttr2 != -1) { part2 = new HlsMediaPlaylist.Part(stringAttr7, segment, 0L, i14, j17, drmInitData2, str12, segmentEncryptionIV3, optionalLongAttr != -1 ? optionalLongAttr : 0L, optionalLongAttr2, false, false, true); } hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; encryptionScheme = str20; longAttr = j32; str8 = str12; arrayList11 = arrayList5; arrayList12 = arrayList3; i12 = i10; arrayList8 = arrayList6; linkedHashMap2 = linkedHashMap4; str7 = str15; str9 = str13; } z12 = false; } part = part2; arrayList2 = arrayList10; str3 = str20; treeMap = treeMap2; str2 = str15; j10 = longAttr; arrayList4 = arrayList6; } z12 = false; map = map4; linkedHashMap = linkedHashMap4; } arrayList8 = arrayList; arrayList11 = arrayList5; } hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; encryptionScheme = str20; str9 = str13; str8 = str12; linkedHashMap2 = linkedHashMap4; arrayList8 = arrayList; arrayList11 = arrayList5; } str7 = str15; z12 = false; } } longAttr = j10; linkedHashMap2 = linkedHashMap; map4 = map; str8 = str12; arrayList11 = arrayList5; arrayList12 = arrayList3; arrayList10 = arrayList2; str7 = str2; treeMap2 = treeMap; part2 = part; hlsMultivariantPlaylist2 = hlsMultivariantPlaylist; hlsMediaPlaylist2 = hlsMediaPlaylist; arrayList8 = arrayList4; encryptionScheme = str3; i12 = i10; str9 = str13; } arrayList8 = arrayList; z12 = false; } str9 = str13; str8 = str12; arrayList8 = arrayList; z12 = false; } } arrayList8 = arrayList; } } int i24 = i12; HlsMediaPlaylist.Part part4 = part2; ArrayList arrayList20 = arrayList10; LinkedHashMap linkedHashMap5 = linkedHashMap2; ArrayList arrayList21 = arrayList11; ArrayList arrayList22 = arrayList12; ArrayList arrayList23 = arrayList8; HashMap map5 = new HashMap(); int i25 = z12 ? 1 : 0; while (i25 < arrayList20.size()) { ArrayList arrayList24 = arrayList20; HlsMediaPlaylist.RenditionReport renditionReport = (HlsMediaPlaylist.RenditionReport) arrayList24.get(i25); long size = renditionReport.lastMediaSequence; if (size == -1) { size = (j15 + ((long) arrayList23.size())) - (arrayList22.isEmpty() ? 1L : 0L); } int size2 = renditionReport.lastPartIndex; if (size2 == -1 && doubleAttr != -9223372036854775807L) { size2 = (arrayList22.isEmpty() ? ((HlsMediaPlaylist.Segment) z0.n(arrayList23)).parts : arrayList22).size() - 1; } Uri uri3 = renditionReport.playlistUri; map5.put(uri3, new HlsMediaPlaylist.RenditionReport(uri3, size, size2)); i25++; arrayList20 = arrayList24; } if (part4 != null) { arrayList22.add(part4); } ArrayList arrayList25 = new ArrayList(); Iterator it = linkedHashMap5.values().iterator(); while (it.hasNext()) { HlsMediaPlaylist.Interstitial interstitialBuild = ((HlsMediaPlaylist.Interstitial.Builder) it.next()).build(); if (interstitialBuild != null) { arrayList25.add(interstitialBuild); } } return new HlsMediaPlaylist(i24, str, arrayList21, j20, optionalBooleanAttribute, jMsToUs3, z14, i13, j15, intAttr, intAttr2, doubleAttr, z13, z15, jMsToUs3 != 0 ? true : z12 ? 1 : 0, playlistProtectionSchemes, arrayList23, arrayList22, serverControl2, map5, arrayList25); } /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */ /* JADX WARN: Removed duplicated region for block: B:42:0x014e */ /* JADX WARN: Removed duplicated region for block: B:51:0x0167 */ /* JADX WARN: Removed duplicated region for block: B:54:0x017f */ /* JADX WARN: Removed duplicated region for block: B:93:0x0363 */ /* Code decompiled incorrectly, please refer to instructions dump. */ private static HlsMultivariantPlaylist parseMultivariantPlaylist(LineIterator lineIterator, String str) throws IOException { String str2; String stringAttr; String stringAttr2; Format.Builder language; Uri uriResolveToUri; Metadata metadata; Format format; ArrayList arrayList; String mediaMimeType; ArrayList arrayList2; int i10; String str3; Format formatBuild; String mediaMimeType2; boolean z10; int i11; ArrayList arrayList3; ArrayList arrayList4; ArrayList arrayList5; ArrayList arrayList6; ArrayList arrayList7; ArrayList arrayList8; HashMap map; String str4; String str5; String codecsOfType; String optionalStringAttr; Uri uriResolveToUri2; String str6 = str; HashMap map2 = new HashMap(); HashMap map3 = new HashMap(); ArrayList arrayList9 = new ArrayList(); ArrayList arrayList10 = new ArrayList(); ArrayList arrayList11 = new ArrayList(); ArrayList arrayList12 = new ArrayList(); ArrayList arrayList13 = new ArrayList(); ArrayList arrayList14 = new ArrayList(); ArrayList arrayList15 = new ArrayList(); ArrayList arrayList16 = new ArrayList(); boolean z11 = false; boolean z12 = false; while (true) { boolean zHasNext = lineIterator.hasNext(); String str7 = MimeTypes.APPLICATION_M3U8; boolean z13 = z11; if (!zHasNext) { ArrayList arrayList17 = arrayList14; ArrayList arrayList18 = arrayList10; ArrayList arrayList19 = arrayList11; ArrayList arrayList20 = arrayList12; ArrayList arrayList21 = arrayList13; ArrayList arrayList22 = arrayList16; ArrayList arrayList23 = arrayList15; ArrayList arrayList24 = new ArrayList(); HashSet hashSet = new HashSet(); for (int i12 = 0; i12 < arrayList9.size(); i12++) { HlsMultivariantPlaylist.Variant variant = (HlsMultivariantPlaylist.Variant) arrayList9.get(i12); if (hashSet.add(variant.url)) { Assertions.checkState(variant.format.metadata == null); arrayList24.add(variant.copyWithFormat(variant.format.buildUpon().setMetadata(new Metadata(new HlsTrackMetadataEntry(null, null, (List) Assertions.checkNotNull((ArrayList) map2.get(variant.url))))).build())); } } ArrayList arrayList25 = null; Format format2 = null; int i13 = 0; while (i13 < arrayList17.size()) { ArrayList arrayList26 = arrayList17; str2 = (String) arrayList26.get(i13); stringAttr = parseStringAttr(str2, REGEX_GROUP_ID, map3); stringAttr2 = parseStringAttr(str2, REGEX_NAME, map3); language = new Format.Builder().setId(stringAttr + ":" + stringAttr2).setLabel(stringAttr2).setContainerMimeType(str7).setSelectionFlags(parseSelectionFlags(str2)).setRoleFlags(parseRoleFlags(str2, map3)).setLanguage(parseOptionalStringAttr(str2, REGEX_LANGUAGE, map3)); String optionalStringAttr2 = parseOptionalStringAttr(str2, REGEX_URI, map3); if (optionalStringAttr2 == null) { arrayList17 = arrayList26; uriResolveToUri = null; } else { uriResolveToUri = UriUtil.resolveToUri(str, optionalStringAttr2); arrayList17 = arrayList26; } String str8 = str7; format = format2; metadata = new Metadata(new HlsTrackMetadataEntry(stringAttr, stringAttr2, Collections.emptyList())); String stringAttr3 = parseStringAttr(str2, REGEX_TYPE, map3); stringAttr3.getClass(); stringAttr3.hashCode(); switch (stringAttr3) { case "SUBTITLES": arrayList = arrayList19; HlsMultivariantPlaylist.Variant variantWithSubtitleGroup = getVariantWithSubtitleGroup(arrayList9, stringAttr); if (variantWithSubtitleGroup != null) { String codecsOfType2 = Util.getCodecsOfType(variantWithSubtitleGroup.format.codecs, 3); language.setCodecs(codecsOfType2); mediaMimeType = MimeTypes.getMediaMimeType(codecsOfType2); } else { mediaMimeType = null; } if (mediaMimeType == null) { mediaMimeType = MimeTypes.TEXT_VTT; } language.setSampleMimeType(mediaMimeType).setMetadata(metadata); if (uriResolveToUri != null) { HlsMultivariantPlaylist.Rendition rendition = new HlsMultivariantPlaylist.Rendition(uriResolveToUri, language.build(), stringAttr, stringAttr2); arrayList2 = arrayList20; arrayList2.add(rendition); } else { arrayList2 = arrayList20; Log.w(LOG_TAG, "EXT-X-MEDIA tag with missing mandatory URI attribute: skipping"); } formatBuild = format; break; case "CLOSED-CAPTIONS": arrayList = arrayList19; String stringAttr4 = parseStringAttr(str2, REGEX_INSTREAM_ID, map3); if (stringAttr4.startsWith("CC")) { i10 = Integer.parseInt(stringAttr4.substring(2)); str3 = MimeTypes.APPLICATION_CEA608; } else { i10 = Integer.parseInt(stringAttr4.substring(7)); str3 = MimeTypes.APPLICATION_CEA708; } if (arrayList25 == null) { arrayList25 = new ArrayList(); } language.setSampleMimeType(str3).setAccessibilityChannel(i10); arrayList25.add(language.build()); formatBuild = format; arrayList2 = arrayList20; break; case "AUDIO": ArrayList arrayList27 = arrayList18; HlsMultivariantPlaylist.Variant variantWithAudioGroup = getVariantWithAudioGroup(arrayList9, stringAttr); if (variantWithAudioGroup != null) { arrayList18 = arrayList27; String codecsOfType3 = Util.getCodecsOfType(variantWithAudioGroup.format.codecs, 1); language.setCodecs(codecsOfType3); mediaMimeType2 = MimeTypes.getMediaMimeType(codecsOfType3); } else { arrayList18 = arrayList27; mediaMimeType2 = null; } String optionalStringAttr3 = parseOptionalStringAttr(str2, REGEX_CHANNELS, map3); if (optionalStringAttr3 != null) { language.setChannelCount(Integer.parseInt(Util.splitAtFirst(optionalStringAttr3, "/")[0])); if (MimeTypes.AUDIO_E_AC3.equals(mediaMimeType2) && optionalStringAttr3.endsWith("/JOC")) { language.setCodecs(MimeTypes.CODEC_E_AC3_JOC); mediaMimeType2 = MimeTypes.AUDIO_E_AC3_JOC; } } language.setSampleMimeType(mediaMimeType2); if (uriResolveToUri == null) { arrayList = arrayList19; if (variantWithAudioGroup != null) { formatBuild = language.build(); arrayList2 = arrayList20; } break; } else { language.setMetadata(metadata); arrayList = arrayList19; arrayList.add(new HlsMultivariantPlaylist.Rendition(uriResolveToUri, language.build(), stringAttr, stringAttr2)); } arrayList2 = arrayList20; formatBuild = format; break; case "VIDEO": HlsMultivariantPlaylist.Variant variantWithVideoGroup = getVariantWithVideoGroup(arrayList9, stringAttr); if (variantWithVideoGroup != null) { Format format3 = variantWithVideoGroup.format; String codecsOfType4 = Util.getCodecsOfType(format3.codecs, 2); language.setCodecs(codecsOfType4).setSampleMimeType(MimeTypes.getMediaMimeType(codecsOfType4)).setWidth(format3.width).setHeight(format3.height).setFrameRate(format3.frameRate); } if (uriResolveToUri != null) { language.setMetadata(metadata); arrayList18.add(new HlsMultivariantPlaylist.Rendition(uriResolveToUri, language.build(), stringAttr, stringAttr2)); break; } default: arrayList2 = arrayList20; arrayList = arrayList19; formatBuild = format; break; } i13++; arrayList20 = arrayList2; arrayList19 = arrayList; str7 = str8; format2 = formatBuild; } return new HlsMultivariantPlaylist(str, arrayList22, arrayList24, arrayList18, arrayList19, arrayList20, arrayList21, format2, z12 ? Collections.emptyList() : arrayList25, z13, map3, arrayList23); } String next = lineIterator.next(); if (next.startsWith(TAG_PREFIX)) { arrayList16.add(next); } boolean zStartsWith = next.startsWith(TAG_I_FRAME_STREAM_INF); ArrayList arrayList28 = arrayList13; if (next.startsWith(TAG_DEFINE)) { map3.put(parseStringAttr(next, REGEX_NAME, map3), parseStringAttr(next, REGEX_VALUE, map3)); } else { if (next.equals(TAG_INDEPENDENT_SEGMENTS)) { arrayList8 = arrayList14; arrayList7 = arrayList10; arrayList6 = arrayList11; arrayList5 = arrayList12; arrayList4 = arrayList16; arrayList3 = arrayList15; z11 = true; } else if (next.startsWith(TAG_MEDIA)) { arrayList14.add(next); } else if (next.startsWith(TAG_SESSION_KEY)) { DrmInitData.SchemeData drmSchemeData = parseDrmSchemeData(next, parseOptionalStringAttr(next, REGEX_KEYFORMAT, KEYFORMAT_IDENTITY, map3), map3); if (drmSchemeData != null) { arrayList15.add(new DrmInitData(parseEncryptionScheme(parseStringAttr(next, REGEX_METHOD, map3)), drmSchemeData)); } } else if (next.startsWith(TAG_STREAM_INF) || zStartsWith) { boolean zContains = z12 | next.contains(ATTR_CLOSED_CAPTIONS_NONE); if (zStartsWith) { i11 = 16384; z10 = zContains; } else { z10 = zContains; i11 = 0; } int intAttr = parseIntAttr(next, REGEX_BANDWIDTH); arrayList3 = arrayList15; arrayList4 = arrayList16; int optionalIntAttr = parseOptionalIntAttr(next, REGEX_AVERAGE_BANDWIDTH, -1); String optionalStringAttr4 = parseOptionalStringAttr(next, REGEX_VIDEO_RANGE, map3); arrayList5 = arrayList12; String optionalStringAttr5 = parseOptionalStringAttr(next, REGEX_CODECS, map3); arrayList6 = arrayList11; String optionalStringAttr6 = parseOptionalStringAttr(next, REGEX_SUPPLEMENTAL_CODECS, map3); arrayList7 = arrayList10; if (optionalStringAttr6 != null) { String[] strArrSplit = Util.split(Util.splitAtFirst(optionalStringAttr6, ",")[0], "/"); String str9 = strArrSplit[0]; arrayList8 = arrayList14; if (strArrSplit.length > 1) { str5 = strArrSplit[1]; map = map2; str4 = str9; codecsOfType = Util.getCodecsOfType(optionalStringAttr5, 2); if (isDolbyVisionFormat(optionalStringAttr4, codecsOfType, str4, str5)) { if (str4 == null) { str4 = codecsOfType; } String codecsWithoutType = Util.getCodecsWithoutType(optionalStringAttr5, 2); optionalStringAttr5 = codecsWithoutType != null ? e.j(str4, ",", codecsWithoutType) : str4; } optionalStringAttr = parseOptionalStringAttr(next, REGEX_RESOLUTION, map3); if (optionalStringAttr == null) { String[] strArrSplit2 = Util.split(optionalStringAttr, "x"); int i14 = Integer.parseInt(strArrSplit2[0]); int i15 = Integer.parseInt(strArrSplit2[1]); if (i14 <= 0 || i15 <= 0) { i15 = -1; i14 = -1; } String optionalStringAttr7 = parseOptionalStringAttr(next, REGEX_FRAME_RATE, map3); float f10 = optionalStringAttr7 != null ? Float.parseFloat(optionalStringAttr7) : -1.0f; String optionalStringAttr8 = parseOptionalStringAttr(next, REGEX_VIDEO, map3); String optionalStringAttr9 = parseOptionalStringAttr(next, REGEX_AUDIO, map3); String optionalStringAttr10 = parseOptionalStringAttr(next, REGEX_SUBTITLES, map3); String optionalStringAttr11 = parseOptionalStringAttr(next, REGEX_CLOSED_CAPTIONS, map3); if (zStartsWith) { uriResolveToUri2 = UriUtil.resolveToUri(str6, parseStringAttr(next, REGEX_URI, map3)); } else { if (!lineIterator.hasNext()) { throw ParserException.createForMalformedManifest("#EXT-X-STREAM-INF must be followed by another line", null); } uriResolveToUri2 = UriUtil.resolveToUri(str6, replaceVariableReferences(lineIterator.next(), map3)); } arrayList9.add(new HlsMultivariantPlaylist.Variant(uriResolveToUri2, new Format.Builder().setId(arrayList9.size()).setContainerMimeType(MimeTypes.APPLICATION_M3U8).setCodecs(optionalStringAttr5).setAverageBitrate(optionalIntAttr).setPeakBitrate(intAttr).setWidth(i14).setHeight(i15).setFrameRate(f10).setRoleFlags(i11).build(), optionalStringAttr8, optionalStringAttr9, optionalStringAttr10, optionalStringAttr11)); map2 = map; ArrayList arrayList29 = (ArrayList) map2.get(uriResolveToUri2); if (arrayList29 == null) { arrayList29 = new ArrayList(); map2.put(uriResolveToUri2, arrayList29); } arrayList29.add(new HlsTrackMetadataEntry.VariantInfo(optionalIntAttr, intAttr, optionalStringAttr8, optionalStringAttr9, optionalStringAttr10, optionalStringAttr11)); z11 = z13; z12 = z10; } } else { map = map2; str4 = str9; } } else { arrayList8 = arrayList14; map = map2; str4 = null; } str5 = null; codecsOfType = Util.getCodecsOfType(optionalStringAttr5, 2); if (isDolbyVisionFormat(optionalStringAttr4, codecsOfType, str4, str5)) { } optionalStringAttr = parseOptionalStringAttr(next, REGEX_RESOLUTION, map3); if (optionalStringAttr == null) { } } str6 = str; arrayList13 = arrayList28; arrayList15 = arrayList3; arrayList16 = arrayList4; arrayList12 = arrayList5; arrayList11 = arrayList6; arrayList10 = arrayList7; arrayList14 = arrayList8; } arrayList8 = arrayList14; arrayList7 = arrayList10; arrayList6 = arrayList11; arrayList5 = arrayList12; arrayList4 = arrayList16; arrayList3 = arrayList15; z11 = z13; str6 = str; arrayList13 = arrayList28; arrayList15 = arrayList3; arrayList16 = arrayList4; arrayList12 = arrayList5; arrayList11 = arrayList6; arrayList10 = arrayList7; arrayList14 = arrayList8; } } private static boolean parseOptionalBooleanAttribute(String str, Pattern pattern, boolean z10) { Matcher matcher = pattern.matcher(str); return matcher.find() ? BOOLEAN_TRUE.equals(matcher.group(1)) : z10; } private static double parseOptionalDoubleAttr(String str, Pattern pattern, double d10) { Matcher matcher = pattern.matcher(str); return matcher.find() ? Double.parseDouble((String) Assertions.checkNotNull(matcher.group(1))) : d10; } private static int parseOptionalIntAttr(String str, Pattern pattern, int i10) { Matcher matcher = pattern.matcher(str); return matcher.find() ? Integer.parseInt((String) Assertions.checkNotNull(matcher.group(1))) : i10; } private static long parseOptionalLongAttr(String str, Pattern pattern, long j10) { Matcher matcher = pattern.matcher(str); return matcher.find() ? Long.parseLong((String) Assertions.checkNotNull(matcher.group(1))) : j10; } @Nullable private static String parseOptionalStringAttr(String str, Pattern pattern, Map map) { return parseOptionalStringAttr(str, pattern, null, map); } private static int parseRoleFlags(String str, Map map) { String optionalStringAttr = parseOptionalStringAttr(str, REGEX_CHARACTERISTICS, map); if (TextUtils.isEmpty(optionalStringAttr)) { return 0; } String[] strArrSplit = Util.split(optionalStringAttr, ","); int i10 = Util.contains(strArrSplit, "public.accessibility.describes-video") ? 512 : 0; if (Util.contains(strArrSplit, "public.accessibility.transcribes-spoken-dialog")) { i10 |= 4096; } if (Util.contains(strArrSplit, "public.accessibility.describes-music-and-sound")) { i10 |= 1024; } return Util.contains(strArrSplit, "public.easy-to-read") ? i10 | 8192 : i10; } /* JADX WARN: Multi-variable type inference failed */ /* JADX WARN: Type inference failed for: r0v2, types: [int] */ /* JADX WARN: Type inference failed for: r0v6 */ /* JADX WARN: Type inference failed for: r0v7 */ private static int parseSelectionFlags(String str) { boolean optionalBooleanAttribute = parseOptionalBooleanAttribute(str, REGEX_DEFAULT, false); ?? r02 = optionalBooleanAttribute; if (parseOptionalBooleanAttribute(str, REGEX_FORCED, false)) { r02 = (optionalBooleanAttribute ? 1 : 0) | 2; } return parseOptionalBooleanAttribute(str, REGEX_AUTOSELECT, false) ? r02 | 4 : r02; } private static HlsMediaPlaylist.ServerControl parseServerControl(String str) { double optionalDoubleAttr = parseOptionalDoubleAttr(str, REGEX_CAN_SKIP_UNTIL, -9.223372036854776E18d); long j10 = optionalDoubleAttr == -9.223372036854776E18d ? -9223372036854775807L : (long) (optionalDoubleAttr * 1000000.0d); boolean optionalBooleanAttribute = parseOptionalBooleanAttribute(str, REGEX_CAN_SKIP_DATE_RANGES, false); double optionalDoubleAttr2 = parseOptionalDoubleAttr(str, REGEX_HOLD_BACK, -9.223372036854776E18d); long j11 = optionalDoubleAttr2 == -9.223372036854776E18d ? -9223372036854775807L : (long) (optionalDoubleAttr2 * 1000000.0d); double optionalDoubleAttr3 = parseOptionalDoubleAttr(str, REGEX_PART_HOLD_BACK, -9.223372036854776E18d); return new HlsMediaPlaylist.ServerControl(j10, optionalBooleanAttribute, j11, optionalDoubleAttr3 != -9.223372036854776E18d ? (long) (optionalDoubleAttr3 * 1000000.0d) : -9223372036854775807L, parseOptionalBooleanAttribute(str, REGEX_CAN_BLOCK_RELOAD, false)); } private static String parseStringAttr(String str, Pattern pattern, Map map) throws ParserException { String optionalStringAttr = parseOptionalStringAttr(str, pattern, map); if (optionalStringAttr != null) { return optionalStringAttr; } throw ParserException.createForMalformedManifest("Couldn't match " + pattern.pattern() + " in " + str, null); } private static long parseTimeSecondsToUs(String str, Pattern pattern) throws ParserException { return new BigDecimal(parseStringAttr(str, pattern, Collections.emptyMap())).multiply(new BigDecimal(1000000L)).longValue(); } private static String replaceVariableReferences(String str, Map map) { Matcher matcher = REGEX_VARIABLE_REFERENCE.matcher(str); StringBuffer stringBuffer = new StringBuffer(); while (matcher.find()) { String strGroup = matcher.group(1); if (map.containsKey(strGroup)) { matcher.appendReplacement(stringBuffer, Matcher.quoteReplacement(map.get(strGroup))); } } matcher.appendTail(stringBuffer); return stringBuffer.toString(); } private static int skipIgnorableWhitespace(BufferedReader bufferedReader, boolean z10, int i10) throws IOException { while (i10 != -1 && Character.isWhitespace(i10) && (z10 || !Util.isLinebreak(i10))) { i10 = bufferedReader.read(); } return i10; } public HlsPlaylistParser(HlsMultivariantPlaylist hlsMultivariantPlaylist, @Nullable HlsMediaPlaylist hlsMediaPlaylist) { this.multivariantPlaylist = hlsMultivariantPlaylist; this.previousMediaPlaylist = hlsMediaPlaylist; } private static String parseOptionalStringAttr(String str, Pattern pattern, String str2, Map map) { Matcher matcher = pattern.matcher(str); if (matcher.find()) { str2 = (String) Assertions.checkNotNull(matcher.group(1)); } return (map.isEmpty() || str2 == null) ? str2 : replaceVariableReferences(str2, map); } /* JADX WARN: Can't rename method to resolve collision */ @Override // androidx.media3.exoplayer.upstream.ParsingLoadable.Parser public HlsPlaylist parse(Uri uri, InputStream inputStream) throws IOException { String strTrim; BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream)); ArrayDeque arrayDeque = new ArrayDeque(); try { if (!checkPlaylistHeader(bufferedReader)) { throw ParserException.createForMalformedManifest("Input does not start with the #EXTM3U header.", null); } while (true) { String line = bufferedReader.readLine(); if (line == null) { Util.closeQuietly(bufferedReader); throw ParserException.createForMalformedManifest("Failed to parse the playlist, could not identify any tags.", null); } strTrim = line.trim(); if (!strTrim.isEmpty()) { if (!strTrim.startsWith(TAG_STREAM_INF)) { if (strTrim.startsWith(TAG_TARGET_DURATION) || strTrim.startsWith(TAG_MEDIA_SEQUENCE) || strTrim.startsWith(TAG_MEDIA_DURATION) || strTrim.startsWith(TAG_KEY) || strTrim.startsWith(TAG_BYTERANGE) || strTrim.equals(TAG_DISCONTINUITY) || strTrim.equals(TAG_DISCONTINUITY_SEQUENCE) || strTrim.equals(TAG_ENDLIST)) { break; } arrayDeque.add(strTrim); } else { arrayDeque.add(strTrim); return parseMultivariantPlaylist(new LineIterator(arrayDeque, bufferedReader), uri.toString()); } } } arrayDeque.add(strTrim); return parseMediaPlaylist(this.multivariantPlaylist, this.previousMediaPlaylist, new LineIterator(arrayDeque, bufferedReader), uri.toString()); } finally { Util.closeQuietly(bufferedReader); } } }