project-real-resurrection-3/rr3-apk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Add decompiled APK source code (JADX)

Browse Source 
- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
Daniel Elliott
2026-02-18 14:52:23 -08:00
parent cc210a65ea
commit f9d20bb3fc
26991 changed files with 2541449 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

271
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/CssParser.java Normal file
View File

@@ -0,0 +1,271 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import android.text.TextUtils;
import com.facebook.internal.security.CertificateUtil;
import com.mbridge.msdk.playercommon.exoplayer2.util.ColorParser;
import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/* loaded from: classes4.dex */
final class CssParser {
private static final String BLOCK_END = "}";
private static final String BLOCK_START = "{";
private static final String PROPERTY_BGCOLOR = "background-color";
private static final String PROPERTY_FONT_FAMILY = "font-family";
private static final String PROPERTY_FONT_STYLE = "font-style";
private static final String PROPERTY_FONT_WEIGHT = "font-weight";
private static final String PROPERTY_TEXT_DECORATION = "text-decoration";
private static final String VALUE_BOLD = "bold";
private static final String VALUE_ITALIC = "italic";
private static final String VALUE_UNDERLINE = "underline";
private static final Pattern VOICE_NAME_PATTERN = Pattern.compile("\\[voice=\"([^\"]*)\"\\]");
private final ParsableByteArray styleInput = new ParsableByteArray();
private final StringBuilder stringBuilder = new StringBuilder();
public final WebvttCssStyle parseBlock(ParsableByteArray parsableByteArray) {
this.stringBuilder.setLength(0);
int position = parsableByteArray.getPosition();
skipStyleBlock(parsableByteArray);
this.styleInput.reset(parsableByteArray.data, parsableByteArray.getPosition());
this.styleInput.setPosition(position);
String parseSelector = parseSelector(this.styleInput, this.stringBuilder);
if (parseSelector == null || !BLOCK_START.equals(parseNextToken(this.styleInput, this.stringBuilder))) {
return null;
}
WebvttCssStyle webvttCssStyle = new WebvttCssStyle();
applySelectorToStyle(webvttCssStyle, parseSelector);
String str = null;
boolean z = false;
while (!z) {
int position2 = this.styleInput.getPosition();
str = parseNextToken(this.styleInput, this.stringBuilder);
boolean z2 = str == null || BLOCK_END.equals(str);
if (!z2) {
this.styleInput.setPosition(position2);
parseStyleDeclaration(this.styleInput, webvttCssStyle, this.stringBuilder);
}
z = z2;
}
if (BLOCK_END.equals(str)) {
return webvttCssStyle;
}
return null;
}
private static String parseSelector(ParsableByteArray parsableByteArray, StringBuilder sb) {
skipWhitespaceAndComments(parsableByteArray);
if (parsableByteArray.bytesLeft() < 5 || !"::cue".equals(parsableByteArray.readString(5))) {
return null;
}
int position = parsableByteArray.getPosition();
String parseNextToken = parseNextToken(parsableByteArray, sb);
if (parseNextToken == null) {
return null;
}
if (BLOCK_START.equals(parseNextToken)) {
parsableByteArray.setPosition(position);
return "";
}
String readCueTarget = "(".equals(parseNextToken) ? readCueTarget(parsableByteArray) : null;
String parseNextToken2 = parseNextToken(parsableByteArray, sb);
if (!")".equals(parseNextToken2) || parseNextToken2 == null) {
return null;
}
return readCueTarget;
}
private static String readCueTarget(ParsableByteArray parsableByteArray) {
int position = parsableByteArray.getPosition();
int limit = parsableByteArray.limit();
boolean z = false;
while (position < limit && !z) {
int i = position + 1;
z = ((char) parsableByteArray.data[position]) == ')';
position = i;
}
return parsableByteArray.readString((position - 1) - parsableByteArray.getPosition()).trim();
}
private static void parseStyleDeclaration(ParsableByteArray parsableByteArray, WebvttCssStyle webvttCssStyle, StringBuilder sb) {
skipWhitespaceAndComments(parsableByteArray);
String parseIdentifier = parseIdentifier(parsableByteArray, sb);
if (!"".equals(parseIdentifier) && CertificateUtil.DELIMITER.equals(parseNextToken(parsableByteArray, sb))) {
skipWhitespaceAndComments(parsableByteArray);
String parsePropertyValue = parsePropertyValue(parsableByteArray, sb);
if (parsePropertyValue == null || "".equals(parsePropertyValue)) {
return;
}
int position = parsableByteArray.getPosition();
String parseNextToken = parseNextToken(parsableByteArray, sb);
if (!";".equals(parseNextToken)) {
if (!BLOCK_END.equals(parseNextToken)) {
return;
} else {
parsableByteArray.setPosition(position);
}
}
if ("color".equals(parseIdentifier)) {
webvttCssStyle.setFontColor(ColorParser.parseCssColor(parsePropertyValue));
return;
}
if (PROPERTY_BGCOLOR.equals(parseIdentifier)) {
webvttCssStyle.setBackgroundColor(ColorParser.parseCssColor(parsePropertyValue));
return;
}
if (PROPERTY_TEXT_DECORATION.equals(parseIdentifier)) {
if ("underline".equals(parsePropertyValue)) {
webvttCssStyle.setUnderline(true);
}
} else {
if (PROPERTY_FONT_FAMILY.equals(parseIdentifier)) {
webvttCssStyle.setFontFamily(parsePropertyValue);
return;
}
if (PROPERTY_FONT_WEIGHT.equals(parseIdentifier)) {
if ("bold".equals(parsePropertyValue)) {
webvttCssStyle.setBold(true);
}
} else if (PROPERTY_FONT_STYLE.equals(parseIdentifier) && "italic".equals(parsePropertyValue)) {
webvttCssStyle.setItalic(true);
}
}
}
}
public static void skipWhitespaceAndComments(ParsableByteArray parsableByteArray) {
while (true) {
for (boolean z = true; parsableByteArray.bytesLeft() > 0 && z; z = false) {
if (!maybeSkipWhitespace(parsableByteArray) && !maybeSkipComment(parsableByteArray)) {
}
}
return;
}
}
public static String parseNextToken(ParsableByteArray parsableByteArray, StringBuilder sb) {
skipWhitespaceAndComments(parsableByteArray);
if (parsableByteArray.bytesLeft() == 0) {
return null;
}
String parseIdentifier = parseIdentifier(parsableByteArray, sb);
if (!"".equals(parseIdentifier)) {
return parseIdentifier;
}
return "" + ((char) parsableByteArray.readUnsignedByte());
}
private static boolean maybeSkipWhitespace(ParsableByteArray parsableByteArray) {
char peekCharAtPosition = peekCharAtPosition(parsableByteArray, parsableByteArray.getPosition());
if (peekCharAtPosition != '\t' && peekCharAtPosition != '\n' && peekCharAtPosition != '\f' && peekCharAtPosition != '\r' && peekCharAtPosition != ' ') {
return false;
}
parsableByteArray.skipBytes(1);
return true;
}
public static void skipStyleBlock(ParsableByteArray parsableByteArray) {
while (!TextUtils.isEmpty(parsableByteArray.readLine())) {
}
}
private static char peekCharAtPosition(ParsableByteArray parsableByteArray, int i) {
return (char) parsableByteArray.data[i];
}
private static String parsePropertyValue(ParsableByteArray parsableByteArray, StringBuilder sb) {
StringBuilder sb2 = new StringBuilder();
boolean z = false;
while (!z) {
int position = parsableByteArray.getPosition();
String parseNextToken = parseNextToken(parsableByteArray, sb);
if (parseNextToken == null) {
return null;
}
if (BLOCK_END.equals(parseNextToken) || ";".equals(parseNextToken)) {
parsableByteArray.setPosition(position);
z = true;
} else {
sb2.append(parseNextToken);
}
}
return sb2.toString();
}
private static boolean maybeSkipComment(ParsableByteArray parsableByteArray) {
int position = parsableByteArray.getPosition();
int limit = parsableByteArray.limit();
byte[] bArr = parsableByteArray.data;
if (position + 2 > limit) {
return false;
}
int i = position + 1;
if (bArr[position] != 47) {
return false;
}
int i2 = position + 2;
if (bArr[i] != 42) {
return false;
}
while (true) {
int i3 = i2 + 1;
if (i3 < limit) {
if (((char) bArr[i2]) == '*' && ((char) bArr[i3]) == '/') {
i2 += 2;
limit = i2;
} else {
i2 = i3;
}
} else {
parsableByteArray.skipBytes(limit - parsableByteArray.getPosition());
return true;
}
}
}
private static String parseIdentifier(ParsableByteArray parsableByteArray, StringBuilder sb) {
boolean z = false;
sb.setLength(0);
int position = parsableByteArray.getPosition();
int limit = parsableByteArray.limit();
while (position < limit && !z) {
char c = (char) parsableByteArray.data[position];
if ((c < 'A' || c > 'Z') && ((c < 'a' || c > 'z') && !((c >= '0' && c <= '9') || c == '#' || c == '-' || c == '.' || c == '_'))) {
z = true;
} else {
position++;
sb.append(c);
}
}
parsableByteArray.skipBytes(position - parsableByteArray.getPosition());
return sb.toString();
}
private void applySelectorToStyle(WebvttCssStyle webvttCssStyle, String str) {
if ("".equals(str)) {
return;
}
int indexOf = str.indexOf(91);
if (indexOf != -1) {
Matcher matcher = VOICE_NAME_PATTERN.matcher(str.substring(indexOf));
if (matcher.matches()) {
webvttCssStyle.setTargetVoice(matcher.group(1));
}
str = str.substring(0, indexOf);
}
String[] split = Util.split(str, "\\.");
String str2 = split[0];
int indexOf2 = str2.indexOf(35);
if (indexOf2 != -1) {
webvttCssStyle.setTargetTagName(str2.substring(0, indexOf2));
webvttCssStyle.setTargetId(str2.substring(indexOf2 + 1));
} else {
webvttCssStyle.setTargetTagName(str2);
}
if (split.length > 1) {
webvttCssStyle.setTargetClasses((String[]) Arrays.copyOfRange(split, 1, split.length));
}
}
}

65
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/Mp4WebvttDecoder.java Normal file
View File

@@ -0,0 +1,65 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
import com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder;
import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderException;
import com.mbridge.msdk.playercommon.exoplayer2.text.webvtt.WebvttCue;
import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
import java.util.ArrayList;
import java.util.Collections;
/* loaded from: classes4.dex */
public final class Mp4WebvttDecoder extends SimpleSubtitleDecoder {
private static final int BOX_HEADER_SIZE = 8;
private static final int TYPE_payl = Util.getIntegerCodeForString("payl");
private static final int TYPE_sttg = Util.getIntegerCodeForString("sttg");
private static final int TYPE_vttc = Util.getIntegerCodeForString("vttc");
private final WebvttCue.Builder builder;
private final ParsableByteArray sampleData;
public Mp4WebvttDecoder() {
super("Mp4WebvttDecoder");
this.sampleData = new ParsableByteArray();
this.builder = new WebvttCue.Builder();
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder
public final Mp4WebvttSubtitle decode(byte[] bArr, int i, boolean z) throws SubtitleDecoderException {
this.sampleData.reset(bArr, i);
ArrayList arrayList = new ArrayList();
while (this.sampleData.bytesLeft() > 0) {
if (this.sampleData.bytesLeft() < 8) {
throw new SubtitleDecoderException("Incomplete Mp4Webvtt Top Level box header found.");
}
int readInt = this.sampleData.readInt();
if (this.sampleData.readInt() == TYPE_vttc) {
arrayList.add(parseVttCueBox(this.sampleData, this.builder, readInt - 8));
} else {
this.sampleData.skipBytes(readInt - 8);
}
}
return new Mp4WebvttSubtitle(arrayList);
}
private static Cue parseVttCueBox(ParsableByteArray parsableByteArray, WebvttCue.Builder builder, int i) throws SubtitleDecoderException {
builder.reset();
while (i > 0) {
if (i < 8) {
throw new SubtitleDecoderException("Incomplete vtt cue box header found.");
}
int readInt = parsableByteArray.readInt();
int readInt2 = parsableByteArray.readInt();
int i2 = readInt - 8;
String fromUtf8Bytes = Util.fromUtf8Bytes(parsableByteArray.data, parsableByteArray.getPosition(), i2);
parsableByteArray.skipBytes(i2);
i = (i - 8) - i2;
if (readInt2 == TYPE_sttg) {
WebvttCueParser.parseCueSettingsList(fromUtf8Bytes, builder);
} else if (readInt2 == TYPE_payl) {
WebvttCueParser.parseCueText(null, fromUtf8Bytes.trim(), builder, Collections.emptyList());
}
}
return builder.build();
}
}

37
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/Mp4WebvttSubtitle.java Normal file
View File

@@ -0,0 +1,37 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
import java.util.Collections;
import java.util.List;
/* loaded from: classes4.dex */
final class Mp4WebvttSubtitle implements Subtitle {
private final List<Cue> cues;
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
public final int getEventTimeCount() {
return 1;
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
public final int getNextEventTimeIndex(long j) {
return j < 0 ? 0 : -1;
}
public Mp4WebvttSubtitle(List<Cue> list) {
this.cues = Collections.unmodifiableList(list);
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
public final long getEventTime(int i) {
Assertions.checkArgument(i == 0);
return 0L;
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
public final List<Cue> getCues(long j) {
return j >= 0 ? this.cues : Collections.emptyList();
}
}

248
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttCssStyle.java Normal file
View File

@@ -0,0 +1,248 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import android.text.Layout;
import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/* loaded from: classes4.dex */
public final class WebvttCssStyle {
public static final int FONT_SIZE_UNIT_EM = 2;
public static final int FONT_SIZE_UNIT_PERCENT = 3;
public static final int FONT_SIZE_UNIT_PIXEL = 1;
private static final int OFF = 0;
private static final int ON = 1;
public static final int STYLE_BOLD = 1;
public static final int STYLE_BOLD_ITALIC = 3;
public static final int STYLE_ITALIC = 2;
public static final int STYLE_NORMAL = 0;
public static final int UNSPECIFIED = -1;
private int backgroundColor;
private int bold;
private int fontColor;
private String fontFamily;
private float fontSize;
private int fontSizeUnit;
private boolean hasBackgroundColor;
private boolean hasFontColor;
private int italic;
private int linethrough;
private List<String> targetClasses;
private String targetId;
private String targetTag;
private String targetVoice;
private Layout.Alignment textAlign;
private int underline;
@Retention(RetentionPolicy.SOURCE)
public @interface FontSizeUnit {
}
@Retention(RetentionPolicy.SOURCE)
public @interface OptionalBoolean {
}
@Retention(RetentionPolicy.SOURCE)
public @interface StyleFlags {
}
public final String getFontFamily() {
return this.fontFamily;
}
public final float getFontSize() {
return this.fontSize;
}
public final int getFontSizeUnit() {
return this.fontSizeUnit;
}
public final int getStyle() {
int i = this.bold;
if (i == -1 && this.italic == -1) {
return -1;
}
return (i == 1 ? 1 : 0) | (this.italic == 1 ? 2 : 0);
}
public final Layout.Alignment getTextAlign() {
return this.textAlign;
}
public final boolean hasBackgroundColor() {
return this.hasBackgroundColor;
}
public final boolean hasFontColor() {
return this.hasFontColor;
}
public final boolean isLinethrough() {
return this.linethrough == 1;
}
public final boolean isUnderline() {
return this.underline == 1;
}
public final WebvttCssStyle setBackgroundColor(int i) {
this.backgroundColor = i;
this.hasBackgroundColor = true;
return this;
}
public final WebvttCssStyle setBold(boolean z) {
this.bold = z ? 1 : 0;
return this;
}
public final WebvttCssStyle setFontColor(int i) {
this.fontColor = i;
this.hasFontColor = true;
return this;
}
public final WebvttCssStyle setFontSize(float f) {
this.fontSize = f;
return this;
}
public final WebvttCssStyle setFontSizeUnit(short s) {
this.fontSizeUnit = s;
return this;
}
public final WebvttCssStyle setItalic(boolean z) {
this.italic = z ? 1 : 0;
return this;
}
public final WebvttCssStyle setLinethrough(boolean z) {
this.linethrough = z ? 1 : 0;
return this;
}
public final void setTargetId(String str) {
this.targetId = str;
}
public final void setTargetTagName(String str) {
this.targetTag = str;
}
public final void setTargetVoice(String str) {
this.targetVoice = str;
}
public final WebvttCssStyle setTextAlign(Layout.Alignment alignment) {
this.textAlign = alignment;
return this;
}
public final WebvttCssStyle setUnderline(boolean z) {
this.underline = z ? 1 : 0;
return this;
}
public WebvttCssStyle() {
reset();
}
public final void reset() {
this.targetId = "";
this.targetTag = "";
this.targetClasses = Collections.emptyList();
this.targetVoice = "";
this.fontFamily = null;
this.hasFontColor = false;
this.hasBackgroundColor = false;
this.linethrough = -1;
this.underline = -1;
this.bold = -1;
this.italic = -1;
this.fontSizeUnit = -1;
this.textAlign = null;
}
public final void setTargetClasses(String[] strArr) {
this.targetClasses = Arrays.asList(strArr);
}
public final int getSpecificityScore(String str, String str2, String[] strArr, String str3) {
if (this.targetId.isEmpty() && this.targetTag.isEmpty() && this.targetClasses.isEmpty() && this.targetVoice.isEmpty()) {
return str2.isEmpty() ? 1 : 0;
}
int updateScoreForMatch = updateScoreForMatch(updateScoreForMatch(updateScoreForMatch(0, this.targetId, str, 1073741824), this.targetTag, str2, 2), this.targetVoice, str3, 4);
if (updateScoreForMatch == -1 || !Arrays.asList(strArr).containsAll(this.targetClasses)) {
return 0;
}
return updateScoreForMatch + (this.targetClasses.size() * 4);
}
public final WebvttCssStyle setFontFamily(String str) {
this.fontFamily = Util.toLowerInvariant(str);
return this;
}
public final int getFontColor() {
if (this.hasFontColor) {
return this.fontColor;
}
throw new IllegalStateException("Font color not defined");
}
public final int getBackgroundColor() {
if (this.hasBackgroundColor) {
return this.backgroundColor;
}
throw new IllegalStateException("Background color not defined.");
}
public final void cascadeFrom(WebvttCssStyle webvttCssStyle) {
if (webvttCssStyle.hasFontColor) {
setFontColor(webvttCssStyle.fontColor);
}
int i = webvttCssStyle.bold;
if (i != -1) {
this.bold = i;
}
int i2 = webvttCssStyle.italic;
if (i2 != -1) {
this.italic = i2;
}
String str = webvttCssStyle.fontFamily;
if (str != null) {
this.fontFamily = str;
}
if (this.linethrough == -1) {
this.linethrough = webvttCssStyle.linethrough;
}
if (this.underline == -1) {
this.underline = webvttCssStyle.underline;
}
if (this.textAlign == null) {
this.textAlign = webvttCssStyle.textAlign;
}
if (this.fontSizeUnit == -1) {
this.fontSizeUnit = webvttCssStyle.fontSizeUnit;
this.fontSize = webvttCssStyle.fontSize;
}
if (webvttCssStyle.hasBackgroundColor) {
setBackgroundColor(webvttCssStyle.backgroundColor);
}
}
private static int updateScoreForMatch(int i, String str, String str2, int i2) {
if (str.isEmpty() || i == -1) {
return i;
}
if (str.equals(str2)) {
return i + i2;
}
return -1;
}
}

160
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttCue.java Normal file
View File

@@ -0,0 +1,160 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import android.text.Layout;
import android.text.SpannableStringBuilder;
import android.util.Log;
import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
/* loaded from: classes4.dex */
public final class WebvttCue extends Cue {
public final long endTime;
public final long startTime;
public final boolean isNormalCue() {
return this.line == Float.MIN_VALUE && this.position == Float.MIN_VALUE;
}
public WebvttCue(CharSequence charSequence) {
this(0L, 0L, charSequence);
}
public WebvttCue(long j, long j2, CharSequence charSequence) {
this(j, j2, charSequence, null, Float.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, Float.MIN_VALUE, Integer.MIN_VALUE, Float.MIN_VALUE);
}
public WebvttCue(long j, long j2, CharSequence charSequence, Layout.Alignment alignment, float f, int i, int i2, float f2, int i3, float f3) {
super(charSequence, alignment, f, i, i2, f2, i3, f3);
this.startTime = j;
this.endTime = j2;
}
public static class Builder {
private static final String TAG = "WebvttCueBuilder";
private long endTime;
private float line;
private int lineAnchor;
private int lineType;
private float position;
private int positionAnchor;
private long startTime;
private SpannableStringBuilder text;
private Layout.Alignment textAlignment;
private float width;
public void reset() {
this.startTime = 0L;
this.endTime = 0L;
this.text = null;
this.textAlignment = null;
this.line = Float.MIN_VALUE;
this.lineType = Integer.MIN_VALUE;
this.lineAnchor = Integer.MIN_VALUE;
this.position = Float.MIN_VALUE;
this.positionAnchor = Integer.MIN_VALUE;
this.width = Float.MIN_VALUE;
}
public Builder setEndTime(long j) {
this.endTime = j;
return this;
}
public Builder setLine(float f) {
this.line = f;
return this;
}
public Builder setLineAnchor(int i) {
this.lineAnchor = i;
return this;
}
public Builder setLineType(int i) {
this.lineType = i;
return this;
}
public Builder setPosition(float f) {
this.position = f;
return this;
}
public Builder setPositionAnchor(int i) {
this.positionAnchor = i;
return this;
}
public Builder setStartTime(long j) {
this.startTime = j;
return this;
}
public Builder setText(SpannableStringBuilder spannableStringBuilder) {
this.text = spannableStringBuilder;
return this;
}
public Builder setTextAlignment(Layout.Alignment alignment) {
this.textAlignment = alignment;
return this;
}
public Builder setWidth(float f) {
this.width = f;
return this;
}
public Builder() {
reset();
}
public WebvttCue build() {
if (this.position != Float.MIN_VALUE && this.positionAnchor == Integer.MIN_VALUE) {
derivePositionAnchorFromAlignment();
}
return new WebvttCue(this.startTime, this.endTime, this.text, this.textAlignment, this.line, this.lineType, this.lineAnchor, this.position, this.positionAnchor, this.width);
}
private Builder derivePositionAnchorFromAlignment() {
Layout.Alignment alignment = this.textAlignment;
if (alignment == null) {
this.positionAnchor = Integer.MIN_VALUE;
} else {
int i = AnonymousClass1.$SwitchMap$android$text$Layout$Alignment[alignment.ordinal()];
if (i == 1) {
this.positionAnchor = 0;
} else if (i == 2) {
this.positionAnchor = 1;
} else if (i != 3) {
Log.w(TAG, "Unrecognized alignment: " + this.textAlignment);
this.positionAnchor = 0;
} else {
this.positionAnchor = 2;
}
}
return this;
}
}
/* renamed from: com.mbridge.msdk.playercommon.exoplayer2.text.webvtt.WebvttCue$1, reason: invalid class name */
public static /* synthetic */ class AnonymousClass1 {
static final /* synthetic */ int[] $SwitchMap$android$text$Layout$Alignment;
static {
int[] iArr = new int[Layout.Alignment.values().length];
$SwitchMap$android$text$Layout$Alignment = iArr;
try {
iArr[Layout.Alignment.ALIGN_NORMAL.ordinal()] = 1;
} catch (NoSuchFieldError unused) {
}
try {
$SwitchMap$android$text$Layout$Alignment[Layout.Alignment.ALIGN_CENTER.ordinal()] = 2;
} catch (NoSuchFieldError unused2) {
}
try {
$SwitchMap$android$text$Layout$Alignment[Layout.Alignment.ALIGN_OPPOSITE.ordinal()] = 3;
} catch (NoSuchFieldError unused3) {
}
}
}
}

434
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttCueParser.java Normal file
View File

@@ -0,0 +1,434 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import android.text.Layout;
import android.text.SpannableStringBuilder;
import android.text.TextUtils;
import android.text.style.AbsoluteSizeSpan;
import android.text.style.AlignmentSpan;
import android.text.style.BackgroundColorSpan;
import android.text.style.ForegroundColorSpan;
import android.text.style.RelativeSizeSpan;
import android.text.style.StrikethroughSpan;
import android.text.style.StyleSpan;
import android.text.style.TypefaceSpan;
import android.text.style.UnderlineSpan;
import android.util.Log;
import androidx.annotation.NonNull;
import com.facebook.internal.security.CertificateUtil;
import com.ironsource.v8;
import com.mbridge.msdk.playercommon.exoplayer2.text.webvtt.WebvttCue;
import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/* loaded from: classes4.dex */
public final class WebvttCueParser {
private static final char CHAR_AMPERSAND = '&';
private static final char CHAR_GREATER_THAN = '>';
private static final char CHAR_LESS_THAN = '<';
private static final char CHAR_SEMI_COLON = ';';
private static final char CHAR_SLASH = '/';
private static final char CHAR_SPACE = ' ';
public static final Pattern CUE_HEADER_PATTERN = Pattern.compile("^(\\S+)\\s+-->\\s+(\\S+)(.*)?$");
private static final Pattern CUE_SETTING_PATTERN = Pattern.compile("(\\S+?):(\\S+)");
private static final String ENTITY_AMPERSAND = "amp";
private static final String ENTITY_GREATER_THAN = "gt";
private static final String ENTITY_LESS_THAN = "lt";
private static final String ENTITY_NON_BREAK_SPACE = "nbsp";
private static final int STYLE_BOLD = 1;
private static final int STYLE_ITALIC = 2;
private static final String TAG = "WebvttCueParser";
private static final String TAG_BOLD = "b";
private static final String TAG_CLASS = "c";
private static final String TAG_ITALIC = "i";
private static final String TAG_LANG = "lang";
private static final String TAG_UNDERLINE = "u";
private static final String TAG_VOICE = "v";
private final StringBuilder textBuilder = new StringBuilder();
public final boolean parseCue(ParsableByteArray parsableByteArray, WebvttCue.Builder builder, List<WebvttCssStyle> list) {
String readLine = parsableByteArray.readLine();
if (readLine == null) {
return false;
}
Pattern pattern = CUE_HEADER_PATTERN;
Matcher matcher = pattern.matcher(readLine);
if (matcher.matches()) {
return parseCue(null, matcher, parsableByteArray, builder, this.textBuilder, list);
}
String readLine2 = parsableByteArray.readLine();
if (readLine2 == null) {
return false;
}
Matcher matcher2 = pattern.matcher(readLine2);
if (matcher2.matches()) {
return parseCue(readLine.trim(), matcher2, parsableByteArray, builder, this.textBuilder, list);
}
return false;
}
public static void parseCueSettingsList(String str, WebvttCue.Builder builder) {
Matcher matcher = CUE_SETTING_PATTERN.matcher(str);
while (matcher.find()) {
String group = matcher.group(1);
String group2 = matcher.group(2);
try {
if ("line".equals(group)) {
parseLineAttribute(group2, builder);
} else if ("align".equals(group)) {
builder.setTextAlignment(parseTextAlignment(group2));
} else if (v8.h.L.equals(group)) {
parsePositionAttribute(group2, builder);
} else if ("size".equals(group)) {
builder.setWidth(WebvttParserUtil.parsePercentage(group2));
} else {
Log.w(TAG, "Unknown cue setting " + group + CertificateUtil.DELIMITER + group2);
}
} catch (NumberFormatException unused) {
Log.w(TAG, "Skipping bad cue setting: " + matcher.group());
}
}
}
public static void parseCueText(String str, String str2, WebvttCue.Builder builder, List<WebvttCssStyle> list) {
SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder();
ArrayDeque arrayDeque = new ArrayDeque();
ArrayList arrayList = new ArrayList();
int i = 0;
while (i < str2.length()) {
char charAt = str2.charAt(i);
if (charAt == '&') {
i++;
int indexOf = str2.indexOf(59, i);
int indexOf2 = str2.indexOf(32, i);
if (indexOf == -1) {
indexOf = indexOf2;
} else if (indexOf2 != -1) {
indexOf = Math.min(indexOf, indexOf2);
}
if (indexOf != -1) {
applyEntity(str2.substring(i, indexOf), spannableStringBuilder);
if (indexOf == indexOf2) {
spannableStringBuilder.append(" ");
}
i = indexOf + 1;
} else {
spannableStringBuilder.append(charAt);
}
} else if (charAt == '<') {
int i2 = i + 1;
if (i2 < str2.length()) {
boolean z = str2.charAt(i2) == '/';
i2 = findEndOfTag(str2, i2);
int i3 = i2 - 2;
boolean z2 = str2.charAt(i3) == '/';
int i4 = i + (z ? 2 : 1);
if (!z2) {
i3 = i2 - 1;
}
String substring = str2.substring(i4, i3);
String tagName = getTagName(substring);
if (tagName != null && isSupportedTag(tagName)) {
if (z) {
while (!arrayDeque.isEmpty()) {
StartTag startTag = (StartTag) arrayDeque.pop();
applySpansForTag(str, startTag, spannableStringBuilder, list, arrayList);
if (startTag.name.equals(tagName)) {
break;
}
}
} else if (!z2) {
arrayDeque.push(StartTag.buildStartTag(substring, spannableStringBuilder.length()));
}
}
}
i = i2;
} else {
spannableStringBuilder.append(charAt);
i++;
}
}
while (!arrayDeque.isEmpty()) {
applySpansForTag(str, (StartTag) arrayDeque.pop(), spannableStringBuilder, list, arrayList);
}
applySpansForTag(str, StartTag.buildWholeCueVirtualTag(), spannableStringBuilder, list, arrayList);
builder.setText(spannableStringBuilder);
}
private static boolean parseCue(String str, Matcher matcher, ParsableByteArray parsableByteArray, WebvttCue.Builder builder, StringBuilder sb, List<WebvttCssStyle> list) {
try {
builder.setStartTime(WebvttParserUtil.parseTimestampUs(matcher.group(1))).setEndTime(WebvttParserUtil.parseTimestampUs(matcher.group(2)));
parseCueSettingsList(matcher.group(3), builder);
sb.setLength(0);
while (true) {
String readLine = parsableByteArray.readLine();
if (!TextUtils.isEmpty(readLine)) {
if (sb.length() > 0) {
sb.append("\n");
}
sb.append(readLine.trim());
} else {
parseCueText(str, sb.toString(), builder, list);
return true;
}
}
} catch (NumberFormatException unused) {
Log.w(TAG, "Skipping cue with bad header: " + matcher.group());
return false;
}
}
private static void parseLineAttribute(String str, WebvttCue.Builder builder) throws NumberFormatException {
int indexOf = str.indexOf(44);
if (indexOf != -1) {
builder.setLineAnchor(parsePositionAnchor(str.substring(indexOf + 1)));
str = str.substring(0, indexOf);
} else {
builder.setLineAnchor(Integer.MIN_VALUE);
}
if (str.endsWith("%")) {
builder.setLine(WebvttParserUtil.parsePercentage(str)).setLineType(0);
return;
}
int parseInt = Integer.parseInt(str);
if (parseInt < 0) {
parseInt--;
}
builder.setLine(parseInt).setLineType(1);
}
private static void parsePositionAttribute(String str, WebvttCue.Builder builder) throws NumberFormatException {
int indexOf = str.indexOf(44);
if (indexOf != -1) {
builder.setPositionAnchor(parsePositionAnchor(str.substring(indexOf + 1)));
str = str.substring(0, indexOf);
} else {
builder.setPositionAnchor(Integer.MIN_VALUE);
}
builder.setPosition(WebvttParserUtil.parsePercentage(str));
}
private static int parsePositionAnchor(String str) {
str.hashCode();
switch (str) {
case "center":
case "middle":
return 1;
case "end":
return 2;
case "start":
return 0;
default:
Log.w(TAG, "Invalid anchor value: " + str);
return Integer.MIN_VALUE;
}
}
private static Layout.Alignment parseTextAlignment(String str) {
str.hashCode();
switch (str) {
case "center":
case "middle":
return Layout.Alignment.ALIGN_CENTER;
case "end":
case "right":
return Layout.Alignment.ALIGN_OPPOSITE;
case "left":
case "start":
return Layout.Alignment.ALIGN_NORMAL;
default:
Log.w(TAG, "Invalid alignment value: " + str);
return null;
}
}
private static int findEndOfTag(String str, int i) {
int indexOf = str.indexOf(62, i);
return indexOf == -1 ? str.length() : indexOf + 1;
}
private static void applyEntity(String str, SpannableStringBuilder spannableStringBuilder) {
str.hashCode();
switch (str) {
case "gt":
spannableStringBuilder.append(CHAR_GREATER_THAN);
break;
case "lt":
spannableStringBuilder.append(CHAR_LESS_THAN);
break;
case "amp":
spannableStringBuilder.append(CHAR_AMPERSAND);
break;
case "nbsp":
spannableStringBuilder.append(CHAR_SPACE);
break;
default:
Log.w(TAG, "ignoring unsupported entity: '&" + str + ";'");
break;
}
}
private static boolean isSupportedTag(String str) {
str.hashCode();
switch (str) {
case "b":
case "c":
case "i":
case "u":
case "v":
case "lang":
return true;
default:
return false;
}
}
private static void applySpansForTag(String str, StartTag startTag, SpannableStringBuilder spannableStringBuilder, List<WebvttCssStyle> list, List<StyleMatch> list2) {
int i;
int length;
i = startTag.position;
length = spannableStringBuilder.length();
String str2 = startTag.name;
str2.hashCode();
switch (str2) {
case "":
case "c":
case "v":
case "lang":
break;
case "b":
spannableStringBuilder.setSpan(new StyleSpan(1), i, length, 33);
break;
case "i":
spannableStringBuilder.setSpan(new StyleSpan(2), i, length, 33);
break;
case "u":
spannableStringBuilder.setSpan(new UnderlineSpan(), i, length, 33);
break;
default:
return;
}
list2.clear();
getApplicableStyles(list, str, startTag, list2);
int size = list2.size();
for (int i2 = 0; i2 < size; i2++) {
applyStyleToText(spannableStringBuilder, list2.get(i2).style, i, length);
}
}
private static void applyStyleToText(SpannableStringBuilder spannableStringBuilder, WebvttCssStyle webvttCssStyle, int i, int i2) {
if (webvttCssStyle == null) {
return;
}
if (webvttCssStyle.getStyle() != -1) {
spannableStringBuilder.setSpan(new StyleSpan(webvttCssStyle.getStyle()), i, i2, 33);
}
if (webvttCssStyle.isLinethrough()) {
spannableStringBuilder.setSpan(new StrikethroughSpan(), i, i2, 33);
}
if (webvttCssStyle.isUnderline()) {
spannableStringBuilder.setSpan(new UnderlineSpan(), i, i2, 33);
}
if (webvttCssStyle.hasFontColor()) {
spannableStringBuilder.setSpan(new ForegroundColorSpan(webvttCssStyle.getFontColor()), i, i2, 33);
}
if (webvttCssStyle.hasBackgroundColor()) {
spannableStringBuilder.setSpan(new BackgroundColorSpan(webvttCssStyle.getBackgroundColor()), i, i2, 33);
}
if (webvttCssStyle.getFontFamily() != null) {
spannableStringBuilder.setSpan(new TypefaceSpan(webvttCssStyle.getFontFamily()), i, i2, 33);
}
if (webvttCssStyle.getTextAlign() != null) {
spannableStringBuilder.setSpan(new AlignmentSpan.Standard(webvttCssStyle.getTextAlign()), i, i2, 33);
}
int fontSizeUnit = webvttCssStyle.getFontSizeUnit();
if (fontSizeUnit == 1) {
spannableStringBuilder.setSpan(new AbsoluteSizeSpan((int) webvttCssStyle.getFontSize(), true), i, i2, 33);
} else if (fontSizeUnit == 2) {
spannableStringBuilder.setSpan(new RelativeSizeSpan(webvttCssStyle.getFontSize()), i, i2, 33);
} else {
if (fontSizeUnit != 3) {
return;
}
spannableStringBuilder.setSpan(new RelativeSizeSpan(webvttCssStyle.getFontSize() / 100.0f), i, i2, 33);
}
}
private static String getTagName(String str) {
String trim = str.trim();
if (trim.isEmpty()) {
return null;
}
return Util.splitAtFirst(trim, "[ \\.]")[0];
}
private static void getApplicableStyles(List<WebvttCssStyle> list, String str, StartTag startTag, List<StyleMatch> list2) {
int size = list.size();
for (int i = 0; i < size; i++) {
WebvttCssStyle webvttCssStyle = list.get(i);
int specificityScore = webvttCssStyle.getSpecificityScore(str, startTag.name, startTag.classes, startTag.voice);
if (specificityScore > 0) {
list2.add(new StyleMatch(specificityScore, webvttCssStyle));
}
}
Collections.sort(list2);
}
public static final class StyleMatch implements Comparable<StyleMatch> {
public final int score;
public final WebvttCssStyle style;
public StyleMatch(int i, WebvttCssStyle webvttCssStyle) {
this.score = i;
this.style = webvttCssStyle;
}
@Override // java.lang.Comparable
public final int compareTo(@NonNull StyleMatch styleMatch) {
return this.score - styleMatch.score;
}
}
public static final class StartTag {
private static final String[] NO_CLASSES = new String[0];
public final String[] classes;
public final String name;
public final int position;
public final String voice;
private StartTag(String str, int i, String str2, String[] strArr) {
this.position = i;
this.name = str;
this.voice = str2;
this.classes = strArr;
}
public static StartTag buildStartTag(String str, int i) {
String str2;
String trim = str.trim();
if (trim.isEmpty()) {
return null;
}
int indexOf = trim.indexOf(" ");
if (indexOf == -1) {
str2 = "";
} else {
String trim2 = trim.substring(indexOf).trim();
trim = trim.substring(0, indexOf);
str2 = trim2;
}
String[] split = Util.split(trim, "\\.");
return new StartTag(split[0], i, str2, split.length > 1 ? (String[]) Arrays.copyOfRange(split, 1, split.length) : NO_CLASSES);
}
public static StartTag buildWholeCueVirtualTag() {
return new StartTag("", 0, "", new String[0]);
}
}
}

89
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttDecoder.java Normal file
View File

@@ -0,0 +1,89 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import android.text.TextUtils;
import com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder;
import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderException;
import com.mbridge.msdk.playercommon.exoplayer2.text.webvtt.WebvttCue;
import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
import java.util.ArrayList;
import java.util.List;
/* loaded from: classes4.dex */
public final class WebvttDecoder extends SimpleSubtitleDecoder {
private static final String COMMENT_START = "NOTE";
private static final int EVENT_COMMENT = 1;
private static final int EVENT_CUE = 3;
private static final int EVENT_END_OF_FILE = 0;
private static final int EVENT_NONE = -1;
private static final int EVENT_STYLE_BLOCK = 2;
private static final String STYLE_START = "STYLE";
private final CssParser cssParser;
private final WebvttCueParser cueParser;
private final List<WebvttCssStyle> definedStyles;
private final ParsableByteArray parsableWebvttData;
private final WebvttCue.Builder webvttCueBuilder;
public WebvttDecoder() {
super("WebvttDecoder");
this.cueParser = new WebvttCueParser();
this.parsableWebvttData = new ParsableByteArray();
this.webvttCueBuilder = new WebvttCue.Builder();
this.cssParser = new CssParser();
this.definedStyles = new ArrayList();
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder
public final WebvttSubtitle decode(byte[] bArr, int i, boolean z) throws SubtitleDecoderException {
this.parsableWebvttData.reset(bArr, i);
this.webvttCueBuilder.reset();
this.definedStyles.clear();
WebvttParserUtil.validateWebvttHeaderLine(this.parsableWebvttData);
while (!TextUtils.isEmpty(this.parsableWebvttData.readLine())) {
}
ArrayList arrayList = new ArrayList();
while (true) {
int nextEvent = getNextEvent(this.parsableWebvttData);
if (nextEvent == 0) {
return new WebvttSubtitle(arrayList);
}
if (nextEvent == 1) {
skipComment(this.parsableWebvttData);
} else if (nextEvent == 2) {
if (!arrayList.isEmpty()) {
throw new SubtitleDecoderException("A style block was found after the first cue.");
}
this.parsableWebvttData.readLine();
WebvttCssStyle parseBlock = this.cssParser.parseBlock(this.parsableWebvttData);
if (parseBlock != null) {
this.definedStyles.add(parseBlock);
}
} else if (nextEvent == 3 && this.cueParser.parseCue(this.parsableWebvttData, this.webvttCueBuilder, this.definedStyles)) {
arrayList.add(this.webvttCueBuilder.build());
this.webvttCueBuilder.reset();
}
}
}
private static int getNextEvent(ParsableByteArray parsableByteArray) {
int i = -1;
int i2 = 0;
while (i == -1) {
i2 = parsableByteArray.getPosition();
String readLine = parsableByteArray.readLine();
if (readLine == null) {
i = 0;
} else if (STYLE_START.equals(readLine)) {
i = 2;
} else {
i = COMMENT_START.startsWith(readLine) ? 1 : 3;
}
}
parsableByteArray.setPosition(i2);
return i;
}
private static void skipComment(ParsableByteArray parsableByteArray) {
while (!TextUtils.isEmpty(parsableByteArray.readLine())) {
}
}
}

66
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttParserUtil.java Normal file
View File

@@ -0,0 +1,66 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import com.facebook.internal.security.CertificateUtil;
import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderException;
import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/* loaded from: classes4.dex */
public final class WebvttParserUtil {
private static final Pattern COMMENT = Pattern.compile("^NOTE(( |\t).*)?$");
private static final Pattern HEADER = Pattern.compile("^\ufeff?WEBVTT(( |\t).*)?$");
private WebvttParserUtil() {
}
public static void validateWebvttHeaderLine(ParsableByteArray parsableByteArray) throws SubtitleDecoderException {
String readLine = parsableByteArray.readLine();
if (readLine == null || !HEADER.matcher(readLine).matches()) {
throw new SubtitleDecoderException("Expected WEBVTT. Got " + readLine);
}
}
public static long parseTimestampUs(String str) throws NumberFormatException {
String[] splitAtFirst = Util.splitAtFirst(str, "\\.");
long j = 0;
for (String str2 : Util.split(splitAtFirst[0], CertificateUtil.DELIMITER)) {
j = (j * 60) + Long.parseLong(str2);
}
long j2 = j * 1000;
if (splitAtFirst.length == 2) {
j2 += Long.parseLong(splitAtFirst[1]);
}
return j2 * 1000;
}
public static float parsePercentage(String str) throws NumberFormatException {
if (!str.endsWith("%")) {
throw new NumberFormatException("Percentages must end with %");
}
return Float.parseFloat(str.substring(0, str.length() - 1)) / 100.0f;
}
public static Matcher findNextCueHeader(ParsableByteArray parsableByteArray) {
String readLine;
while (true) {
String readLine2 = parsableByteArray.readLine();
if (readLine2 == null) {
return null;
}
if (COMMENT.matcher(readLine2).matches()) {
do {
readLine = parsableByteArray.readLine();
if (readLine != null) {
}
} while (!readLine.isEmpty());
} else {
Matcher matcher = WebvttCueParser.CUE_HEADER_PATTERN.matcher(readLine2);
if (matcher.matches()) {
return matcher;
}
}
}
}
}

91
decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttSubtitle.java Normal file
View File

@@ -0,0 +1,91 @@
package com.mbridge.msdk.playercommon.exoplayer2.text.webvtt;
import android.text.SpannableStringBuilder;
import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/* loaded from: classes4.dex */
final class WebvttSubtitle implements Subtitle {
private final long[] cueTimesUs;
private final List<WebvttCue> cues;
private final int numCues;
private final long[] sortedCueTimesUs;
public WebvttSubtitle(List<WebvttCue> list) {
this.cues = list;
int size = list.size();
this.numCues = size;
this.cueTimesUs = new long[size * 2];
for (int i = 0; i < this.numCues; i++) {
WebvttCue webvttCue = list.get(i);
int i2 = i * 2;
long[] jArr = this.cueTimesUs;
jArr[i2] = webvttCue.startTime;
jArr[i2 + 1] = webvttCue.endTime;
}
long[] jArr2 = this.cueTimesUs;
long[] copyOf = Arrays.copyOf(jArr2, jArr2.length);
this.sortedCueTimesUs = copyOf;
Arrays.sort(copyOf);
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
public final int getNextEventTimeIndex(long j) {
int binarySearchCeil = Util.binarySearchCeil(this.sortedCueTimesUs, j, false, false);
if (binarySearchCeil < this.sortedCueTimesUs.length) {
return binarySearchCeil;
}
return -1;
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
public final int getEventTimeCount() {
return this.sortedCueTimesUs.length;
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
public final long getEventTime(int i) {
Assertions.checkArgument(i >= 0);
Assertions.checkArgument(i < this.sortedCueTimesUs.length);
return this.sortedCueTimesUs[i];
}
@Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
public final List<Cue> getCues(long j) {
SpannableStringBuilder spannableStringBuilder = null;
ArrayList arrayList = null;
WebvttCue webvttCue = null;
for (int i = 0; i < this.numCues; i++) {
long[] jArr = this.cueTimesUs;
int i2 = i * 2;
if (jArr[i2] <= j && j < jArr[i2 + 1]) {
if (arrayList == null) {
arrayList = new ArrayList();
}
WebvttCue webvttCue2 = this.cues.get(i);
if (!webvttCue2.isNormalCue()) {
arrayList.add(webvttCue2);
} else if (webvttCue == null) {
webvttCue = webvttCue2;
} else if (spannableStringBuilder == null) {
spannableStringBuilder = new SpannableStringBuilder();
spannableStringBuilder.append(webvttCue.text).append((CharSequence) "\n").append(webvttCue2.text);
} else {
spannableStringBuilder.append((CharSequence) "\n").append(webvttCue2.text);
}
}
}
if (spannableStringBuilder != null) {
arrayList.add(new WebvttCue(spannableStringBuilder));
} else if (webvttCue != null) {
arrayList.add(webvttCue);
}
return arrayList != null ? arrayList : Collections.emptyList();
}
}