Add decompiled APK source code (JADX)

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

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/CaptionStyleCompat.java

@@ -0,0 +1,57 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import android.annotation.TargetApi;
+import android.graphics.Typeface;
+import android.view.accessibility.CaptioningManager;
+import androidx.core.view.ViewCompat;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class CaptionStyleCompat {
+    public static final CaptionStyleCompat DEFAULT = new CaptionStyleCompat(-1, ViewCompat.MEASURED_STATE_MASK, 0, 0, -1, null);
+    public static final int EDGE_TYPE_DEPRESSED = 4;
+    public static final int EDGE_TYPE_DROP_SHADOW = 2;
+    public static final int EDGE_TYPE_NONE = 0;
+    public static final int EDGE_TYPE_OUTLINE = 1;
+    public static final int EDGE_TYPE_RAISED = 3;
+    public static final int USE_TRACK_COLOR_SETTINGS = 1;
+    public final int backgroundColor;
+    public final int edgeColor;
+    public final int edgeType;
+    public final int foregroundColor;
+    public final Typeface typeface;
+    public final int windowColor;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface EdgeType {
+    }
+
+    @TargetApi(19)
+    public static CaptionStyleCompat createFromCaptionStyle(CaptioningManager.CaptionStyle captionStyle) {
+        if (Util.SDK_INT >= 21) {
+            return createFromCaptionStyleV21(captionStyle);
+        }
+        return createFromCaptionStyleV19(captionStyle);
+    }
+
+    public CaptionStyleCompat(int i, int i2, int i3, int i4, int i5, Typeface typeface) {
+        this.foregroundColor = i;
+        this.backgroundColor = i2;
+        this.windowColor = i3;
+        this.edgeType = i4;
+        this.edgeColor = i5;
+        this.typeface = typeface;
+    }
+
+    @TargetApi(19)
+    private static CaptionStyleCompat createFromCaptionStyleV19(CaptioningManager.CaptionStyle captionStyle) {
+        return new CaptionStyleCompat(captionStyle.foregroundColor, captionStyle.backgroundColor, 0, captionStyle.edgeType, captionStyle.edgeColor, captionStyle.getTypeface());
+    }
+
+    @TargetApi(21)
+    private static CaptionStyleCompat createFromCaptionStyleV21(CaptioningManager.CaptionStyle captionStyle) {
+        return new CaptionStyleCompat(captionStyle.hasForegroundColor() ? captionStyle.foregroundColor : DEFAULT.foregroundColor, captionStyle.hasBackgroundColor() ? captionStyle.backgroundColor : DEFAULT.backgroundColor, captionStyle.hasWindowColor() ? captionStyle.windowColor : DEFAULT.windowColor, captionStyle.hasEdgeType() ? captionStyle.edgeType : DEFAULT.edgeType, captionStyle.hasEdgeColor() ? captionStyle.edgeColor : DEFAULT.edgeColor, captionStyle.getTypeface());
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/Cue.java

@@ -0,0 +1,84 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import android.graphics.Bitmap;
+import android.text.Layout;
+import androidx.core.view.ViewCompat;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public class Cue {
+    public static final int ANCHOR_TYPE_END = 2;
+    public static final int ANCHOR_TYPE_MIDDLE = 1;
+    public static final int ANCHOR_TYPE_START = 0;
+    public static final float DIMEN_UNSET = Float.MIN_VALUE;
+    public static final int LINE_TYPE_FRACTION = 0;
+    public static final int LINE_TYPE_NUMBER = 1;
+    public static final int TEXT_SIZE_TYPE_ABSOLUTE = 2;
+    public static final int TEXT_SIZE_TYPE_FRACTIONAL = 0;
+    public static final int TEXT_SIZE_TYPE_FRACTIONAL_IGNORE_PADDING = 1;
+    public static final int TYPE_UNSET = Integer.MIN_VALUE;
+    public final Bitmap bitmap;
+    public final float bitmapHeight;
+    public final float line;
+    public final int lineAnchor;
+    public final int lineType;
+    public final float position;
+    public final int positionAnchor;
+    public final float size;
+    public final CharSequence text;
+    public final Layout.Alignment textAlignment;
+    public final float textSize;
+    public final int textSizeType;
+    public final int windowColor;
+    public final boolean windowColorSet;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface AnchorType {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface LineType {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface TextSizeType {
+    }
+
+    public Cue(Bitmap bitmap, float f, int i, float f2, int i2, float f3, float f4) {
+        this(null, null, bitmap, f2, 0, i2, f, i, Integer.MIN_VALUE, Float.MIN_VALUE, f3, f4, false, ViewCompat.MEASURED_STATE_MASK);
+    }
+
+    public Cue(CharSequence charSequence) {
+        this(charSequence, null, Float.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, Float.MIN_VALUE, Integer.MIN_VALUE, Float.MIN_VALUE);
+    }
+
+    public Cue(CharSequence charSequence, Layout.Alignment alignment, float f, int i, int i2, float f2, int i3, float f3) {
+        this(charSequence, alignment, f, i, i2, f2, i3, f3, false, ViewCompat.MEASURED_STATE_MASK);
+    }
+
+    public Cue(CharSequence charSequence, Layout.Alignment alignment, float f, int i, int i2, float f2, int i3, float f3, int i4, float f4) {
+        this(charSequence, alignment, null, f, i, i2, f2, i3, i4, f4, f3, Float.MIN_VALUE, false, ViewCompat.MEASURED_STATE_MASK);
+    }
+
+    public Cue(CharSequence charSequence, Layout.Alignment alignment, float f, int i, int i2, float f2, int i3, float f3, boolean z, int i4) {
+        this(charSequence, alignment, null, f, i, i2, f2, i3, Integer.MIN_VALUE, Float.MIN_VALUE, f3, Float.MIN_VALUE, z, i4);
+    }
+
+    private Cue(CharSequence charSequence, Layout.Alignment alignment, Bitmap bitmap, float f, int i, int i2, float f2, int i3, int i4, float f3, float f4, float f5, boolean z, int i5) {
+        this.text = charSequence;
+        this.textAlignment = alignment;
+        this.bitmap = bitmap;
+        this.line = f;
+        this.lineType = i;
+        this.lineAnchor = i2;
+        this.position = f2;
+        this.positionAnchor = i3;
+        this.size = f4;
+        this.bitmapHeight = f5;
+        this.windowColorSet = z;
+        this.windowColor = i5;
+        this.textSizeType = i4;
+        this.textSize = f3;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/SimpleSubtitleDecoder.java

@@ -0,0 +1,59 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes4.dex */
+public abstract class SimpleSubtitleDecoder extends SimpleDecoder<SubtitleInputBuffer, SubtitleOutputBuffer, SubtitleDecoderException> implements SubtitleDecoder {
+    private final String name;
+
+    public abstract Subtitle decode(byte[] bArr, int i, boolean z) throws SubtitleDecoderException;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final String getName() {
+        return this.name;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoder
+    public void setPositionUs(long j) {
+    }
+
+    public SimpleSubtitleDecoder(String str) {
+        super(new SubtitleInputBuffer[2], new SubtitleOutputBuffer[2]);
+        this.name = str;
+        setInitialInputBufferSize(1024);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder
+    public final SubtitleInputBuffer createInputBuffer() {
+        return new SubtitleInputBuffer();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder
+    public final SubtitleOutputBuffer createOutputBuffer() {
+        return new SimpleSubtitleOutputBuffer(this);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder
+    public final SubtitleDecoderException createUnexpectedDecodeException(Throwable th) {
+        return new SubtitleDecoderException("Unexpected decode error", th);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder
+    public final void releaseOutputBuffer(SubtitleOutputBuffer subtitleOutputBuffer) {
+        super.releaseOutputBuffer((SimpleSubtitleDecoder) subtitleOutputBuffer);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder
+    public final SubtitleDecoderException decode(SubtitleInputBuffer subtitleInputBuffer, SubtitleOutputBuffer subtitleOutputBuffer, boolean z) {
+        try {
+            ByteBuffer byteBuffer = subtitleInputBuffer.data;
+            subtitleOutputBuffer.setContent(subtitleInputBuffer.timeUs, decode(byteBuffer.array(), byteBuffer.limit(), z), subtitleInputBuffer.subsampleOffsetUs);
+            subtitleOutputBuffer.clearFlag(Integer.MIN_VALUE);
+            return null;
+        } catch (SubtitleDecoderException e) {
+            return e;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/SimpleSubtitleOutputBuffer.java

@@ -0,0 +1,15 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+/* loaded from: classes4.dex */
+final class SimpleSubtitleOutputBuffer extends SubtitleOutputBuffer {
+    private final SimpleSubtitleDecoder owner;
+
+    public SimpleSubtitleOutputBuffer(SimpleSubtitleDecoder simpleSubtitleDecoder) {
+        this.owner = simpleSubtitleDecoder;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleOutputBuffer, com.mbridge.msdk.playercommon.exoplayer2.decoder.OutputBuffer
+    public final void release() {
+        this.owner.releaseOutputBuffer((SubtitleOutputBuffer) this);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/Subtitle.java

@@ -0,0 +1,14 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public interface Subtitle {
+    List<Cue> getCues(long j);
+
+    long getEventTime(int i);
+
+    int getEventTimeCount();
+
+    int getNextEventTimeIndex(long j);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/SubtitleDecoder.java

@@ -0,0 +1,8 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder;
+
+/* loaded from: classes4.dex */
+public interface SubtitleDecoder extends Decoder<SubtitleInputBuffer, SubtitleOutputBuffer, SubtitleDecoderException> {
+    void setPositionUs(long j);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/SubtitleDecoderException.java

@@ -0,0 +1,12 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+/* loaded from: classes4.dex */
+public class SubtitleDecoderException extends Exception {
+    public SubtitleDecoderException(String str) {
+        super(str);
+    }
+
+    public SubtitleDecoderException(String str, Throwable th) {
+        super(str, th);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/SubtitleDecoderFactory.java

@@ -0,0 +1,60 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.text.cea.Cea608Decoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.cea.Cea708Decoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.dvb.DvbDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.pgs.PgsDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.ssa.SsaDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.subrip.SubripDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.tx3g.Tx3gDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.webvtt.Mp4WebvttDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.webvtt.WebvttDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+
+/* loaded from: classes4.dex */
+public interface SubtitleDecoderFactory {
+    public static final SubtitleDecoderFactory DEFAULT = new SubtitleDecoderFactory() { // from class: com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderFactory.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderFactory
+        public boolean supportsFormat(Format format) {
+            String str = format.sampleMimeType;
+            return MimeTypes.TEXT_VTT.equals(str) || MimeTypes.TEXT_SSA.equals(str) || MimeTypes.APPLICATION_TTML.equals(str) || MimeTypes.APPLICATION_MP4VTT.equals(str) || MimeTypes.APPLICATION_SUBRIP.equals(str) || MimeTypes.APPLICATION_TX3G.equals(str) || MimeTypes.APPLICATION_CEA608.equals(str) || MimeTypes.APPLICATION_MP4CEA608.equals(str) || MimeTypes.APPLICATION_CEA708.equals(str) || MimeTypes.APPLICATION_DVBSUBS.equals(str) || MimeTypes.APPLICATION_PGS.equals(str);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderFactory
+        public SubtitleDecoder createDecoder(Format format) {
+            String str = format.sampleMimeType;
+            str.hashCode();
+            switch (str) {
+                case "application/dvbsubs":
+                    return new DvbDecoder(format.initializationData);
+                case "application/pgs":
+                    return new PgsDecoder();
+                case "application/x-mp4-vtt":
+                    return new Mp4WebvttDecoder();
+                case "text/vtt":
+                    return new WebvttDecoder();
+                case "application/x-quicktime-tx3g":
+                    return new Tx3gDecoder(format.initializationData);
+                case "text/x-ssa":
+                    return new SsaDecoder(format.initializationData);
+                case "application/x-mp4-cea-608":
+                case "application/cea-608":
+                    return new Cea608Decoder(format.sampleMimeType, format.accessibilityChannel);
+                case "application/cea-708":
+                    return new Cea708Decoder(format.accessibilityChannel);
+                case "application/x-subrip":
+                    return new SubripDecoder();
+                case "application/ttml+xml":
+                    return new TtmlDecoder();
+                default:
+                    throw new IllegalArgumentException("Attempted to create decoder for unsupported format");
+            }
+        }
+    };
+
+    SubtitleDecoder createDecoder(Format format);
+
+    boolean supportsFormat(Format format);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/SubtitleInputBuffer.java

@@ -0,0 +1,12 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+
+/* loaded from: classes4.dex */
+public class SubtitleInputBuffer extends DecoderInputBuffer {
+    public long subsampleOffsetUs;
+
+    public SubtitleInputBuffer() {
+        super(1);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/SubtitleOutputBuffer.java

@@ -0,0 +1,48 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.OutputBuffer;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public abstract class SubtitleOutputBuffer extends OutputBuffer implements Subtitle {
+    private long subsampleOffsetUs;
+    private Subtitle subtitle;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.OutputBuffer
+    public abstract void release();
+
+    public void setContent(long j, Subtitle subtitle, long j2) {
+        this.timeUs = j;
+        this.subtitle = subtitle;
+        if (j2 != Long.MAX_VALUE) {
+            j = j2;
+        }
+        this.subsampleOffsetUs = j;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public int getEventTimeCount() {
+        return this.subtitle.getEventTimeCount();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public long getEventTime(int i) {
+        return this.subtitle.getEventTime(i) + this.subsampleOffsetUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public int getNextEventTimeIndex(long j) {
+        return this.subtitle.getNextEventTimeIndex(j - this.subsampleOffsetUs);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public List<Cue> getCues(long j) {
+        return this.subtitle.getCues(j - this.subsampleOffsetUs);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Buffer
+    public void clear() {
+        super.clear();
+        this.subtitle = null;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/TextOutput.java

@@ -0,0 +1,8 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public interface TextOutput {
+    void onCues(List<Cue> list);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/TextRenderer.java

@@ -0,0 +1,180 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.FormatHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class TextRenderer extends BaseRenderer implements Handler.Callback {
+    private static final int MSG_UPDATE_OUTPUT = 0;
+    private static final int REPLACEMENT_STATE_NONE = 0;
+    private static final int REPLACEMENT_STATE_SIGNAL_END_OF_STREAM = 1;
+    private static final int REPLACEMENT_STATE_WAIT_END_OF_STREAM = 2;
+    private SubtitleDecoder decoder;
+    private final SubtitleDecoderFactory decoderFactory;
+    private int decoderReplacementState;
+    private final FormatHolder formatHolder;
+    private boolean inputStreamEnded;
+    private SubtitleInputBuffer nextInputBuffer;
+    private SubtitleOutputBuffer nextSubtitle;
+    private int nextSubtitleEventIndex;
+    private final TextOutput output;
+    private final Handler outputHandler;
+    private boolean outputStreamEnded;
+    private Format streamFormat;
+    private SubtitleOutputBuffer subtitle;
+
+    @Deprecated
+    public interface Output extends TextOutput {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ReplacementState {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final boolean isEnded() {
+        return this.outputStreamEnded;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final boolean isReady() {
+        return true;
+    }
+
+    public TextRenderer(TextOutput textOutput, Looper looper) {
+        this(textOutput, looper, SubtitleDecoderFactory.DEFAULT);
+    }
+
+    public TextRenderer(TextOutput textOutput, Looper looper, SubtitleDecoderFactory subtitleDecoderFactory) {
+        super(3);
+        this.output = (TextOutput) Assertions.checkNotNull(textOutput);
+        this.outputHandler = looper == null ? null : new Handler(looper, this);
+        this.decoderFactory = subtitleDecoderFactory;
+        this.formatHolder = new FormatHolder();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities
+    public final int supportsFormat(Format format) {
+        return this.decoderFactory.supportsFormat(format) ? BaseRenderer.supportsFormatDrm(null, format.drmInitData) ? 4 : 2 : MimeTypes.isText(format.sampleMimeType) ? 1 : 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public final void onStreamChanged(Format[] formatArr, long j) throws ExoPlaybackException {
+        Format format = formatArr[0];
+        this.streamFormat = format;
+        if (this.decoder != null) {
+            this.decoderReplacementState = 1;
+        } else {
+            this.decoder = this.decoderFactory.createDecoder(format);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public final void onPositionReset(long j, boolean z) {
+        clearOutput();
+        this.inputStreamEnded = false;
+        this.outputStreamEnded = false;
+        if (this.decoderReplacementState != 0) {
+            replaceDecoder();
+        } else {
+            releaseBuffers();
+            this.decoder.flush();
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:82:0x008a, code lost:
+    
+        if (r11 != false) goto L41;
+     */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void render(long r9, long r11) throws com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException {
+        /*
+            Method dump skipped, instructions count: 257
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.text.TextRenderer.render(long, long):void");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public final void onDisabled() {
+        this.streamFormat = null;
+        clearOutput();
+        releaseDecoder();
+    }
+
+    private void releaseBuffers() {
+        this.nextInputBuffer = null;
+        this.nextSubtitleEventIndex = -1;
+        SubtitleOutputBuffer subtitleOutputBuffer = this.subtitle;
+        if (subtitleOutputBuffer != null) {
+            subtitleOutputBuffer.release();
+            this.subtitle = null;
+        }
+        SubtitleOutputBuffer subtitleOutputBuffer2 = this.nextSubtitle;
+        if (subtitleOutputBuffer2 != null) {
+            subtitleOutputBuffer2.release();
+            this.nextSubtitle = null;
+        }
+    }
+
+    private void releaseDecoder() {
+        releaseBuffers();
+        this.decoder.release();
+        this.decoder = null;
+        this.decoderReplacementState = 0;
+    }
+
+    private void replaceDecoder() {
+        releaseDecoder();
+        this.decoder = this.decoderFactory.createDecoder(this.streamFormat);
+    }
+
+    private long getNextEventTime() {
+        int i = this.nextSubtitleEventIndex;
+        if (i == -1 || i >= this.subtitle.getEventTimeCount()) {
+            return Long.MAX_VALUE;
+        }
+        return this.subtitle.getEventTime(this.nextSubtitleEventIndex);
+    }
+
+    private void updateOutput(List<Cue> list) {
+        Handler handler = this.outputHandler;
+        if (handler != null) {
+            handler.obtainMessage(0, list).sendToTarget();
+        } else {
+            invokeUpdateOutputInternal(list);
+        }
+    }
+
+    private void clearOutput() {
+        updateOutput(Collections.emptyList());
+    }
+
+    @Override // android.os.Handler.Callback
+    public final boolean handleMessage(Message message) {
+        if (message.what == 0) {
+            invokeUpdateOutputInternal((List) message.obj);
+            return true;
+        }
+        throw new IllegalStateException();
+    }
+
+    private void invokeUpdateOutputInternal(List<Cue> list) {
+        this.output.onCues(list);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/cea/Cea608Decoder.java

@@ -0,0 +1,569 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.cea;
+
+import android.text.Layout;
+import android.text.SpannableString;
+import android.text.SpannableStringBuilder;
+import android.text.style.ForegroundColorSpan;
+import android.text.style.StyleSpan;
+import android.text.style.UnderlineSpan;
+import androidx.core.internal.view.SupportMenu;
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderException;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleOutputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.vungle.ads.internal.protos.Sdk;
+import com.vungle.ads.internal.signals.SignalKey;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class Cea608Decoder extends CeaDecoder {
+    private static final int CC_FIELD_FLAG = 1;
+    private static final byte CC_IMPLICIT_DATA_HEADER = -4;
+    private static final int CC_MODE_PAINT_ON = 3;
+    private static final int CC_MODE_POP_ON = 2;
+    private static final int CC_MODE_ROLL_UP = 1;
+    private static final int CC_MODE_UNKNOWN = 0;
+    private static final int CC_TYPE_FLAG = 2;
+    private static final int CC_VALID_608_ID = 4;
+    private static final int CC_VALID_FLAG = 4;
+    private static final byte CTRL_BACKSPACE = 33;
+    private static final byte CTRL_CARRIAGE_RETURN = 45;
+    private static final byte CTRL_DELETE_TO_END_OF_ROW = 36;
+    private static final byte CTRL_END_OF_CAPTION = 47;
+    private static final byte CTRL_ERASE_DISPLAYED_MEMORY = 44;
+    private static final byte CTRL_ERASE_NON_DISPLAYED_MEMORY = 46;
+    private static final byte CTRL_RESUME_CAPTION_LOADING = 32;
+    private static final byte CTRL_RESUME_DIRECT_CAPTIONING = 41;
+    private static final byte CTRL_ROLL_UP_CAPTIONS_2_ROWS = 37;
+    private static final byte CTRL_ROLL_UP_CAPTIONS_3_ROWS = 38;
+    private static final byte CTRL_ROLL_UP_CAPTIONS_4_ROWS = 39;
+    private static final int DEFAULT_CAPTIONS_ROW_COUNT = 4;
+    private static final int NTSC_CC_FIELD_1 = 0;
+    private static final int NTSC_CC_FIELD_2 = 1;
+    private static final int STYLE_ITALICS = 7;
+    private static final int STYLE_UNCHANGED = 8;
+    private int captionMode;
+    private int captionRowCount;
+    private List<Cue> cues;
+    private List<Cue> lastCues;
+    private final int packetLength;
+    private byte repeatableControlCc1;
+    private byte repeatableControlCc2;
+    private boolean repeatableControlSet;
+    private final int selectedField;
+    private static final int[] ROW_INDICES = {11, 1, 3, 12, 14, 5, 7, 9};
+    private static final int[] COLUMN_INDICES = {0, 4, 8, 12, 16, 20, 24, 28};
+    private static final int[] STYLE_COLORS = {-1, -16711936, -16776961, -16711681, SupportMenu.CATEGORY_MASK, -256, -65281};
+    private static final int[] BASIC_CHARACTER_SET = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 225, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 233, 93, 237, 243, 250, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, SignalKey.EVENT_ID, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 231, 247, 209, 241, 9632};
+    private static final int[] SPECIAL_CHARACTER_SET = {174, 176, PsExtractor.PRIVATE_STREAM_1, 191, 8482, 162, 163, 9834, 224, 32, 232, 226, 234, 238, 244, 251};
+    private static final int[] SPECIAL_ES_FR_CHARACTER_SET = {193, 201, 211, 218, 220, 252, 8216, 161, 42, 39, 8212, 169, 8480, 8226, 8220, 8221, PsExtractor.AUDIO_STREAM, 194, 199, 200, 202, 203, 235, 206, 207, 239, 212, 217, 249, 219, 171, 187};
+    private static final int[] SPECIAL_PT_DE_CHARACTER_SET = {195, 227, 205, 204, 236, 210, 242, 213, 245, 123, 125, 92, 94, 95, 124, 126, 196, 228, 214, 246, Sdk.SDKError.Reason.STALE_CACHED_RESPONSE_VALUE, 165, 164, 9474, 197, 229, 216, 248, 9484, 9488, 9492, 9496};
+    private final ParsableByteArray ccData = new ParsableByteArray();
+    private final ArrayList<CueBuilder> cueBuilders = new ArrayList<>();
+    private CueBuilder currentCueBuilder = new CueBuilder(0, 4);
+
+    private static boolean isMidrowCtrlCode(byte b, byte b2) {
+        return (b & 247) == 17 && (b2 & 240) == 32;
+    }
+
+    private static boolean isMiscCode(byte b, byte b2) {
+        return (b & 247) == 20 && (b2 & 240) == 32;
+    }
+
+    private static boolean isPreambleAddressCode(byte b, byte b2) {
+        return (b & 240) == 16 && (b2 & 192) == 64;
+    }
+
+    private static boolean isRepeatable(byte b) {
+        return (b & 240) == 16;
+    }
+
+    private static boolean isTabCtrlCode(byte b, byte b2) {
+        return (b & 247) == 23 && b2 >= 33 && b2 <= 35;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder, com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final String getName() {
+        return "Cea608Decoder";
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder
+    public final boolean isNewSubtitleDataAvailable() {
+        return this.cues != this.lastCues;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder, com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final void release() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder, com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final /* bridge */ /* synthetic */ SubtitleInputBuffer dequeueInputBuffer() throws SubtitleDecoderException {
+        return super.dequeueInputBuffer();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder, com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final /* bridge */ /* synthetic */ SubtitleOutputBuffer dequeueOutputBuffer() throws SubtitleDecoderException {
+        return super.dequeueOutputBuffer();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder
+    public final /* bridge */ /* synthetic */ void queueInputBuffer(SubtitleInputBuffer subtitleInputBuffer) throws SubtitleDecoderException {
+        super.queueInputBuffer(subtitleInputBuffer);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder, com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoder
+    public final /* bridge */ /* synthetic */ void setPositionUs(long j) {
+        super.setPositionUs(j);
+    }
+
+    public Cea608Decoder(String str, int i) {
+        this.packetLength = MimeTypes.APPLICATION_MP4CEA608.equals(str) ? 2 : 3;
+        if (i == 3 || i == 4) {
+            this.selectedField = 2;
+        } else {
+            this.selectedField = 1;
+        }
+        setCaptionMode(0);
+        resetCueBuilders();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder, com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final void flush() {
+        super.flush();
+        this.cues = null;
+        this.lastCues = null;
+        setCaptionMode(0);
+        setCaptionRowCount(4);
+        resetCueBuilders();
+        this.repeatableControlSet = false;
+        this.repeatableControlCc1 = (byte) 0;
+        this.repeatableControlCc2 = (byte) 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder
+    public final Subtitle createSubtitle() {
+        List<Cue> list = this.cues;
+        this.lastCues = list;
+        return new CeaSubtitle(list);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.cea.CeaDecoder
+    public final void decode(SubtitleInputBuffer subtitleInputBuffer) {
+        int i;
+        this.ccData.reset(subtitleInputBuffer.data.array(), subtitleInputBuffer.data.limit());
+        boolean z = false;
+        boolean z2 = false;
+        while (true) {
+            int bytesLeft = this.ccData.bytesLeft();
+            int i2 = this.packetLength;
+            if (bytesLeft < i2) {
+                break;
+            }
+            byte readUnsignedByte = i2 == 2 ? CC_IMPLICIT_DATA_HEADER : (byte) this.ccData.readUnsignedByte();
+            byte readUnsignedByte2 = (byte) (this.ccData.readUnsignedByte() & 127);
+            byte readUnsignedByte3 = (byte) (this.ccData.readUnsignedByte() & 127);
+            if ((readUnsignedByte & 6) == 4 && ((i = this.selectedField) != 1 || (readUnsignedByte & 1) == 0)) {
+                if (i != 2 || (readUnsignedByte & 1) == 1) {
+                    if (readUnsignedByte2 != 0 || readUnsignedByte3 != 0) {
+                        if ((readUnsignedByte2 & 247) == 17 && (readUnsignedByte3 & 240) == 48) {
+                            this.currentCueBuilder.append(getSpecialChar(readUnsignedByte3));
+                        } else if ((readUnsignedByte2 & 246) == 18 && (readUnsignedByte3 & 224) == 32) {
+                            this.currentCueBuilder.backspace();
+                            if ((readUnsignedByte2 & 1) == 0) {
+                                this.currentCueBuilder.append(getExtendedEsFrChar(readUnsignedByte3));
+                            } else {
+                                this.currentCueBuilder.append(getExtendedPtDeChar(readUnsignedByte3));
+                            }
+                        } else if ((readUnsignedByte2 & 224) == 0) {
+                            z2 = handleCtrl(readUnsignedByte2, readUnsignedByte3);
+                        } else {
+                            this.currentCueBuilder.append(getChar(readUnsignedByte2));
+                            if ((readUnsignedByte3 & 224) != 0) {
+                                this.currentCueBuilder.append(getChar(readUnsignedByte3));
+                            }
+                        }
+                        z = true;
+                    }
+                }
+            }
+        }
+        if (z) {
+            if (!z2) {
+                this.repeatableControlSet = false;
+            }
+            int i3 = this.captionMode;
+            if (i3 == 1 || i3 == 3) {
+                this.cues = getDisplayCues();
+            }
+        }
+    }
+
+    private boolean handleCtrl(byte b, byte b2) {
+        boolean isRepeatable = isRepeatable(b);
+        if (isRepeatable) {
+            if (this.repeatableControlSet && this.repeatableControlCc1 == b && this.repeatableControlCc2 == b2) {
+                this.repeatableControlSet = false;
+                return true;
+            }
+            this.repeatableControlSet = true;
+            this.repeatableControlCc1 = b;
+            this.repeatableControlCc2 = b2;
+        }
+        if (isMidrowCtrlCode(b, b2)) {
+            handleMidrowCtrl(b2);
+        } else if (isPreambleAddressCode(b, b2)) {
+            handlePreambleAddressCode(b, b2);
+        } else if (isTabCtrlCode(b, b2)) {
+            this.currentCueBuilder.setTab(b2 - 32);
+        } else if (isMiscCode(b, b2)) {
+            handleMiscCode(b2);
+        }
+        return isRepeatable;
+    }
+
+    private void handleMidrowCtrl(byte b) {
+        this.currentCueBuilder.append(' ');
+        this.currentCueBuilder.setStyle((b >> 1) & 7, (b & 1) == 1);
+    }
+
+    private void handlePreambleAddressCode(byte b, byte b2) {
+        int i = ROW_INDICES[b & 7];
+        if ((b2 & 32) != 0) {
+            i++;
+        }
+        if (i != this.currentCueBuilder.getRow()) {
+            if (this.captionMode != 1 && !this.currentCueBuilder.isEmpty()) {
+                CueBuilder cueBuilder = new CueBuilder(this.captionMode, this.captionRowCount);
+                this.currentCueBuilder = cueBuilder;
+                this.cueBuilders.add(cueBuilder);
+            }
+            this.currentCueBuilder.setRow(i);
+        }
+        boolean z = (b2 & Ascii.DLE) == 16;
+        boolean z2 = (b2 & 1) == 1;
+        int i2 = (b2 >> 1) & 7;
+        this.currentCueBuilder.setStyle(z ? 8 : i2, z2);
+        if (z) {
+            this.currentCueBuilder.setIndent(COLUMN_INDICES[i2]);
+        }
+    }
+
+    private void handleMiscCode(byte b) {
+        if (b == 32) {
+            setCaptionMode(2);
+            return;
+        }
+        if (b != 41) {
+            switch (b) {
+                case 37:
+                    setCaptionMode(1);
+                    setCaptionRowCount(2);
+                    break;
+                case 38:
+                    setCaptionMode(1);
+                    setCaptionRowCount(3);
+                    break;
+                case 39:
+                    setCaptionMode(1);
+                    setCaptionRowCount(4);
+                    break;
+                default:
+                    int i = this.captionMode;
+                    if (i != 0) {
+                        if (b != 33) {
+                            switch (b) {
+                                case 44:
+                                    this.cues = null;
+                                    if (i == 1 || i == 3) {
+                                        resetCueBuilders();
+                                        break;
+                                    }
+                                case 45:
+                                    if (i == 1 && !this.currentCueBuilder.isEmpty()) {
+                                        this.currentCueBuilder.rollUp();
+                                        break;
+                                    }
+                                    break;
+                                case 46:
+                                    resetCueBuilders();
+                                    break;
+                                case 47:
+                                    this.cues = getDisplayCues();
+                                    resetCueBuilders();
+                                    break;
+                            }
+                        } else {
+                            this.currentCueBuilder.backspace();
+                            break;
+                        }
+                    }
+                    break;
+            }
+            return;
+        }
+        setCaptionMode(3);
+    }
+
+    private List<Cue> getDisplayCues() {
+        ArrayList arrayList = new ArrayList();
+        for (int i = 0; i < this.cueBuilders.size(); i++) {
+            Cue build = this.cueBuilders.get(i).build();
+            if (build != null) {
+                arrayList.add(build);
+            }
+        }
+        return arrayList;
+    }
+
+    private void setCaptionMode(int i) {
+        int i2 = this.captionMode;
+        if (i2 == i) {
+            return;
+        }
+        this.captionMode = i;
+        resetCueBuilders();
+        if (i2 == 3 || i == 1 || i == 0) {
+            this.cues = null;
+        }
+    }
+
+    private void setCaptionRowCount(int i) {
+        this.captionRowCount = i;
+        this.currentCueBuilder.setCaptionRowCount(i);
+    }
+
+    private void resetCueBuilders() {
+        this.currentCueBuilder.reset(this.captionMode);
+        this.cueBuilders.clear();
+        this.cueBuilders.add(this.currentCueBuilder);
+    }
+
+    private static char getChar(byte b) {
+        return (char) BASIC_CHARACTER_SET[(b & Byte.MAX_VALUE) - 32];
+    }
+
+    private static char getSpecialChar(byte b) {
+        return (char) SPECIAL_CHARACTER_SET[b & Ascii.SI];
+    }
+
+    private static char getExtendedEsFrChar(byte b) {
+        return (char) SPECIAL_ES_FR_CHARACTER_SET[b & Ascii.US];
+    }
+
+    private static char getExtendedPtDeChar(byte b) {
+        return (char) SPECIAL_PT_DE_CHARACTER_SET[b & Ascii.US];
+    }
+
+    public static class CueBuilder {
+        private static final int BASE_ROW = 15;
+        private static final int SCREEN_CHARWIDTH = 32;
+        private int captionMode;
+        private int captionRowCount;
+        private int indent;
+        private int row;
+        private int tabOffset;
+        private final List<CueStyle> cueStyles = new ArrayList();
+        private final List<SpannableString> rolledUpCaptions = new ArrayList();
+        private final StringBuilder captionStringBuilder = new StringBuilder();
+
+        public int getRow() {
+            return this.row;
+        }
+
+        public void setCaptionRowCount(int i) {
+            this.captionRowCount = i;
+        }
+
+        public void setIndent(int i) {
+            this.indent = i;
+        }
+
+        public void setRow(int i) {
+            this.row = i;
+        }
+
+        public void setTab(int i) {
+            this.tabOffset = i;
+        }
+
+        public CueBuilder(int i, int i2) {
+            reset(i);
+            setCaptionRowCount(i2);
+        }
+
+        public void reset(int i) {
+            this.captionMode = i;
+            this.cueStyles.clear();
+            this.rolledUpCaptions.clear();
+            this.captionStringBuilder.setLength(0);
+            this.row = 15;
+            this.indent = 0;
+            this.tabOffset = 0;
+        }
+
+        public boolean isEmpty() {
+            return this.cueStyles.isEmpty() && this.rolledUpCaptions.isEmpty() && this.captionStringBuilder.length() == 0;
+        }
+
+        public void backspace() {
+            int length = this.captionStringBuilder.length();
+            if (length > 0) {
+                this.captionStringBuilder.delete(length - 1, length);
+                for (int size = this.cueStyles.size() - 1; size >= 0; size--) {
+                    CueStyle cueStyle = this.cueStyles.get(size);
+                    int i = cueStyle.start;
+                    if (i != length) {
+                        return;
+                    }
+                    cueStyle.start = i - 1;
+                }
+            }
+        }
+
+        public void rollUp() {
+            this.rolledUpCaptions.add(buildSpannableString());
+            this.captionStringBuilder.setLength(0);
+            this.cueStyles.clear();
+            int min = Math.min(this.captionRowCount, this.row);
+            while (this.rolledUpCaptions.size() >= min) {
+                this.rolledUpCaptions.remove(0);
+            }
+        }
+
+        public void setStyle(int i, boolean z) {
+            this.cueStyles.add(new CueStyle(i, z, this.captionStringBuilder.length()));
+        }
+
+        public void append(char c) {
+            this.captionStringBuilder.append(c);
+        }
+
+        public SpannableString buildSpannableString() {
+            SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(this.captionStringBuilder);
+            int length = spannableStringBuilder.length();
+            int i = -1;
+            int i2 = -1;
+            int i3 = -1;
+            int i4 = -1;
+            int i5 = 0;
+            int i6 = 0;
+            boolean z = false;
+            while (i5 < this.cueStyles.size()) {
+                CueStyle cueStyle = this.cueStyles.get(i5);
+                boolean z2 = cueStyle.underline;
+                int i7 = cueStyle.style;
+                if (i7 != 8) {
+                    boolean z3 = i7 == 7;
+                    if (i7 != 7) {
+                        i4 = Cea608Decoder.STYLE_COLORS[i7];
+                    }
+                    z = z3;
+                }
+                int i8 = cueStyle.start;
+                i5++;
+                if (i8 != (i5 < this.cueStyles.size() ? this.cueStyles.get(i5).start : length)) {
+                    if (i != -1 && !z2) {
+                        setUnderlineSpan(spannableStringBuilder, i, i8);
+                        i = -1;
+                    } else if (i == -1 && z2) {
+                        i = i8;
+                    }
+                    if (i2 != -1 && !z) {
+                        setItalicSpan(spannableStringBuilder, i2, i8);
+                        i2 = -1;
+                    } else if (i2 == -1 && z) {
+                        i2 = i8;
+                    }
+                    if (i4 != i3) {
+                        setColorSpan(spannableStringBuilder, i6, i8, i3);
+                        i3 = i4;
+                        i6 = i8;
+                    }
+                }
+            }
+            if (i != -1 && i != length) {
+                setUnderlineSpan(spannableStringBuilder, i, length);
+            }
+            if (i2 != -1 && i2 != length) {
+                setItalicSpan(spannableStringBuilder, i2, length);
+            }
+            if (i6 != length) {
+                setColorSpan(spannableStringBuilder, i6, length, i3);
+            }
+            return new SpannableString(spannableStringBuilder);
+        }
+
+        public Cue build() {
+            int i;
+            float f;
+            int i2;
+            int i3;
+            SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder();
+            for (int i4 = 0; i4 < this.rolledUpCaptions.size(); i4++) {
+                spannableStringBuilder.append((CharSequence) this.rolledUpCaptions.get(i4));
+                spannableStringBuilder.append('\n');
+            }
+            spannableStringBuilder.append((CharSequence) buildSpannableString());
+            if (spannableStringBuilder.length() == 0) {
+                return null;
+            }
+            int i5 = this.indent + this.tabOffset;
+            int length = (32 - i5) - spannableStringBuilder.length();
+            int i6 = i5 - length;
+            if (this.captionMode == 2 && (Math.abs(i6) < 3 || length < 0)) {
+                f = 0.5f;
+                i = 1;
+            } else if (this.captionMode != 2 || i6 <= 0) {
+                i = 0;
+                f = ((i5 / 32.0f) * 0.8f) + 0.1f;
+            } else {
+                f = (((32 - length) / 32.0f) * 0.8f) + 0.1f;
+                i = 2;
+            }
+            if (this.captionMode == 1 || (i2 = this.row) > 7) {
+                i2 = this.row - 17;
+                i3 = 2;
+            } else {
+                i3 = 0;
+            }
+            return new Cue(spannableStringBuilder, Layout.Alignment.ALIGN_NORMAL, i2, 1, i3, f, i, Float.MIN_VALUE);
+        }
+
+        public String toString() {
+            return this.captionStringBuilder.toString();
+        }
+
+        private static void setUnderlineSpan(SpannableStringBuilder spannableStringBuilder, int i, int i2) {
+            spannableStringBuilder.setSpan(new UnderlineSpan(), i, i2, 33);
+        }
+
+        private static void setItalicSpan(SpannableStringBuilder spannableStringBuilder, int i, int i2) {
+            spannableStringBuilder.setSpan(new StyleSpan(2), i, i2, 33);
+        }
+
+        private static void setColorSpan(SpannableStringBuilder spannableStringBuilder, int i, int i2, int i3) {
+            if (i3 == -1) {
+                return;
+            }
+            spannableStringBuilder.setSpan(new ForegroundColorSpan(i3), i, i2, 33);
+        }
+
+        public static class CueStyle {
+            public int start;
+            public final int style;
+            public final boolean underline;
+
+            public CueStyle(int i, boolean z, int i2) {
+                this.style = i;
+                this.underline = z;
+                this.start = i2;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/cea/Cea708Cue.java

@@ -0,0 +1,26 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.cea;
+
+import android.text.Layout;
+import androidx.annotation.NonNull;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+
+/* loaded from: classes4.dex */
+final class Cea708Cue extends Cue implements Comparable<Cea708Cue> {
+    public static final int PRIORITY_UNSET = -1;
+    public final int priority;
+
+    public Cea708Cue(CharSequence charSequence, Layout.Alignment alignment, float f, int i, int i2, float f2, int i3, float f3, boolean z, int i4, int i5) {
+        super(charSequence, alignment, f, i, i2, f2, i3, f3, z, i4);
+        this.priority = i5;
+    }
+
+    @Override // java.lang.Comparable
+    public final int compareTo(@NonNull Cea708Cue cea708Cue) {
+        int i = cea708Cue.priority;
+        int i2 = this.priority;
+        if (i < i2) {
+            return -1;
+        }
+        return i > i2 ? 1 : 0;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/cea/CeaDecoder.java

@@ -0,0 +1,170 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.cea;
+
+import androidx.annotation.NonNull;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderException;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleOutputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.ArrayDeque;
+import java.util.PriorityQueue;
+
+/* loaded from: classes4.dex */
+abstract class CeaDecoder implements SubtitleDecoder {
+    private static final int NUM_INPUT_BUFFERS = 10;
+    private static final int NUM_OUTPUT_BUFFERS = 2;
+    private final ArrayDeque<CeaInputBuffer> availableInputBuffers = new ArrayDeque<>();
+    private final ArrayDeque<SubtitleOutputBuffer> availableOutputBuffers;
+    private CeaInputBuffer dequeuedInputBuffer;
+    private long playbackPositionUs;
+    private long queuedInputBufferCount;
+    private final PriorityQueue<CeaInputBuffer> queuedInputBuffers;
+
+    public abstract Subtitle createSubtitle();
+
+    public abstract void decode(SubtitleInputBuffer subtitleInputBuffer);
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public abstract String getName();
+
+    public abstract boolean isNewSubtitleDataAvailable();
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public void release() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoder
+    public void setPositionUs(long j) {
+        this.playbackPositionUs = j;
+    }
+
+    public CeaDecoder() {
+        int i = 0;
+        while (true) {
+            if (i >= 10) {
+                break;
+            }
+            this.availableInputBuffers.add(new CeaInputBuffer());
+            i++;
+        }
+        this.availableOutputBuffers = new ArrayDeque<>();
+        for (int i2 = 0; i2 < 2; i2++) {
+            this.availableOutputBuffers.add(new CeaOutputBuffer());
+        }
+        this.queuedInputBuffers = new PriorityQueue<>();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public SubtitleInputBuffer dequeueInputBuffer() throws SubtitleDecoderException {
+        Assertions.checkState(this.dequeuedInputBuffer == null);
+        if (this.availableInputBuffers.isEmpty()) {
+            return null;
+        }
+        CeaInputBuffer pollFirst = this.availableInputBuffers.pollFirst();
+        this.dequeuedInputBuffer = pollFirst;
+        return pollFirst;
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public void queueInputBuffer(SubtitleInputBuffer subtitleInputBuffer) throws SubtitleDecoderException {
+        Assertions.checkArgument(subtitleInputBuffer == this.dequeuedInputBuffer);
+        if (subtitleInputBuffer.isDecodeOnly()) {
+            releaseInputBuffer(this.dequeuedInputBuffer);
+        } else {
+            CeaInputBuffer ceaInputBuffer = this.dequeuedInputBuffer;
+            long j = this.queuedInputBufferCount;
+            this.queuedInputBufferCount = 1 + j;
+            ceaInputBuffer.queuedInputBufferCount = j;
+            this.queuedInputBuffers.add(this.dequeuedInputBuffer);
+        }
+        this.dequeuedInputBuffer = null;
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public SubtitleOutputBuffer dequeueOutputBuffer() throws SubtitleDecoderException {
+        if (this.availableOutputBuffers.isEmpty()) {
+            return null;
+        }
+        while (!this.queuedInputBuffers.isEmpty() && this.queuedInputBuffers.peek().timeUs <= this.playbackPositionUs) {
+            CeaInputBuffer poll = this.queuedInputBuffers.poll();
+            if (poll.isEndOfStream()) {
+                SubtitleOutputBuffer pollFirst = this.availableOutputBuffers.pollFirst();
+                pollFirst.addFlag(4);
+                releaseInputBuffer(poll);
+                return pollFirst;
+            }
+            decode(poll);
+            if (isNewSubtitleDataAvailable()) {
+                Subtitle createSubtitle = createSubtitle();
+                if (!poll.isDecodeOnly()) {
+                    SubtitleOutputBuffer pollFirst2 = this.availableOutputBuffers.pollFirst();
+                    pollFirst2.setContent(poll.timeUs, createSubtitle, Long.MAX_VALUE);
+                    releaseInputBuffer(poll);
+                    return pollFirst2;
+                }
+            }
+            releaseInputBuffer(poll);
+        }
+        return null;
+    }
+
+    private void releaseInputBuffer(CeaInputBuffer ceaInputBuffer) {
+        ceaInputBuffer.clear();
+        this.availableInputBuffers.add(ceaInputBuffer);
+    }
+
+    public void releaseOutputBuffer(SubtitleOutputBuffer subtitleOutputBuffer) {
+        subtitleOutputBuffer.clear();
+        this.availableOutputBuffers.add(subtitleOutputBuffer);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public void flush() {
+        this.queuedInputBufferCount = 0L;
+        this.playbackPositionUs = 0L;
+        while (!this.queuedInputBuffers.isEmpty()) {
+            releaseInputBuffer(this.queuedInputBuffers.poll());
+        }
+        CeaInputBuffer ceaInputBuffer = this.dequeuedInputBuffer;
+        if (ceaInputBuffer != null) {
+            releaseInputBuffer(ceaInputBuffer);
+            this.dequeuedInputBuffer = null;
+        }
+    }
+
+    public static final class CeaInputBuffer extends SubtitleInputBuffer implements Comparable<CeaInputBuffer> {
+        private long queuedInputBufferCount;
+
+        private CeaInputBuffer() {
+        }
+
+        @Override // java.lang.Comparable
+        public final int compareTo(@NonNull CeaInputBuffer ceaInputBuffer) {
+            if (isEndOfStream() != ceaInputBuffer.isEndOfStream()) {
+                return isEndOfStream() ? 1 : -1;
+            }
+            long j = this.timeUs - ceaInputBuffer.timeUs;
+            if (j == 0) {
+                j = this.queuedInputBufferCount - ceaInputBuffer.queuedInputBufferCount;
+                if (j == 0) {
+                    return 0;
+                }
+            }
+            return j > 0 ? 1 : -1;
+        }
+    }
+
+    public final class CeaOutputBuffer extends SubtitleOutputBuffer {
+        private CeaOutputBuffer() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleOutputBuffer, com.mbridge.msdk.playercommon.exoplayer2.decoder.OutputBuffer
+        public final void release() {
+            CeaDecoder.this.releaseOutputBuffer(this);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/cea/CeaSubtitle.java

@@ -0,0 +1,37 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.cea;
+
+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 CeaSubtitle 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 CeaSubtitle(List<Cue> list) {
+        this.cues = 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();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/cea/CeaUtil.java

@@ -0,0 +1,69 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.cea;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public final class CeaUtil {
+    private static final int COUNTRY_CODE = 181;
+    private static final int PAYLOAD_TYPE_CC = 4;
+    private static final int PROVIDER_CODE_ATSC = 49;
+    private static final int PROVIDER_CODE_DIRECTV = 47;
+    private static final String TAG = "CeaUtil";
+    private static final int USER_DATA_TYPE_CODE = 3;
+    private static final int USER_ID_GA94 = Util.getIntegerCodeForString("GA94");
+    private static final int USER_ID_DTG1 = Util.getIntegerCodeForString("DTG1");
+
+    private CeaUtil() {
+    }
+
+    public static void consume(long j, ParsableByteArray parsableByteArray, TrackOutput[] trackOutputArr) {
+        while (parsableByteArray.bytesLeft() > 1) {
+            int readNon255TerminatedValue = readNon255TerminatedValue(parsableByteArray);
+            int readNon255TerminatedValue2 = readNon255TerminatedValue(parsableByteArray);
+            int position = parsableByteArray.getPosition() + readNon255TerminatedValue2;
+            if (readNon255TerminatedValue2 == -1 || readNon255TerminatedValue2 > parsableByteArray.bytesLeft()) {
+                Log.w(TAG, "Skipping remainder of malformed SEI NAL unit.");
+                position = parsableByteArray.limit();
+            } else if (readNon255TerminatedValue == 4 && readNon255TerminatedValue2 >= 8) {
+                int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                int readUnsignedShort = parsableByteArray.readUnsignedShort();
+                int readInt = readUnsignedShort == 49 ? parsableByteArray.readInt() : 0;
+                int readUnsignedByte2 = parsableByteArray.readUnsignedByte();
+                if (readUnsignedShort == 47) {
+                    parsableByteArray.skipBytes(1);
+                }
+                boolean z = readUnsignedByte == COUNTRY_CODE && (readUnsignedShort == 49 || readUnsignedShort == 47) && readUnsignedByte2 == 3;
+                if (readUnsignedShort == 49) {
+                    z &= readInt == USER_ID_GA94 || readInt == USER_ID_DTG1;
+                }
+                if (z) {
+                    int readUnsignedByte3 = parsableByteArray.readUnsignedByte() & 31;
+                    parsableByteArray.skipBytes(1);
+                    int i = readUnsignedByte3 * 3;
+                    int position2 = parsableByteArray.getPosition();
+                    for (TrackOutput trackOutput : trackOutputArr) {
+                        parsableByteArray.setPosition(position2);
+                        trackOutput.sampleData(parsableByteArray, i);
+                        trackOutput.sampleMetadata(j, 1, i, 0, null);
+                    }
+                }
+            }
+            parsableByteArray.setPosition(position);
+        }
+    }
+
+    private static int readNon255TerminatedValue(ParsableByteArray parsableByteArray) {
+        int i = 0;
+        while (parsableByteArray.bytesLeft() != 0) {
+            int readUnsignedByte = parsableByteArray.readUnsignedByte();
+            i += readUnsignedByte;
+            if (readUnsignedByte != 255) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/dvb/DvbDecoder.java

@@ -0,0 +1,24 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.dvb;
+
+import com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class DvbDecoder extends SimpleSubtitleDecoder {
+    private final DvbParser parser;
+
+    public DvbDecoder(List<byte[]> list) {
+        super("DvbDecoder");
+        ParsableByteArray parsableByteArray = new ParsableByteArray(list.get(0));
+        this.parser = new DvbParser(parsableByteArray.readUnsignedShort(), parsableByteArray.readUnsignedShort());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder
+    public final DvbSubtitle decode(byte[] bArr, int i, boolean z) {
+        if (z) {
+            this.parser.reset();
+        }
+        return new DvbSubtitle(this.parser.decode(bArr, i));
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/dvb/DvbParser.java

@@ -0,0 +1,834 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.dvb;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Region;
+import android.util.Log;
+import android.util.SparseArray;
+import androidx.core.view.ViewCompat;
+import androidx.work.WorkInfo;
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+final class DvbParser {
+    private static final int DATA_TYPE_24_TABLE_DATA = 32;
+    private static final int DATA_TYPE_28_TABLE_DATA = 33;
+    private static final int DATA_TYPE_2BP_CODE_STRING = 16;
+    private static final int DATA_TYPE_48_TABLE_DATA = 34;
+    private static final int DATA_TYPE_4BP_CODE_STRING = 17;
+    private static final int DATA_TYPE_8BP_CODE_STRING = 18;
+    private static final int DATA_TYPE_END_LINE = 240;
+    private static final int OBJECT_CODING_PIXELS = 0;
+    private static final int OBJECT_CODING_STRING = 1;
+    private static final int PAGE_STATE_NORMAL = 0;
+    private static final int REGION_DEPTH_4_BIT = 2;
+    private static final int REGION_DEPTH_8_BIT = 3;
+    private static final int SEGMENT_TYPE_CLUT_DEFINITION = 18;
+    private static final int SEGMENT_TYPE_DISPLAY_DEFINITION = 20;
+    private static final int SEGMENT_TYPE_OBJECT_DATA = 19;
+    private static final int SEGMENT_TYPE_PAGE_COMPOSITION = 16;
+    private static final int SEGMENT_TYPE_REGION_COMPOSITION = 17;
+    private static final String TAG = "DvbParser";
+    private static final byte[] defaultMap2To4 = {0, 7, 8, Ascii.SI};
+    private static final byte[] defaultMap2To8 = {0, 119, -120, -1};
+    private static final byte[] defaultMap4To8 = {0, 17, 34, 51, 68, 85, 102, 119, -120, -103, -86, -69, -52, -35, -18, -1};
+    private Bitmap bitmap;
+    private final Canvas canvas;
+    private final ClutDefinition defaultClutDefinition;
+    private final DisplayDefinition defaultDisplayDefinition;
+    private final Paint defaultPaint;
+    private final Paint fillRegionPaint;
+    private final SubtitleService subtitleService;
+
+    private static int[] generateDefault2BitClutEntries() {
+        return new int[]{0, -1, ViewCompat.MEASURED_STATE_MASK, -8421505};
+    }
+
+    private static int getColor(int i, int i2, int i3, int i4) {
+        return (i << 24) | (i2 << 16) | (i3 << 8) | i4;
+    }
+
+    public DvbParser(int i, int i2) {
+        Paint paint = new Paint();
+        this.defaultPaint = paint;
+        paint.setStyle(Paint.Style.FILL_AND_STROKE);
+        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
+        paint.setPathEffect(null);
+        Paint paint2 = new Paint();
+        this.fillRegionPaint = paint2;
+        paint2.setStyle(Paint.Style.FILL);
+        paint2.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OVER));
+        paint2.setPathEffect(null);
+        this.canvas = new Canvas();
+        this.defaultDisplayDefinition = new DisplayDefinition(719, 575, 0, 719, 0, 575);
+        this.defaultClutDefinition = new ClutDefinition(0, generateDefault2BitClutEntries(), generateDefault4BitClutEntries(), generateDefault8BitClutEntries());
+        this.subtitleService = new SubtitleService(i, i2);
+    }
+
+    public final void reset() {
+        this.subtitleService.reset();
+    }
+
+    public final List<Cue> decode(byte[] bArr, int i) {
+        int i2;
+        int i3;
+        SparseArray<RegionObject> sparseArray;
+        ParsableBitArray parsableBitArray = new ParsableBitArray(bArr, i);
+        while (parsableBitArray.bitsLeft() >= 48 && parsableBitArray.readBits(8) == 15) {
+            parseSubtitlingSegment(parsableBitArray, this.subtitleService);
+        }
+        SubtitleService subtitleService = this.subtitleService;
+        if (subtitleService.pageComposition == null) {
+            return Collections.emptyList();
+        }
+        DisplayDefinition displayDefinition = subtitleService.displayDefinition;
+        if (displayDefinition == null) {
+            displayDefinition = this.defaultDisplayDefinition;
+        }
+        Bitmap bitmap = this.bitmap;
+        if (bitmap == null || displayDefinition.width + 1 != bitmap.getWidth() || displayDefinition.height + 1 != this.bitmap.getHeight()) {
+            Bitmap createBitmap = Bitmap.createBitmap(displayDefinition.width + 1, displayDefinition.height + 1, Bitmap.Config.ARGB_8888);
+            this.bitmap = createBitmap;
+            this.canvas.setBitmap(createBitmap);
+        }
+        ArrayList arrayList = new ArrayList();
+        SparseArray<PageRegion> sparseArray2 = this.subtitleService.pageComposition.regions;
+        for (int i4 = 0; i4 < sparseArray2.size(); i4++) {
+            PageRegion valueAt = sparseArray2.valueAt(i4);
+            RegionComposition regionComposition = this.subtitleService.regions.get(sparseArray2.keyAt(i4));
+            int i5 = valueAt.horizontalAddress + displayDefinition.horizontalPositionMinimum;
+            int i6 = valueAt.verticalAddress + displayDefinition.verticalPositionMinimum;
+            float f = i5;
+            float f2 = i6;
+            this.canvas.clipRect(f, f2, Math.min(regionComposition.width + i5, displayDefinition.horizontalPositionMaximum), Math.min(regionComposition.height + i6, displayDefinition.verticalPositionMaximum), Region.Op.REPLACE);
+            ClutDefinition clutDefinition = this.subtitleService.cluts.get(regionComposition.clutId);
+            if (clutDefinition == null && (clutDefinition = this.subtitleService.ancillaryCluts.get(regionComposition.clutId)) == null) {
+                clutDefinition = this.defaultClutDefinition;
+            }
+            SparseArray<RegionObject> sparseArray3 = regionComposition.regionObjects;
+            int i7 = 0;
+            while (i7 < sparseArray3.size()) {
+                int keyAt = sparseArray3.keyAt(i7);
+                RegionObject valueAt2 = sparseArray3.valueAt(i7);
+                ObjectData objectData = this.subtitleService.objects.get(keyAt);
+                ObjectData objectData2 = objectData == null ? this.subtitleService.ancillaryObjects.get(keyAt) : objectData;
+                if (objectData2 != null) {
+                    i3 = i7;
+                    sparseArray = sparseArray3;
+                    paintPixelDataSubBlocks(objectData2, clutDefinition, regionComposition.depth, valueAt2.horizontalPosition + i5, i6 + valueAt2.verticalPosition, objectData2.nonModifyingColorFlag ? null : this.defaultPaint, this.canvas);
+                } else {
+                    i3 = i7;
+                    sparseArray = sparseArray3;
+                }
+                i7 = i3 + 1;
+                sparseArray3 = sparseArray;
+            }
+            if (regionComposition.fillFlag) {
+                int i8 = regionComposition.depth;
+                if (i8 == 3) {
+                    i2 = clutDefinition.clutEntries8Bit[regionComposition.pixelCode8Bit];
+                } else if (i8 == 2) {
+                    i2 = clutDefinition.clutEntries4Bit[regionComposition.pixelCode4Bit];
+                } else {
+                    i2 = clutDefinition.clutEntries2Bit[regionComposition.pixelCode2Bit];
+                }
+                this.fillRegionPaint.setColor(i2);
+                this.canvas.drawRect(f, f2, regionComposition.width + i5, regionComposition.height + i6, this.fillRegionPaint);
+            }
+            Bitmap createBitmap2 = Bitmap.createBitmap(this.bitmap, i5, i6, regionComposition.width, regionComposition.height);
+            int i9 = displayDefinition.width;
+            int i10 = displayDefinition.height;
+            arrayList.add(new Cue(createBitmap2, f / i9, 0, f2 / i10, 0, regionComposition.width / i9, regionComposition.height / i10));
+            this.canvas.drawColor(0, PorterDuff.Mode.CLEAR);
+        }
+        return arrayList;
+    }
+
+    private static void parseSubtitlingSegment(ParsableBitArray parsableBitArray, SubtitleService subtitleService) {
+        int readBits = parsableBitArray.readBits(8);
+        int readBits2 = parsableBitArray.readBits(16);
+        int readBits3 = parsableBitArray.readBits(16);
+        int bytePosition = parsableBitArray.getBytePosition() + readBits3;
+        if (readBits3 * 8 > parsableBitArray.bitsLeft()) {
+            Log.w(TAG, "Data field length exceeds limit");
+            parsableBitArray.skipBits(parsableBitArray.bitsLeft());
+            return;
+        }
+        switch (readBits) {
+            case 16:
+                if (readBits2 == subtitleService.subtitlePageId) {
+                    PageComposition pageComposition = subtitleService.pageComposition;
+                    PageComposition parsePageComposition = parsePageComposition(parsableBitArray, readBits3);
+                    if (parsePageComposition.state != 0) {
+                        subtitleService.pageComposition = parsePageComposition;
+                        subtitleService.regions.clear();
+                        subtitleService.cluts.clear();
+                        subtitleService.objects.clear();
+                        break;
+                    } else if (pageComposition != null && pageComposition.version != parsePageComposition.version) {
+                        subtitleService.pageComposition = parsePageComposition;
+                        break;
+                    }
+                }
+                break;
+            case 17:
+                PageComposition pageComposition2 = subtitleService.pageComposition;
+                if (readBits2 == subtitleService.subtitlePageId && pageComposition2 != null) {
+                    RegionComposition parseRegionComposition = parseRegionComposition(parsableBitArray, readBits3);
+                    if (pageComposition2.state == 0) {
+                        parseRegionComposition.mergeFrom(subtitleService.regions.get(parseRegionComposition.id));
+                    }
+                    subtitleService.regions.put(parseRegionComposition.id, parseRegionComposition);
+                    break;
+                }
+                break;
+            case 18:
+                if (readBits2 == subtitleService.subtitlePageId) {
+                    ClutDefinition parseClutDefinition = parseClutDefinition(parsableBitArray, readBits3);
+                    subtitleService.cluts.put(parseClutDefinition.id, parseClutDefinition);
+                    break;
+                } else if (readBits2 == subtitleService.ancillaryPageId) {
+                    ClutDefinition parseClutDefinition2 = parseClutDefinition(parsableBitArray, readBits3);
+                    subtitleService.ancillaryCluts.put(parseClutDefinition2.id, parseClutDefinition2);
+                    break;
+                }
+                break;
+            case 19:
+                if (readBits2 == subtitleService.subtitlePageId) {
+                    ObjectData parseObjectData = parseObjectData(parsableBitArray);
+                    subtitleService.objects.put(parseObjectData.id, parseObjectData);
+                    break;
+                } else if (readBits2 == subtitleService.ancillaryPageId) {
+                    ObjectData parseObjectData2 = parseObjectData(parsableBitArray);
+                    subtitleService.ancillaryObjects.put(parseObjectData2.id, parseObjectData2);
+                    break;
+                }
+                break;
+            case 20:
+                if (readBits2 == subtitleService.subtitlePageId) {
+                    subtitleService.displayDefinition = parseDisplayDefinition(parsableBitArray);
+                    break;
+                }
+                break;
+        }
+        parsableBitArray.skipBytes(bytePosition - parsableBitArray.getBytePosition());
+    }
+
+    private static DisplayDefinition parseDisplayDefinition(ParsableBitArray parsableBitArray) {
+        int i;
+        int i2;
+        int i3;
+        int i4;
+        parsableBitArray.skipBits(4);
+        boolean readBit = parsableBitArray.readBit();
+        parsableBitArray.skipBits(3);
+        int readBits = parsableBitArray.readBits(16);
+        int readBits2 = parsableBitArray.readBits(16);
+        if (readBit) {
+            int readBits3 = parsableBitArray.readBits(16);
+            int readBits4 = parsableBitArray.readBits(16);
+            int readBits5 = parsableBitArray.readBits(16);
+            i4 = parsableBitArray.readBits(16);
+            i3 = readBits4;
+            i2 = readBits5;
+            i = readBits3;
+        } else {
+            i = 0;
+            i2 = 0;
+            i3 = readBits;
+            i4 = readBits2;
+        }
+        return new DisplayDefinition(readBits, readBits2, i, i3, i2, i4);
+    }
+
+    private static PageComposition parsePageComposition(ParsableBitArray parsableBitArray, int i) {
+        int readBits = parsableBitArray.readBits(8);
+        int readBits2 = parsableBitArray.readBits(4);
+        int readBits3 = parsableBitArray.readBits(2);
+        parsableBitArray.skipBits(2);
+        int i2 = i - 2;
+        SparseArray sparseArray = new SparseArray();
+        while (i2 > 0) {
+            int readBits4 = parsableBitArray.readBits(8);
+            parsableBitArray.skipBits(8);
+            i2 -= 6;
+            sparseArray.put(readBits4, new PageRegion(parsableBitArray.readBits(16), parsableBitArray.readBits(16)));
+        }
+        return new PageComposition(readBits, readBits2, readBits3, sparseArray);
+    }
+
+    private static RegionComposition parseRegionComposition(ParsableBitArray parsableBitArray, int i) {
+        int i2;
+        int i3;
+        int i4;
+        int readBits = parsableBitArray.readBits(8);
+        parsableBitArray.skipBits(4);
+        boolean readBit = parsableBitArray.readBit();
+        parsableBitArray.skipBits(3);
+        int i5 = 16;
+        int readBits2 = parsableBitArray.readBits(16);
+        int readBits3 = parsableBitArray.readBits(16);
+        int readBits4 = parsableBitArray.readBits(3);
+        int readBits5 = parsableBitArray.readBits(3);
+        int i6 = 2;
+        parsableBitArray.skipBits(2);
+        int readBits6 = parsableBitArray.readBits(8);
+        int readBits7 = parsableBitArray.readBits(8);
+        int readBits8 = parsableBitArray.readBits(4);
+        int readBits9 = parsableBitArray.readBits(2);
+        parsableBitArray.skipBits(2);
+        int i7 = i - 10;
+        SparseArray sparseArray = new SparseArray();
+        while (i7 > 0) {
+            int readBits10 = parsableBitArray.readBits(i5);
+            int readBits11 = parsableBitArray.readBits(i6);
+            int readBits12 = parsableBitArray.readBits(i6);
+            int readBits13 = parsableBitArray.readBits(12);
+            int i8 = readBits9;
+            parsableBitArray.skipBits(4);
+            int readBits14 = parsableBitArray.readBits(12);
+            int i9 = i7 - 6;
+            if (readBits11 != 1) {
+                i2 = 2;
+                if (readBits11 != 2) {
+                    i4 = 0;
+                    i3 = 0;
+                    i7 = i9;
+                    sparseArray.put(readBits10, new RegionObject(readBits11, readBits12, readBits13, readBits14, i4, i3));
+                    i6 = i2;
+                    readBits9 = i8;
+                    i5 = 16;
+                }
+            } else {
+                i2 = 2;
+            }
+            i7 -= 8;
+            i4 = parsableBitArray.readBits(8);
+            i3 = parsableBitArray.readBits(8);
+            sparseArray.put(readBits10, new RegionObject(readBits11, readBits12, readBits13, readBits14, i4, i3));
+            i6 = i2;
+            readBits9 = i8;
+            i5 = 16;
+        }
+        return new RegionComposition(readBits, readBit, readBits2, readBits3, readBits4, readBits5, readBits6, readBits7, readBits8, readBits9, sparseArray);
+    }
+
+    private static ClutDefinition parseClutDefinition(ParsableBitArray parsableBitArray, int i) {
+        int readBits;
+        int i2;
+        int readBits2;
+        int i3;
+        int i4;
+        int i5 = 8;
+        int readBits3 = parsableBitArray.readBits(8);
+        parsableBitArray.skipBits(8);
+        int i6 = 2;
+        int i7 = i - 2;
+        int[] generateDefault2BitClutEntries = generateDefault2BitClutEntries();
+        int[] generateDefault4BitClutEntries = generateDefault4BitClutEntries();
+        int[] generateDefault8BitClutEntries = generateDefault8BitClutEntries();
+        while (i7 > 0) {
+            int readBits4 = parsableBitArray.readBits(i5);
+            int readBits5 = parsableBitArray.readBits(i5);
+            int[] iArr = (readBits5 & 128) != 0 ? generateDefault2BitClutEntries : (readBits5 & 64) != 0 ? generateDefault4BitClutEntries : generateDefault8BitClutEntries;
+            if ((readBits5 & 1) != 0) {
+                i3 = parsableBitArray.readBits(i5);
+                i4 = parsableBitArray.readBits(i5);
+                readBits = parsableBitArray.readBits(i5);
+                readBits2 = parsableBitArray.readBits(i5);
+                i2 = i7 - 6;
+            } else {
+                int readBits6 = parsableBitArray.readBits(6) << i6;
+                int readBits7 = parsableBitArray.readBits(4) << 4;
+                readBits = parsableBitArray.readBits(4) << 4;
+                i2 = i7 - 4;
+                readBits2 = parsableBitArray.readBits(i6) << 6;
+                i3 = readBits6;
+                i4 = readBits7;
+            }
+            if (i3 == 0) {
+                readBits2 = 255;
+                i4 = 0;
+                readBits = 0;
+            }
+            double d = i3;
+            double d2 = i4 + WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT;
+            double d3 = readBits + WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT;
+            iArr[readBits4] = getColor((byte) (255 - (readBits2 & 255)), Util.constrainValue((int) (d + (1.402d * d2)), 0, 255), Util.constrainValue((int) ((d - (0.34414d * d3)) - (d2 * 0.71414d)), 0, 255), Util.constrainValue((int) (d + (d3 * 1.772d)), 0, 255));
+            i7 = i2;
+            readBits3 = readBits3;
+            i5 = 8;
+            i6 = 2;
+        }
+        return new ClutDefinition(readBits3, generateDefault2BitClutEntries, generateDefault4BitClutEntries, generateDefault8BitClutEntries);
+    }
+
+    private static ObjectData parseObjectData(ParsableBitArray parsableBitArray) {
+        byte[] bArr;
+        int readBits = parsableBitArray.readBits(16);
+        parsableBitArray.skipBits(4);
+        int readBits2 = parsableBitArray.readBits(2);
+        boolean readBit = parsableBitArray.readBit();
+        parsableBitArray.skipBits(1);
+        byte[] bArr2 = null;
+        if (readBits2 == 1) {
+            parsableBitArray.skipBits(parsableBitArray.readBits(8) * 16);
+        } else if (readBits2 == 0) {
+            int readBits3 = parsableBitArray.readBits(16);
+            int readBits4 = parsableBitArray.readBits(16);
+            if (readBits3 > 0) {
+                bArr2 = new byte[readBits3];
+                parsableBitArray.readBytes(bArr2, 0, readBits3);
+            }
+            if (readBits4 > 0) {
+                bArr = new byte[readBits4];
+                parsableBitArray.readBytes(bArr, 0, readBits4);
+                return new ObjectData(readBits, readBit, bArr2, bArr);
+            }
+        }
+        bArr = bArr2;
+        return new ObjectData(readBits, readBit, bArr2, bArr);
+    }
+
+    private static int[] generateDefault4BitClutEntries() {
+        int[] iArr = new int[16];
+        iArr[0] = 0;
+        for (int i = 1; i < 16; i++) {
+            if (i < 8) {
+                iArr[i] = getColor(255, (i & 1) != 0 ? 255 : 0, (i & 2) != 0 ? 255 : 0, (i & 4) != 0 ? 255 : 0);
+            } else {
+                iArr[i] = getColor(255, (i & 1) != 0 ? 127 : 0, (i & 2) != 0 ? 127 : 0, (i & 4) == 0 ? 0 : 127);
+            }
+        }
+        return iArr;
+    }
+
+    private static int[] generateDefault8BitClutEntries() {
+        int[] iArr = new int[256];
+        iArr[0] = 0;
+        for (int i = 0; i < 256; i++) {
+            if (i < 8) {
+                iArr[i] = getColor(63, (i & 1) != 0 ? 255 : 0, (i & 2) != 0 ? 255 : 0, (i & 4) == 0 ? 0 : 255);
+            } else {
+                int i2 = i & 136;
+                if (i2 == 0) {
+                    iArr[i] = getColor(255, ((i & 1) != 0 ? 85 : 0) + ((i & 16) != 0 ? 170 : 0), ((i & 2) != 0 ? 85 : 0) + ((i & 32) != 0 ? 170 : 0), ((i & 4) == 0 ? 0 : 85) + ((i & 64) == 0 ? 0 : 170));
+                } else if (i2 == 8) {
+                    iArr[i] = getColor(127, ((i & 1) != 0 ? 85 : 0) + ((i & 16) != 0 ? 170 : 0), ((i & 2) != 0 ? 85 : 0) + ((i & 32) != 0 ? 170 : 0), ((i & 4) == 0 ? 0 : 85) + ((i & 64) == 0 ? 0 : 170));
+                } else if (i2 == 128) {
+                    iArr[i] = getColor(255, ((i & 1) != 0 ? 43 : 0) + 127 + ((i & 16) != 0 ? 85 : 0), ((i & 2) != 0 ? 43 : 0) + 127 + ((i & 32) != 0 ? 85 : 0), ((i & 4) == 0 ? 0 : 43) + 127 + ((i & 64) == 0 ? 0 : 85));
+                } else if (i2 == 136) {
+                    iArr[i] = getColor(255, ((i & 1) != 0 ? 43 : 0) + ((i & 16) != 0 ? 85 : 0), ((i & 2) != 0 ? 43 : 0) + ((i & 32) != 0 ? 85 : 0), ((i & 4) == 0 ? 0 : 43) + ((i & 64) == 0 ? 0 : 85));
+                }
+            }
+        }
+        return iArr;
+    }
+
+    private static void paintPixelDataSubBlocks(ObjectData objectData, ClutDefinition clutDefinition, int i, int i2, int i3, Paint paint, Canvas canvas) {
+        int[] iArr;
+        if (i == 3) {
+            iArr = clutDefinition.clutEntries8Bit;
+        } else if (i == 2) {
+            iArr = clutDefinition.clutEntries4Bit;
+        } else {
+            iArr = clutDefinition.clutEntries2Bit;
+        }
+        int[] iArr2 = iArr;
+        paintPixelDataSubBlock(objectData.topFieldData, iArr2, i, i2, i3, paint, canvas);
+        paintPixelDataSubBlock(objectData.bottomFieldData, iArr2, i, i2, i3 + 1, paint, canvas);
+    }
+
+    private static void paintPixelDataSubBlock(byte[] bArr, int[] iArr, int i, int i2, int i3, Paint paint, Canvas canvas) {
+        byte[] bArr2;
+        byte[] bArr3;
+        ParsableBitArray parsableBitArray = new ParsableBitArray(bArr);
+        int i4 = i2;
+        int i5 = i3;
+        byte[] bArr4 = null;
+        byte[] bArr5 = null;
+        while (parsableBitArray.bitsLeft() != 0) {
+            int readBits = parsableBitArray.readBits(8);
+            if (readBits != 240) {
+                switch (readBits) {
+                    case 16:
+                        if (i != 3) {
+                            if (i != 2) {
+                                bArr2 = null;
+                                i4 = paint2BitPixelCodeString(parsableBitArray, iArr, bArr2, i4, i5, paint, canvas);
+                                parsableBitArray.byteAlign();
+                                break;
+                            } else {
+                                bArr3 = bArr5 == null ? defaultMap2To4 : bArr5;
+                            }
+                        } else {
+                            bArr3 = bArr4 == null ? defaultMap2To8 : bArr4;
+                        }
+                        bArr2 = bArr3;
+                        i4 = paint2BitPixelCodeString(parsableBitArray, iArr, bArr2, i4, i5, paint, canvas);
+                        parsableBitArray.byteAlign();
+                    case 17:
+                        i4 = paint4BitPixelCodeString(parsableBitArray, iArr, i == 3 ? defaultMap4To8 : null, i4, i5, paint, canvas);
+                        parsableBitArray.byteAlign();
+                        break;
+                    case 18:
+                        i4 = paint8BitPixelCodeString(parsableBitArray, iArr, null, i4, i5, paint, canvas);
+                        break;
+                    default:
+                        switch (readBits) {
+                            case 32:
+                                bArr5 = buildClutMapTable(4, 4, parsableBitArray);
+                                break;
+                            case 33:
+                                bArr4 = buildClutMapTable(4, 8, parsableBitArray);
+                                break;
+                            case 34:
+                                bArr4 = buildClutMapTable(16, 8, parsableBitArray);
+                                break;
+                        }
+                }
+            } else {
+                i5 += 2;
+                i4 = i2;
+            }
+        }
+    }
+
+    private static int paint2BitPixelCodeString(ParsableBitArray parsableBitArray, int[] iArr, byte[] bArr, int i, int i2, Paint paint, Canvas canvas) {
+        boolean z;
+        int i3;
+        int readBits;
+        int readBits2;
+        int i4 = i;
+        boolean z2 = false;
+        while (true) {
+            int readBits3 = parsableBitArray.readBits(2);
+            if (readBits3 != 0) {
+                z = z2;
+                i3 = 1;
+            } else {
+                if (parsableBitArray.readBit()) {
+                    readBits = parsableBitArray.readBits(3) + 3;
+                    readBits2 = parsableBitArray.readBits(2);
+                } else {
+                    if (parsableBitArray.readBit()) {
+                        z = z2;
+                        i3 = 1;
+                    } else {
+                        int readBits4 = parsableBitArray.readBits(2);
+                        if (readBits4 == 0) {
+                            z = true;
+                        } else if (readBits4 == 1) {
+                            z = z2;
+                            i3 = 2;
+                        } else if (readBits4 == 2) {
+                            readBits = parsableBitArray.readBits(4) + 12;
+                            readBits2 = parsableBitArray.readBits(2);
+                        } else if (readBits4 != 3) {
+                            z = z2;
+                        } else {
+                            readBits = parsableBitArray.readBits(8) + 29;
+                            readBits2 = parsableBitArray.readBits(2);
+                        }
+                        readBits3 = 0;
+                        i3 = 0;
+                    }
+                    readBits3 = 0;
+                }
+                z = z2;
+                i3 = readBits;
+                readBits3 = readBits2;
+            }
+            if (i3 != 0 && paint != null) {
+                if (bArr != null) {
+                    readBits3 = bArr[readBits3];
+                }
+                paint.setColor(iArr[readBits3]);
+                canvas.drawRect(i4, i2, i4 + i3, i2 + 1, paint);
+            }
+            i4 += i3;
+            if (z) {
+                return i4;
+            }
+            z2 = z;
+        }
+    }
+
+    private static int paint4BitPixelCodeString(ParsableBitArray parsableBitArray, int[] iArr, byte[] bArr, int i, int i2, Paint paint, Canvas canvas) {
+        boolean z;
+        int i3;
+        int readBits;
+        int readBits2;
+        int i4 = i;
+        boolean z2 = false;
+        while (true) {
+            int readBits3 = parsableBitArray.readBits(4);
+            if (readBits3 != 0) {
+                z = z2;
+                i3 = 1;
+            } else if (!parsableBitArray.readBit()) {
+                int readBits4 = parsableBitArray.readBits(3);
+                if (readBits4 != 0) {
+                    z = z2;
+                    i3 = readBits4 + 2;
+                    readBits3 = 0;
+                } else {
+                    z = true;
+                    readBits3 = 0;
+                    i3 = 0;
+                }
+            } else {
+                if (!parsableBitArray.readBit()) {
+                    readBits = parsableBitArray.readBits(2) + 4;
+                    readBits2 = parsableBitArray.readBits(4);
+                } else {
+                    int readBits5 = parsableBitArray.readBits(2);
+                    if (readBits5 == 0) {
+                        z = z2;
+                        i3 = 1;
+                    } else if (readBits5 == 1) {
+                        z = z2;
+                        i3 = 2;
+                    } else if (readBits5 == 2) {
+                        readBits = parsableBitArray.readBits(4) + 9;
+                        readBits2 = parsableBitArray.readBits(4);
+                    } else if (readBits5 != 3) {
+                        z = z2;
+                        readBits3 = 0;
+                        i3 = 0;
+                    } else {
+                        readBits = parsableBitArray.readBits(8) + 25;
+                        readBits2 = parsableBitArray.readBits(4);
+                    }
+                    readBits3 = 0;
+                }
+                z = z2;
+                i3 = readBits;
+                readBits3 = readBits2;
+            }
+            if (i3 != 0 && paint != null) {
+                if (bArr != null) {
+                    readBits3 = bArr[readBits3];
+                }
+                paint.setColor(iArr[readBits3]);
+                canvas.drawRect(i4, i2, i4 + i3, i2 + 1, paint);
+            }
+            i4 += i3;
+            if (z) {
+                return i4;
+            }
+            z2 = z;
+        }
+    }
+
+    private static int paint8BitPixelCodeString(ParsableBitArray parsableBitArray, int[] iArr, byte[] bArr, int i, int i2, Paint paint, Canvas canvas) {
+        boolean z;
+        int readBits;
+        int i3 = i;
+        boolean z2 = false;
+        while (true) {
+            int readBits2 = parsableBitArray.readBits(8);
+            if (readBits2 != 0) {
+                z = z2;
+                readBits = 1;
+            } else if (!parsableBitArray.readBit()) {
+                int readBits3 = parsableBitArray.readBits(7);
+                if (readBits3 != 0) {
+                    z = z2;
+                    readBits = readBits3;
+                    readBits2 = 0;
+                } else {
+                    z = true;
+                    readBits2 = 0;
+                    readBits = 0;
+                }
+            } else {
+                z = z2;
+                readBits = parsableBitArray.readBits(7);
+                readBits2 = parsableBitArray.readBits(8);
+            }
+            if (readBits != 0 && paint != null) {
+                if (bArr != null) {
+                    readBits2 = bArr[readBits2];
+                }
+                paint.setColor(iArr[readBits2]);
+                canvas.drawRect(i3, i2, i3 + readBits, i2 + 1, paint);
+            }
+            i3 += readBits;
+            if (z) {
+                return i3;
+            }
+            z2 = z;
+        }
+    }
+
+    private static byte[] buildClutMapTable(int i, int i2, ParsableBitArray parsableBitArray) {
+        byte[] bArr = new byte[i];
+        for (int i3 = 0; i3 < i; i3++) {
+            bArr[i3] = (byte) parsableBitArray.readBits(i2);
+        }
+        return bArr;
+    }
+
+    public static final class SubtitleService {
+        public final int ancillaryPageId;
+        public DisplayDefinition displayDefinition;
+        public PageComposition pageComposition;
+        public final int subtitlePageId;
+        public final SparseArray<RegionComposition> regions = new SparseArray<>();
+        public final SparseArray<ClutDefinition> cluts = new SparseArray<>();
+        public final SparseArray<ObjectData> objects = new SparseArray<>();
+        public final SparseArray<ClutDefinition> ancillaryCluts = new SparseArray<>();
+        public final SparseArray<ObjectData> ancillaryObjects = new SparseArray<>();
+
+        public SubtitleService(int i, int i2) {
+            this.subtitlePageId = i;
+            this.ancillaryPageId = i2;
+        }
+
+        public final void reset() {
+            this.regions.clear();
+            this.cluts.clear();
+            this.objects.clear();
+            this.ancillaryCluts.clear();
+            this.ancillaryObjects.clear();
+            this.displayDefinition = null;
+            this.pageComposition = null;
+        }
+    }
+
+    public static final class DisplayDefinition {
+        public final int height;
+        public final int horizontalPositionMaximum;
+        public final int horizontalPositionMinimum;
+        public final int verticalPositionMaximum;
+        public final int verticalPositionMinimum;
+        public final int width;
+
+        public DisplayDefinition(int i, int i2, int i3, int i4, int i5, int i6) {
+            this.width = i;
+            this.height = i2;
+            this.horizontalPositionMinimum = i3;
+            this.horizontalPositionMaximum = i4;
+            this.verticalPositionMinimum = i5;
+            this.verticalPositionMaximum = i6;
+        }
+    }
+
+    public static final class PageComposition {
+        public final SparseArray<PageRegion> regions;
+        public final int state;
+        public final int timeOutSecs;
+        public final int version;
+
+        public PageComposition(int i, int i2, int i3, SparseArray<PageRegion> sparseArray) {
+            this.timeOutSecs = i;
+            this.version = i2;
+            this.state = i3;
+            this.regions = sparseArray;
+        }
+    }
+
+    public static final class PageRegion {
+        public final int horizontalAddress;
+        public final int verticalAddress;
+
+        public PageRegion(int i, int i2) {
+            this.horizontalAddress = i;
+            this.verticalAddress = i2;
+        }
+    }
+
+    public static final class RegionComposition {
+        public final int clutId;
+        public final int depth;
+        public final boolean fillFlag;
+        public final int height;
+        public final int id;
+        public final int levelOfCompatibility;
+        public final int pixelCode2Bit;
+        public final int pixelCode4Bit;
+        public final int pixelCode8Bit;
+        public final SparseArray<RegionObject> regionObjects;
+        public final int width;
+
+        public RegionComposition(int i, boolean z, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, SparseArray<RegionObject> sparseArray) {
+            this.id = i;
+            this.fillFlag = z;
+            this.width = i2;
+            this.height = i3;
+            this.levelOfCompatibility = i4;
+            this.depth = i5;
+            this.clutId = i6;
+            this.pixelCode8Bit = i7;
+            this.pixelCode4Bit = i8;
+            this.pixelCode2Bit = i9;
+            this.regionObjects = sparseArray;
+        }
+
+        public final void mergeFrom(RegionComposition regionComposition) {
+            if (regionComposition == null) {
+                return;
+            }
+            SparseArray<RegionObject> sparseArray = regionComposition.regionObjects;
+            for (int i = 0; i < sparseArray.size(); i++) {
+                this.regionObjects.put(sparseArray.keyAt(i), sparseArray.valueAt(i));
+            }
+        }
+    }
+
+    public static final class RegionObject {
+        public final int backgroundPixelCode;
+        public final int foregroundPixelCode;
+        public final int horizontalPosition;
+        public final int provider;
+        public final int type;
+        public final int verticalPosition;
+
+        public RegionObject(int i, int i2, int i3, int i4, int i5, int i6) {
+            this.type = i;
+            this.provider = i2;
+            this.horizontalPosition = i3;
+            this.verticalPosition = i4;
+            this.foregroundPixelCode = i5;
+            this.backgroundPixelCode = i6;
+        }
+    }
+
+    public static final class ClutDefinition {
+        public final int[] clutEntries2Bit;
+        public final int[] clutEntries4Bit;
+        public final int[] clutEntries8Bit;
+        public final int id;
+
+        public ClutDefinition(int i, int[] iArr, int[] iArr2, int[] iArr3) {
+            this.id = i;
+            this.clutEntries2Bit = iArr;
+            this.clutEntries4Bit = iArr2;
+            this.clutEntries8Bit = iArr3;
+        }
+    }
+
+    public static final class ObjectData {
+        public final byte[] bottomFieldData;
+        public final int id;
+        public final boolean nonModifyingColorFlag;
+        public final byte[] topFieldData;
+
+        public ObjectData(int i, boolean z, byte[] bArr, byte[] bArr2) {
+            this.id = i;
+            this.nonModifyingColorFlag = z;
+            this.topFieldData = bArr;
+            this.bottomFieldData = bArr2;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/dvb/DvbSubtitle.java

@@ -0,0 +1,34 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.dvb;
+
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+final class DvbSubtitle implements Subtitle {
+    private final List<Cue> cues;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final List<Cue> getCues(long j) {
+        return this.cues;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final long getEventTime(int i) {
+        return 0L;
+    }
+
+    @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 -1;
+    }
+
+    public DvbSubtitle(List<Cue> list) {
+        this.cues = list;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/pgs/PgsDecoder.java

@@ -0,0 +1,232 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.pgs;
+
+import android.graphics.Bitmap;
+import androidx.work.WorkInfo;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
+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.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.zip.DataFormatException;
+import java.util.zip.Inflater;
+
+/* loaded from: classes4.dex */
+public final class PgsDecoder extends SimpleSubtitleDecoder {
+    private static final byte INFLATE_HEADER = 120;
+    private static final int SECTION_TYPE_BITMAP_PICTURE = 21;
+    private static final int SECTION_TYPE_END = 128;
+    private static final int SECTION_TYPE_IDENTIFIER = 22;
+    private static final int SECTION_TYPE_PALETTE = 20;
+    private final ParsableByteArray buffer;
+    private final CueBuilder cueBuilder;
+    private byte[] inflatedData;
+    private int inflatedDataSize;
+    private Inflater inflater;
+
+    public PgsDecoder() {
+        super("PgsDecoder");
+        this.buffer = new ParsableByteArray();
+        this.cueBuilder = new CueBuilder();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder
+    public final Subtitle decode(byte[] bArr, int i, boolean z) throws SubtitleDecoderException {
+        if (maybeInflateData(bArr, i)) {
+            this.buffer.reset(this.inflatedData, this.inflatedDataSize);
+        } else {
+            this.buffer.reset(bArr, i);
+        }
+        this.cueBuilder.reset();
+        ArrayList arrayList = new ArrayList();
+        while (this.buffer.bytesLeft() >= 3) {
+            Cue readNextSection = readNextSection(this.buffer, this.cueBuilder);
+            if (readNextSection != null) {
+                arrayList.add(readNextSection);
+            }
+        }
+        return new PgsSubtitle(Collections.unmodifiableList(arrayList));
+    }
+
+    private boolean maybeInflateData(byte[] bArr, int i) {
+        if (i != 0 && bArr[0] == 120) {
+            if (this.inflater == null) {
+                this.inflater = new Inflater();
+                this.inflatedData = new byte[i];
+            }
+            this.inflatedDataSize = 0;
+            this.inflater.setInput(bArr, 0, i);
+            while (!this.inflater.finished() && !this.inflater.needsDictionary() && !this.inflater.needsInput()) {
+                try {
+                    int i2 = this.inflatedDataSize;
+                    byte[] bArr2 = this.inflatedData;
+                    if (i2 == bArr2.length) {
+                        this.inflatedData = Arrays.copyOf(bArr2, bArr2.length * 2);
+                    }
+                    int i3 = this.inflatedDataSize;
+                    Inflater inflater = this.inflater;
+                    byte[] bArr3 = this.inflatedData;
+                    this.inflatedDataSize = i3 + inflater.inflate(bArr3, i3, bArr3.length - i3);
+                } catch (DataFormatException unused) {
+                    this.inflater.reset();
+                } catch (Throwable th) {
+                    this.inflater.reset();
+                    throw th;
+                }
+            }
+            boolean finished = this.inflater.finished();
+            this.inflater.reset();
+            return finished;
+        }
+        return false;
+    }
+
+    private static Cue readNextSection(ParsableByteArray parsableByteArray, CueBuilder cueBuilder) {
+        int limit = parsableByteArray.limit();
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        int readUnsignedShort = parsableByteArray.readUnsignedShort();
+        int position = parsableByteArray.getPosition() + readUnsignedShort;
+        Cue cue = null;
+        if (position > limit) {
+            parsableByteArray.setPosition(limit);
+            return null;
+        }
+        if (readUnsignedByte == 128) {
+            cue = cueBuilder.build();
+            cueBuilder.reset();
+        } else {
+            switch (readUnsignedByte) {
+                case 20:
+                    cueBuilder.parsePaletteSection(parsableByteArray, readUnsignedShort);
+                    break;
+                case 21:
+                    cueBuilder.parseBitmapSection(parsableByteArray, readUnsignedShort);
+                    break;
+                case 22:
+                    cueBuilder.parseIdentifierSection(parsableByteArray, readUnsignedShort);
+                    break;
+            }
+        }
+        parsableByteArray.setPosition(position);
+        return cue;
+    }
+
+    public static final class CueBuilder {
+        private int bitmapHeight;
+        private int bitmapWidth;
+        private int bitmapX;
+        private int bitmapY;
+        private boolean colorsSet;
+        private int planeHeight;
+        private int planeWidth;
+        private final ParsableByteArray bitmapData = new ParsableByteArray();
+        private final int[] colors = new int[256];
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void parsePaletteSection(ParsableByteArray parsableByteArray, int i) {
+            if (i % 5 != 2) {
+                return;
+            }
+            parsableByteArray.skipBytes(2);
+            Arrays.fill(this.colors, 0);
+            int i2 = i / 5;
+            for (int i3 = 0; i3 < i2; i3++) {
+                int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                int readUnsignedByte2 = parsableByteArray.readUnsignedByte();
+                int readUnsignedByte3 = parsableByteArray.readUnsignedByte();
+                int readUnsignedByte4 = parsableByteArray.readUnsignedByte();
+                int readUnsignedByte5 = parsableByteArray.readUnsignedByte();
+                double d = readUnsignedByte2;
+                double d2 = readUnsignedByte3 + WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT;
+                double d3 = readUnsignedByte4 + WorkInfo.STOP_REASON_FOREGROUND_SERVICE_TIMEOUT;
+                this.colors[readUnsignedByte] = (Util.constrainValue((int) ((d - (0.34414d * d3)) - (d2 * 0.71414d)), 0, 255) << 8) | (readUnsignedByte5 << 24) | (Util.constrainValue((int) ((1.402d * d2) + d), 0, 255) << 16) | Util.constrainValue((int) (d + (d3 * 1.772d)), 0, 255);
+            }
+            this.colorsSet = true;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void parseBitmapSection(ParsableByteArray parsableByteArray, int i) {
+            int readUnsignedInt24;
+            if (i < 4) {
+                return;
+            }
+            parsableByteArray.skipBytes(3);
+            int i2 = i - 4;
+            if ((parsableByteArray.readUnsignedByte() & 128) != 0) {
+                if (i2 < 7 || (readUnsignedInt24 = parsableByteArray.readUnsignedInt24()) < 4) {
+                    return;
+                }
+                this.bitmapWidth = parsableByteArray.readUnsignedShort();
+                this.bitmapHeight = parsableByteArray.readUnsignedShort();
+                this.bitmapData.reset(readUnsignedInt24 - 4);
+                i2 = i - 11;
+            }
+            int position = this.bitmapData.getPosition();
+            int limit = this.bitmapData.limit();
+            if (position >= limit || i2 <= 0) {
+                return;
+            }
+            int min = Math.min(i2, limit - position);
+            parsableByteArray.readBytes(this.bitmapData.data, position, min);
+            this.bitmapData.setPosition(position + min);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void parseIdentifierSection(ParsableByteArray parsableByteArray, int i) {
+            if (i < 19) {
+                return;
+            }
+            this.planeWidth = parsableByteArray.readUnsignedShort();
+            this.planeHeight = parsableByteArray.readUnsignedShort();
+            parsableByteArray.skipBytes(11);
+            this.bitmapX = parsableByteArray.readUnsignedShort();
+            this.bitmapY = parsableByteArray.readUnsignedShort();
+        }
+
+        public final Cue build() {
+            int i;
+            if (this.planeWidth == 0 || this.planeHeight == 0 || this.bitmapWidth == 0 || this.bitmapHeight == 0 || this.bitmapData.limit() == 0 || this.bitmapData.getPosition() != this.bitmapData.limit() || !this.colorsSet) {
+                return null;
+            }
+            this.bitmapData.setPosition(0);
+            int i2 = this.bitmapWidth * this.bitmapHeight;
+            int[] iArr = new int[i2];
+            int i3 = 0;
+            while (i3 < i2) {
+                int readUnsignedByte = this.bitmapData.readUnsignedByte();
+                if (readUnsignedByte != 0) {
+                    i = i3 + 1;
+                    iArr[i3] = this.colors[readUnsignedByte];
+                } else {
+                    int readUnsignedByte2 = this.bitmapData.readUnsignedByte();
+                    if (readUnsignedByte2 != 0) {
+                        i = ((readUnsignedByte2 & 64) == 0 ? readUnsignedByte2 & 63 : ((readUnsignedByte2 & 63) << 8) | this.bitmapData.readUnsignedByte()) + i3;
+                        Arrays.fill(iArr, i3, i, (readUnsignedByte2 & 128) == 0 ? 0 : this.colors[this.bitmapData.readUnsignedByte()]);
+                    }
+                }
+                i3 = i;
+            }
+            Bitmap createBitmap = Bitmap.createBitmap(iArr, this.bitmapWidth, this.bitmapHeight, Bitmap.Config.ARGB_8888);
+            float f = this.bitmapX;
+            int i4 = this.planeWidth;
+            float f2 = f / i4;
+            float f3 = this.bitmapY;
+            int i5 = this.planeHeight;
+            return new Cue(createBitmap, f2, 0, f3 / i5, 0, this.bitmapWidth / i4, this.bitmapHeight / i5);
+        }
+
+        public final void reset() {
+            this.planeWidth = 0;
+            this.planeHeight = 0;
+            this.bitmapX = 0;
+            this.bitmapY = 0;
+            this.bitmapWidth = 0;
+            this.bitmapHeight = 0;
+            this.bitmapData.reset(0);
+            this.colorsSet = false;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/pgs/PgsSubtitle.java

@@ -0,0 +1,34 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.pgs;
+
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+final class PgsSubtitle implements Subtitle {
+    private final List<Cue> cues;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final List<Cue> getCues(long j) {
+        return this.cues;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final long getEventTime(int i) {
+        return 0L;
+    }
+
+    @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 -1;
+    }
+
+    public PgsSubtitle(List<Cue> list) {
+        this.cues = list;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/ssa/SsaDecoder.java

@@ -0,0 +1,178 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.ssa;
+
+import android.text.TextUtils;
+import android.util.Log;
+import androidx.work.WorkRequest;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlNode;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.LongArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes4.dex */
+public final class SsaDecoder extends SimpleSubtitleDecoder {
+    private static final String DIALOGUE_LINE_PREFIX = "Dialogue: ";
+    private static final String FORMAT_LINE_PREFIX = "Format: ";
+    private static final Pattern SSA_TIMECODE_PATTERN = Pattern.compile("(?:(\\d+):)?(\\d+):(\\d+)(?::|\\.)(\\d+)");
+    private static final String TAG = "SsaDecoder";
+    private int formatEndIndex;
+    private int formatKeyCount;
+    private int formatStartIndex;
+    private int formatTextIndex;
+    private final boolean haveInitializationData;
+
+    public SsaDecoder() {
+        this(null);
+    }
+
+    public SsaDecoder(List<byte[]> list) {
+        super(TAG);
+        if (list == null || list.isEmpty()) {
+            this.haveInitializationData = false;
+            return;
+        }
+        this.haveInitializationData = true;
+        String fromUtf8Bytes = Util.fromUtf8Bytes(list.get(0));
+        Assertions.checkArgument(fromUtf8Bytes.startsWith(FORMAT_LINE_PREFIX));
+        parseFormatLine(fromUtf8Bytes);
+        parseHeader(new ParsableByteArray(list.get(1)));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder
+    public final SsaSubtitle decode(byte[] bArr, int i, boolean z) {
+        ArrayList arrayList = new ArrayList();
+        LongArray longArray = new LongArray();
+        ParsableByteArray parsableByteArray = new ParsableByteArray(bArr, i);
+        if (!this.haveInitializationData) {
+            parseHeader(parsableByteArray);
+        }
+        parseEventBody(parsableByteArray, arrayList, longArray);
+        Cue[] cueArr = new Cue[arrayList.size()];
+        arrayList.toArray(cueArr);
+        return new SsaSubtitle(cueArr, longArray.toArray());
+    }
+
+    private void parseHeader(ParsableByteArray parsableByteArray) {
+        String readLine;
+        do {
+            readLine = parsableByteArray.readLine();
+            if (readLine == null) {
+                return;
+            }
+        } while (!readLine.startsWith("[Events]"));
+    }
+
+    private void parseEventBody(ParsableByteArray parsableByteArray, List<Cue> list, LongArray longArray) {
+        while (true) {
+            String readLine = parsableByteArray.readLine();
+            if (readLine == null) {
+                return;
+            }
+            if (!this.haveInitializationData && readLine.startsWith(FORMAT_LINE_PREFIX)) {
+                parseFormatLine(readLine);
+            } else if (readLine.startsWith(DIALOGUE_LINE_PREFIX)) {
+                parseDialogueLine(readLine, list, longArray);
+            }
+        }
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    private void parseFormatLine(String str) {
+        char c;
+        String[] split = TextUtils.split(str.substring(8), ",");
+        this.formatKeyCount = split.length;
+        this.formatStartIndex = -1;
+        this.formatEndIndex = -1;
+        this.formatTextIndex = -1;
+        for (int i = 0; i < this.formatKeyCount; i++) {
+            String lowerInvariant = Util.toLowerInvariant(split[i].trim());
+            lowerInvariant.hashCode();
+            switch (lowerInvariant.hashCode()) {
+                case 100571:
+                    if (lowerInvariant.equals(TtmlNode.END)) {
+                        c = 0;
+                        break;
+                    }
+                    c = 65535;
+                    break;
+                case 3556653:
+                    if (lowerInvariant.equals("text")) {
+                        c = 1;
+                        break;
+                    }
+                    c = 65535;
+                    break;
+                case 109757538:
+                    if (lowerInvariant.equals("start")) {
+                        c = 2;
+                        break;
+                    }
+                    c = 65535;
+                    break;
+                default:
+                    c = 65535;
+                    break;
+            }
+            switch (c) {
+                case 0:
+                    this.formatEndIndex = i;
+                    break;
+                case 1:
+                    this.formatTextIndex = i;
+                    break;
+                case 2:
+                    this.formatStartIndex = i;
+                    break;
+            }
+        }
+        if (this.formatStartIndex == -1 || this.formatEndIndex == -1 || this.formatTextIndex == -1) {
+            this.formatKeyCount = 0;
+        }
+    }
+
+    private void parseDialogueLine(String str, List<Cue> list, LongArray longArray) {
+        long j;
+        if (this.formatKeyCount == 0) {
+            Log.w(TAG, "Skipping dialogue line before complete format: " + str);
+            return;
+        }
+        String[] split = str.substring(10).split(",", this.formatKeyCount);
+        if (split.length != this.formatKeyCount) {
+            Log.w(TAG, "Skipping dialogue line with fewer columns than format: " + str);
+            return;
+        }
+        long parseTimecodeUs = parseTimecodeUs(split[this.formatStartIndex]);
+        if (parseTimecodeUs == C.TIME_UNSET) {
+            Log.w(TAG, "Skipping invalid timing: " + str);
+            return;
+        }
+        String str2 = split[this.formatEndIndex];
+        if (str2.trim().isEmpty()) {
+            j = -9223372036854775807L;
+        } else {
+            j = parseTimecodeUs(str2);
+            if (j == C.TIME_UNSET) {
+                Log.w(TAG, "Skipping invalid timing: " + str);
+                return;
+            }
+        }
+        list.add(new Cue(split[this.formatTextIndex].replaceAll("\\{.*?\\}", "").replaceAll("\\\\N", "\n").replaceAll("\\\\n", "\n")));
+        longArray.add(parseTimecodeUs);
+        if (j != C.TIME_UNSET) {
+            list.add(null);
+            longArray.add(j);
+        }
+    }
+
+    public static long parseTimecodeUs(String str) {
+        Matcher matcher = SSA_TIMECODE_PATTERN.matcher(str);
+        return !matcher.matches() ? C.TIME_UNSET : (Long.parseLong(matcher.group(1)) * 3600000000L) + (Long.parseLong(matcher.group(2)) * 60000000) + (Long.parseLong(matcher.group(3)) * 1000000) + (Long.parseLong(matcher.group(4)) * WorkRequest.MIN_BACKOFF_MILLIS);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/ssa/SsaSubtitle.java

@@ -0,0 +1,50 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.ssa;
+
+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.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+final class SsaSubtitle implements Subtitle {
+    private final long[] cueTimesUs;
+    private final Cue[] cues;
+
+    public SsaSubtitle(Cue[] cueArr, long[] jArr) {
+        this.cues = cueArr;
+        this.cueTimesUs = jArr;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final int getNextEventTimeIndex(long j) {
+        int binarySearchCeil = Util.binarySearchCeil(this.cueTimesUs, j, false, false);
+        if (binarySearchCeil < this.cueTimesUs.length) {
+            return binarySearchCeil;
+        }
+        return -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final int getEventTimeCount() {
+        return this.cueTimesUs.length;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final long getEventTime(int i) {
+        Assertions.checkArgument(i >= 0);
+        Assertions.checkArgument(i < this.cueTimesUs.length);
+        return this.cueTimesUs[i];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final List<Cue> getCues(long j) {
+        Cue cue;
+        int binarySearchFloor = Util.binarySearchFloor(this.cueTimesUs, j, true, false);
+        if (binarySearchFloor == -1 || (cue = this.cues[binarySearchFloor]) == null) {
+            return Collections.emptyList();
+        }
+        return Collections.singletonList(cue);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/subrip/SubripDecoder.java

@@ -0,0 +1,80 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.subrip;
+
+import android.text.Html;
+import android.text.TextUtils;
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkedTrackBlacklistUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.util.LongArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes4.dex */
+public final class SubripDecoder extends SimpleSubtitleDecoder {
+    private static final String SUBRIP_TIMECODE = "(?:(\\d+):)?(\\d+):(\\d+),(\\d+)";
+    private static final Pattern SUBRIP_TIMING_LINE = Pattern.compile("\\s*((?:(\\d+):)?(\\d+):(\\d+),(\\d+))\\s*-->\\s*((?:(\\d+):)?(\\d+):(\\d+),(\\d+))?\\s*");
+    private static final String TAG = "SubripDecoder";
+    private final StringBuilder textBuilder;
+
+    public SubripDecoder() {
+        super(TAG);
+        this.textBuilder = new StringBuilder();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder
+    public final SubripSubtitle decode(byte[] bArr, int i, boolean z) {
+        ArrayList arrayList = new ArrayList();
+        LongArray longArray = new LongArray();
+        ParsableByteArray parsableByteArray = new ParsableByteArray(bArr, i);
+        while (true) {
+            String readLine = parsableByteArray.readLine();
+            if (readLine == null) {
+                break;
+            }
+            if (readLine.length() != 0) {
+                String readLine2 = parsableByteArray.readLine();
+                if (readLine2 == null) {
+                    Log.w(TAG, "Unexpected end");
+                    break;
+                }
+                Matcher matcher = SUBRIP_TIMING_LINE.matcher(readLine2);
+                if (matcher.matches()) {
+                    boolean z2 = true;
+                    longArray.add(parseTimecode(matcher, 1));
+                    if (TextUtils.isEmpty(matcher.group(6))) {
+                        z2 = false;
+                    } else {
+                        longArray.add(parseTimecode(matcher, 6));
+                    }
+                    this.textBuilder.setLength(0);
+                    while (true) {
+                        String readLine3 = parsableByteArray.readLine();
+                        if (TextUtils.isEmpty(readLine3)) {
+                            break;
+                        }
+                        if (this.textBuilder.length() > 0) {
+                            this.textBuilder.append("<br>");
+                        }
+                        this.textBuilder.append(readLine3.trim());
+                    }
+                    arrayList.add(new Cue(Html.fromHtml(this.textBuilder.toString())));
+                    if (z2) {
+                        arrayList.add(null);
+                    }
+                } else {
+                    Log.w(TAG, "Skipping invalid timing: " + readLine2);
+                }
+            }
+        }
+        Cue[] cueArr = new Cue[arrayList.size()];
+        arrayList.toArray(cueArr);
+        return new SubripSubtitle(cueArr, longArray.toArray());
+    }
+
+    private static long parseTimecode(Matcher matcher, int i) {
+        return ((Long.parseLong(matcher.group(i + 1)) * 3600000) + (Long.parseLong(matcher.group(i + 2)) * ChunkedTrackBlacklistUtil.DEFAULT_TRACK_BLACKLIST_MS) + (Long.parseLong(matcher.group(i + 3)) * 1000) + Long.parseLong(matcher.group(i + 4))) * 1000;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/subrip/SubripSubtitle.java

@@ -0,0 +1,50 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.subrip;
+
+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.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+final class SubripSubtitle implements Subtitle {
+    private final long[] cueTimesUs;
+    private final Cue[] cues;
+
+    public SubripSubtitle(Cue[] cueArr, long[] jArr) {
+        this.cues = cueArr;
+        this.cueTimesUs = jArr;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final int getNextEventTimeIndex(long j) {
+        int binarySearchCeil = Util.binarySearchCeil(this.cueTimesUs, j, false, false);
+        if (binarySearchCeil < this.cueTimesUs.length) {
+            return binarySearchCeil;
+        }
+        return -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final int getEventTimeCount() {
+        return this.cueTimesUs.length;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final long getEventTime(int i) {
+        Assertions.checkArgument(i >= 0);
+        Assertions.checkArgument(i < this.cueTimesUs.length);
+        return this.cueTimesUs[i];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final List<Cue> getCues(long j) {
+        Cue cue;
+        int binarySearchFloor = Util.binarySearchFloor(this.cueTimesUs, j, true, false);
+        if (binarySearchFloor == -1 || (cue = this.cues[binarySearchFloor]) == null) {
+            return Collections.emptyList();
+        }
+        return Collections.singletonList(cue);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/ttml/TtmlDecoder.java

@@ -0,0 +1,423 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.ttml;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderException;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import com.mbridge.msdk.playercommon.exoplayer2.util.XmlPullParserUtil;
+import csdk.gluads.Consts;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+
+/* loaded from: classes4.dex */
+public final class TtmlDecoder extends SimpleSubtitleDecoder {
+    private static final String ATTR_BEGIN = "begin";
+    private static final String ATTR_DURATION = "dur";
+    private static final String ATTR_END = "end";
+    private static final String ATTR_REGION = "region";
+    private static final String ATTR_STYLE = "style";
+    private static final int DEFAULT_FRAME_RATE = 30;
+    private static final String TAG = "TtmlDecoder";
+    private static final String TTP = "http://www.w3.org/ns/ttml#parameter";
+    private final XmlPullParserFactory xmlParserFactory;
+    private static final Pattern CLOCK_TIME = Pattern.compile("^([0-9][0-9]+):([0-9][0-9]):([0-9][0-9])(?:(\\.[0-9]+)|:([0-9][0-9])(?:\\.([0-9]+))?)?$");
+    private static final Pattern OFFSET_TIME = Pattern.compile("^([0-9]+(?:\\.[0-9]+)?)(h|m|s|ms|f|t)$");
+    private static final Pattern FONT_SIZE = Pattern.compile("^(([0-9]*.)?[0-9]+)(px|em|%)$");
+    private static final Pattern PERCENTAGE_COORDINATES = Pattern.compile("^(\\d+\\.?\\d*?)% (\\d+\\.?\\d*?)%$");
+    private static final Pattern CELL_RESOLUTION = Pattern.compile("^(\\d+) (\\d+)$");
+    private static final FrameAndTickRate DEFAULT_FRAME_AND_TICK_RATE = new FrameAndTickRate(30.0f, 1, 1);
+    private static final CellResolution DEFAULT_CELL_RESOLUTION = new CellResolution(32, 15);
+
+    public TtmlDecoder() {
+        super(TAG);
+        try {
+            XmlPullParserFactory newInstance = XmlPullParserFactory.newInstance();
+            this.xmlParserFactory = newInstance;
+            newInstance.setNamespaceAware(true);
+        } catch (XmlPullParserException e) {
+            throw new RuntimeException("Couldn't create XmlPullParserFactory instance", e);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder
+    public final TtmlSubtitle decode(byte[] bArr, int i, boolean z) throws SubtitleDecoderException {
+        try {
+            XmlPullParser newPullParser = this.xmlParserFactory.newPullParser();
+            HashMap hashMap = new HashMap();
+            HashMap hashMap2 = new HashMap();
+            TtmlSubtitle ttmlSubtitle = null;
+            hashMap2.put("", new TtmlRegion(null));
+            int i2 = 0;
+            newPullParser.setInput(new ByteArrayInputStream(bArr, 0, i), null);
+            ArrayDeque arrayDeque = new ArrayDeque();
+            FrameAndTickRate frameAndTickRate = DEFAULT_FRAME_AND_TICK_RATE;
+            CellResolution cellResolution = DEFAULT_CELL_RESOLUTION;
+            for (int eventType = newPullParser.getEventType(); eventType != 1; eventType = newPullParser.getEventType()) {
+                TtmlNode ttmlNode = (TtmlNode) arrayDeque.peek();
+                if (i2 == 0) {
+                    String name = newPullParser.getName();
+                    if (eventType == 2) {
+                        if (TtmlNode.TAG_TT.equals(name)) {
+                            frameAndTickRate = parseFrameAndTickRates(newPullParser);
+                            cellResolution = parseCellResolution(newPullParser, DEFAULT_CELL_RESOLUTION);
+                        }
+                        if (!isSupportedTag(name)) {
+                            StringBuilder sb = new StringBuilder();
+                            sb.append("Ignoring unsupported tag: ");
+                            sb.append(newPullParser.getName());
+                        } else if (TtmlNode.TAG_HEAD.equals(name)) {
+                            parseHeader(newPullParser, hashMap, hashMap2, cellResolution);
+                        } else {
+                            try {
+                                TtmlNode parseNode = parseNode(newPullParser, ttmlNode, hashMap2, frameAndTickRate);
+                                arrayDeque.push(parseNode);
+                                if (ttmlNode != null) {
+                                    ttmlNode.addChild(parseNode);
+                                }
+                            } catch (SubtitleDecoderException e) {
+                                Log.w(TAG, "Suppressing parser error", e);
+                            }
+                        }
+                        i2++;
+                    } else if (eventType == 4) {
+                        ttmlNode.addChild(TtmlNode.buildTextNode(newPullParser.getText()));
+                    } else if (eventType == 3) {
+                        if (newPullParser.getName().equals(TtmlNode.TAG_TT)) {
+                            ttmlSubtitle = new TtmlSubtitle((TtmlNode) arrayDeque.peek(), hashMap, hashMap2);
+                        }
+                        arrayDeque.pop();
+                    }
+                } else {
+                    if (eventType != 2) {
+                        if (eventType == 3) {
+                            i2--;
+                        }
+                    }
+                    i2++;
+                }
+                newPullParser.next();
+            }
+            return ttmlSubtitle;
+        } catch (IOException e2) {
+            throw new IllegalStateException("Unexpected error when reading input.", e2);
+        } catch (XmlPullParserException e3) {
+            throw new SubtitleDecoderException("Unable to decode source", e3);
+        }
+    }
+
+    private FrameAndTickRate parseFrameAndTickRates(XmlPullParser xmlPullParser) throws SubtitleDecoderException {
+        float f;
+        String attributeValue = xmlPullParser.getAttributeValue(TTP, "frameRate");
+        int parseInt = attributeValue != null ? Integer.parseInt(attributeValue) : 30;
+        String attributeValue2 = xmlPullParser.getAttributeValue(TTP, "frameRateMultiplier");
+        if (attributeValue2 != null) {
+            if (Util.split(attributeValue2, " ").length != 2) {
+                throw new SubtitleDecoderException("frameRateMultiplier doesn't have 2 parts");
+            }
+            f = Integer.parseInt(r2[0]) / Integer.parseInt(r2[1]);
+        } else {
+            f = 1.0f;
+        }
+        FrameAndTickRate frameAndTickRate = DEFAULT_FRAME_AND_TICK_RATE;
+        int i = frameAndTickRate.subFrameRate;
+        String attributeValue3 = xmlPullParser.getAttributeValue(TTP, "subFrameRate");
+        if (attributeValue3 != null) {
+            i = Integer.parseInt(attributeValue3);
+        }
+        int i2 = frameAndTickRate.tickRate;
+        String attributeValue4 = xmlPullParser.getAttributeValue(TTP, "tickRate");
+        if (attributeValue4 != null) {
+            i2 = Integer.parseInt(attributeValue4);
+        }
+        return new FrameAndTickRate(parseInt * f, i, i2);
+    }
+
+    private CellResolution parseCellResolution(XmlPullParser xmlPullParser, CellResolution cellResolution) throws SubtitleDecoderException {
+        String attributeValue = xmlPullParser.getAttributeValue(TTP, "cellResolution");
+        if (attributeValue == null) {
+            return cellResolution;
+        }
+        Matcher matcher = CELL_RESOLUTION.matcher(attributeValue);
+        if (!matcher.matches()) {
+            Log.w(TAG, "Ignoring malformed cell resolution: " + attributeValue);
+            return cellResolution;
+        }
+        try {
+            int parseInt = Integer.parseInt(matcher.group(1));
+            int parseInt2 = Integer.parseInt(matcher.group(2));
+            if (parseInt == 0 || parseInt2 == 0) {
+                throw new SubtitleDecoderException("Invalid cell resolution " + parseInt + " " + parseInt2);
+            }
+            return new CellResolution(parseInt, parseInt2);
+        } catch (NumberFormatException unused) {
+            Log.w(TAG, "Ignoring malformed cell resolution: " + attributeValue);
+            return cellResolution;
+        }
+    }
+
+    private Map<String, TtmlStyle> parseHeader(XmlPullParser xmlPullParser, Map<String, TtmlStyle> map, Map<String, TtmlRegion> map2, CellResolution cellResolution) throws IOException, XmlPullParserException {
+        TtmlRegion parseRegionAttributes;
+        do {
+            xmlPullParser.next();
+            if (XmlPullParserUtil.isStartTag(xmlPullParser, "style")) {
+                String attributeValue = XmlPullParserUtil.getAttributeValue(xmlPullParser, "style");
+                TtmlStyle parseStyleAttributes = parseStyleAttributes(xmlPullParser, new TtmlStyle());
+                if (attributeValue != null) {
+                    for (String str : parseStyleIds(attributeValue)) {
+                        parseStyleAttributes.chain(map.get(str));
+                    }
+                }
+                if (parseStyleAttributes.getId() != null) {
+                    map.put(parseStyleAttributes.getId(), parseStyleAttributes);
+                }
+            } else if (XmlPullParserUtil.isStartTag(xmlPullParser, "region") && (parseRegionAttributes = parseRegionAttributes(xmlPullParser, cellResolution)) != null) {
+                map2.put(parseRegionAttributes.id, parseRegionAttributes);
+            }
+        } while (!XmlPullParserUtil.isEndTag(xmlPullParser, TtmlNode.TAG_HEAD));
+        return map;
+    }
+
+    private TtmlRegion parseRegionAttributes(XmlPullParser xmlPullParser, CellResolution cellResolution) {
+        float f;
+        String attributeValue = XmlPullParserUtil.getAttributeValue(xmlPullParser, "id");
+        if (attributeValue == null) {
+            return null;
+        }
+        String attributeValue2 = XmlPullParserUtil.getAttributeValue(xmlPullParser, "origin");
+        if (attributeValue2 != null) {
+            Pattern pattern = PERCENTAGE_COORDINATES;
+            Matcher matcher = pattern.matcher(attributeValue2);
+            if (matcher.matches()) {
+                int i = 1;
+                try {
+                    float parseFloat = Float.parseFloat(matcher.group(1)) / 100.0f;
+                    float parseFloat2 = Float.parseFloat(matcher.group(2)) / 100.0f;
+                    String attributeValue3 = XmlPullParserUtil.getAttributeValue(xmlPullParser, TtmlNode.ATTR_TTS_EXTENT);
+                    if (attributeValue3 != null) {
+                        Matcher matcher2 = pattern.matcher(attributeValue3);
+                        if (matcher2.matches()) {
+                            try {
+                                float parseFloat3 = Float.parseFloat(matcher2.group(1)) / 100.0f;
+                                float parseFloat4 = Float.parseFloat(matcher2.group(2)) / 100.0f;
+                                String attributeValue4 = XmlPullParserUtil.getAttributeValue(xmlPullParser, TtmlNode.ATTR_TTS_DISPLAY_ALIGN);
+                                if (attributeValue4 != null) {
+                                    String lowerInvariant = Util.toLowerInvariant(attributeValue4);
+                                    lowerInvariant.hashCode();
+                                    if (lowerInvariant.equals("center")) {
+                                        parseFloat2 += parseFloat4 / 2.0f;
+                                        f = parseFloat2;
+                                        return new TtmlRegion(attributeValue, parseFloat, f, 0, i, parseFloat3, 1, 1.0f / cellResolution.rows);
+                                    }
+                                    if (lowerInvariant.equals("after")) {
+                                        f = parseFloat2 + parseFloat4;
+                                        i = 2;
+                                        return new TtmlRegion(attributeValue, parseFloat, f, 0, i, parseFloat3, 1, 1.0f / cellResolution.rows);
+                                    }
+                                }
+                                i = 0;
+                                f = parseFloat2;
+                                return new TtmlRegion(attributeValue, parseFloat, f, 0, i, parseFloat3, 1, 1.0f / cellResolution.rows);
+                            } catch (NumberFormatException unused) {
+                                Log.w(TAG, "Ignoring region with malformed extent: " + attributeValue2);
+                                return null;
+                            }
+                        }
+                        Log.w(TAG, "Ignoring region with unsupported extent: " + attributeValue2);
+                        return null;
+                    }
+                    Log.w(TAG, "Ignoring region without an extent");
+                    return null;
+                } catch (NumberFormatException unused2) {
+                    Log.w(TAG, "Ignoring region with malformed origin: " + attributeValue2);
+                    return null;
+                }
+            }
+            Log.w(TAG, "Ignoring region with unsupported origin: " + attributeValue2);
+            return null;
+        }
+        Log.w(TAG, "Ignoring region without an origin");
+        return null;
+    }
+
+    private String[] parseStyleIds(String str) {
+        String trim = str.trim();
+        return trim.isEmpty() ? new String[0] : Util.split(trim, "\\s+");
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    /* JADX WARN: Code restructure failed: missing block: B:44:0x012e, code lost:
+    
+        if (r3.equals(com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlNode.LINETHROUGH) == false) goto L63;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:70:0x0194, code lost:
+    
+        if (r3.equals("start") == false) goto L87;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlStyle parseStyleAttributes(org.xmlpull.v1.XmlPullParser r12, com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlStyle r13) {
+        /*
+            Method dump skipped, instructions count: 664
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlDecoder.parseStyleAttributes(org.xmlpull.v1.XmlPullParser, com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlStyle):com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlStyle");
+    }
+
+    private TtmlStyle createIfNull(TtmlStyle ttmlStyle) {
+        return ttmlStyle == null ? new TtmlStyle() : ttmlStyle;
+    }
+
+    private TtmlNode parseNode(XmlPullParser xmlPullParser, TtmlNode ttmlNode, Map<String, TtmlRegion> map, FrameAndTickRate frameAndTickRate) throws SubtitleDecoderException {
+        long j;
+        String attributeValue;
+        int attributeCount = xmlPullParser.getAttributeCount();
+        TtmlStyle parseStyleAttributes = parseStyleAttributes(xmlPullParser, null);
+        String[] strArr = null;
+        long j2 = -9223372036854775807L;
+        long j3 = -9223372036854775807L;
+        long j4 = -9223372036854775807L;
+        String str = "";
+        for (int i = 0; i < attributeCount; i++) {
+            String attributeName = xmlPullParser.getAttributeName(i);
+            attributeValue = xmlPullParser.getAttributeValue(i);
+            attributeName.hashCode();
+            switch (attributeName) {
+                case "region":
+                    if (!map.containsKey(attributeValue)) {
+                        break;
+                    } else {
+                        str = attributeValue;
+                        continue;
+                    }
+                case "dur":
+                    j4 = parseTimeExpression(attributeValue, frameAndTickRate);
+                    break;
+                case "end":
+                    j3 = parseTimeExpression(attributeValue, frameAndTickRate);
+                    break;
+                case "begin":
+                    j2 = parseTimeExpression(attributeValue, frameAndTickRate);
+                    break;
+                case "style":
+                    String[] parseStyleIds = parseStyleIds(attributeValue);
+                    if (parseStyleIds.length > 0) {
+                        strArr = parseStyleIds;
+                        break;
+                    }
+                    break;
+            }
+        }
+        if (ttmlNode != null) {
+            long j5 = ttmlNode.startTimeUs;
+            if (j5 != C.TIME_UNSET) {
+                if (j2 != C.TIME_UNSET) {
+                    j2 += j5;
+                }
+                if (j3 != C.TIME_UNSET) {
+                    j3 += j5;
+                }
+            }
+        }
+        if (j3 == C.TIME_UNSET) {
+            if (j4 != C.TIME_UNSET) {
+                j = j2 + j4;
+            } else if (ttmlNode != null) {
+                long j6 = ttmlNode.endTimeUs;
+                if (j6 != C.TIME_UNSET) {
+                    j = j6;
+                }
+            }
+            return TtmlNode.buildNode(xmlPullParser.getName(), j2, j, parseStyleAttributes, strArr, str);
+        }
+        j = j3;
+        return TtmlNode.buildNode(xmlPullParser.getName(), j2, j, parseStyleAttributes, strArr, str);
+    }
+
+    private static boolean isSupportedTag(String str) {
+        return str.equals(TtmlNode.TAG_TT) || str.equals(TtmlNode.TAG_HEAD) || str.equals("body") || str.equals(TtmlNode.TAG_DIV) || str.equals(TtmlNode.TAG_P) || str.equals(TtmlNode.TAG_SPAN) || str.equals(TtmlNode.TAG_BR) || str.equals("style") || str.equals(TtmlNode.TAG_STYLING) || str.equals(TtmlNode.TAG_LAYOUT) || str.equals("region") || str.equals("metadata") || str.equals(TtmlNode.TAG_SMPTE_IMAGE) || str.equals(TtmlNode.TAG_SMPTE_DATA) || str.equals(TtmlNode.TAG_SMPTE_INFORMATION);
+    }
+
+    private static void parseFontSize(String str, TtmlStyle ttmlStyle) throws SubtitleDecoderException {
+        Matcher matcher;
+        String group;
+        String[] split = Util.split(str, "\\s+");
+        if (split.length == 1) {
+            matcher = FONT_SIZE.matcher(str);
+        } else if (split.length == 2) {
+            matcher = FONT_SIZE.matcher(split[1]);
+            Log.w(TAG, "Multiple values in fontSize attribute. Picking the second value for vertical font size and ignoring the first.");
+        } else {
+            throw new SubtitleDecoderException("Invalid number of entries for fontSize: " + split.length + Consts.STRING_PERIOD);
+        }
+        if (matcher.matches()) {
+            group = matcher.group(3);
+            group.hashCode();
+            switch (group) {
+                case "%":
+                    ttmlStyle.setFontSizeUnit(3);
+                    break;
+                case "em":
+                    ttmlStyle.setFontSizeUnit(2);
+                    break;
+                case "px":
+                    ttmlStyle.setFontSizeUnit(1);
+                    break;
+                default:
+                    throw new SubtitleDecoderException("Invalid unit for fontSize: '" + group + "'.");
+            }
+            ttmlStyle.setFontSize(Float.valueOf(matcher.group(1)).floatValue());
+            return;
+        }
+        throw new SubtitleDecoderException("Invalid expression for fontSize: '" + str + "'.");
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    /* JADX WARN: Code restructure failed: missing block: B:33:0x009e, code lost:
+    
+        if (r13.equals("ms") == false) goto L21;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static long parseTimeExpression(java.lang.String r13, com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlDecoder.FrameAndTickRate r14) throws com.mbridge.msdk.playercommon.exoplayer2.text.SubtitleDecoderException {
+        /*
+            Method dump skipped, instructions count: 296
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlDecoder.parseTimeExpression(java.lang.String, com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlDecoder$FrameAndTickRate):long");
+    }
+
+    public static final class FrameAndTickRate {
+        final float effectiveFrameRate;
+        final int subFrameRate;
+        final int tickRate;
+
+        public FrameAndTickRate(float f, int i, int i2) {
+            this.effectiveFrameRate = f;
+            this.subFrameRate = i;
+            this.tickRate = i2;
+        }
+    }
+
+    public static final class CellResolution {
+        final int columns;
+        final int rows;
+
+        public CellResolution(int i, int i2) {
+            this.columns = i;
+            this.rows = i2;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/ttml/TtmlNode.java

@@ -0,0 +1,299 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.ttml;
+
+import android.text.Layout;
+import android.text.SpannableStringBuilder;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+/* loaded from: classes4.dex */
+final class TtmlNode {
+    public static final String ANONYMOUS_REGION_ID = "";
+    public static final String ATTR_ID = "id";
+    public static final String ATTR_TTS_BACKGROUND_COLOR = "backgroundColor";
+    public static final String ATTR_TTS_COLOR = "color";
+    public static final String ATTR_TTS_DISPLAY_ALIGN = "displayAlign";
+    public static final String ATTR_TTS_EXTENT = "extent";
+    public static final String ATTR_TTS_FONT_FAMILY = "fontFamily";
+    public static final String ATTR_TTS_FONT_SIZE = "fontSize";
+    public static final String ATTR_TTS_FONT_STYLE = "fontStyle";
+    public static final String ATTR_TTS_FONT_WEIGHT = "fontWeight";
+    public static final String ATTR_TTS_ORIGIN = "origin";
+    public static final String ATTR_TTS_TEXT_ALIGN = "textAlign";
+    public static final String ATTR_TTS_TEXT_DECORATION = "textDecoration";
+    public static final String BOLD = "bold";
+    public static final String CENTER = "center";
+    public static final String END = "end";
+    public static final String ITALIC = "italic";
+    public static final String LEFT = "left";
+    public static final String LINETHROUGH = "linethrough";
+    public static final String NO_LINETHROUGH = "nolinethrough";
+    public static final String NO_UNDERLINE = "nounderline";
+    public static final String RIGHT = "right";
+    public static final String START = "start";
+    public static final String TAG_BODY = "body";
+    public static final String TAG_BR = "br";
+    public static final String TAG_DIV = "div";
+    public static final String TAG_HEAD = "head";
+    public static final String TAG_LAYOUT = "layout";
+    public static final String TAG_METADATA = "metadata";
+    public static final String TAG_P = "p";
+    public static final String TAG_REGION = "region";
+    public static final String TAG_SMPTE_DATA = "smpte:data";
+    public static final String TAG_SMPTE_IMAGE = "smpte:image";
+    public static final String TAG_SMPTE_INFORMATION = "smpte:information";
+    public static final String TAG_SPAN = "span";
+    public static final String TAG_STYLE = "style";
+    public static final String TAG_STYLING = "styling";
+    public static final String TAG_TT = "tt";
+    public static final String UNDERLINE = "underline";
+    private List<TtmlNode> children;
+    public final long endTimeUs;
+    public final boolean isTextNode;
+    private final HashMap<String, Integer> nodeEndsByRegion;
+    private final HashMap<String, Integer> nodeStartsByRegion;
+    public final String regionId;
+    public final long startTimeUs;
+    public final TtmlStyle style;
+    private final String[] styleIds;
+    public final String tag;
+    public final String text;
+
+    public final String[] getStyleIds() {
+        return this.styleIds;
+    }
+
+    public final boolean isActive(long j) {
+        long j2 = this.startTimeUs;
+        return (j2 == C.TIME_UNSET && this.endTimeUs == C.TIME_UNSET) || (j2 <= j && this.endTimeUs == C.TIME_UNSET) || ((j2 == C.TIME_UNSET && j < this.endTimeUs) || (j2 <= j && j < this.endTimeUs));
+    }
+
+    public static TtmlNode buildTextNode(String str) {
+        return new TtmlNode(null, TtmlRenderUtil.applyTextElementSpacePolicy(str), C.TIME_UNSET, C.TIME_UNSET, null, null, "");
+    }
+
+    public static TtmlNode buildNode(String str, long j, long j2, TtmlStyle ttmlStyle, String[] strArr, String str2) {
+        return new TtmlNode(str, null, j, j2, ttmlStyle, strArr, str2);
+    }
+
+    private TtmlNode(String str, String str2, long j, long j2, TtmlStyle ttmlStyle, String[] strArr, String str3) {
+        this.tag = str;
+        this.text = str2;
+        this.style = ttmlStyle;
+        this.styleIds = strArr;
+        this.isTextNode = str2 != null;
+        this.startTimeUs = j;
+        this.endTimeUs = j2;
+        this.regionId = (String) Assertions.checkNotNull(str3);
+        this.nodeStartsByRegion = new HashMap<>();
+        this.nodeEndsByRegion = new HashMap<>();
+    }
+
+    public final void addChild(TtmlNode ttmlNode) {
+        if (this.children == null) {
+            this.children = new ArrayList();
+        }
+        this.children.add(ttmlNode);
+    }
+
+    public final TtmlNode getChild(int i) {
+        List<TtmlNode> list = this.children;
+        if (list == null) {
+            throw new IndexOutOfBoundsException();
+        }
+        return list.get(i);
+    }
+
+    public final int getChildCount() {
+        List<TtmlNode> list = this.children;
+        if (list == null) {
+            return 0;
+        }
+        return list.size();
+    }
+
+    public final long[] getEventTimesUs() {
+        TreeSet<Long> treeSet = new TreeSet<>();
+        int i = 0;
+        getEventTimes(treeSet, false);
+        long[] jArr = new long[treeSet.size()];
+        Iterator<Long> it = treeSet.iterator();
+        while (it.hasNext()) {
+            jArr[i] = it.next().longValue();
+            i++;
+        }
+        return jArr;
+    }
+
+    private void getEventTimes(TreeSet<Long> treeSet, boolean z) {
+        boolean equals = TAG_P.equals(this.tag);
+        if (z || equals) {
+            long j = this.startTimeUs;
+            if (j != C.TIME_UNSET) {
+                treeSet.add(Long.valueOf(j));
+            }
+            long j2 = this.endTimeUs;
+            if (j2 != C.TIME_UNSET) {
+                treeSet.add(Long.valueOf(j2));
+            }
+        }
+        if (this.children == null) {
+            return;
+        }
+        for (int i = 0; i < this.children.size(); i++) {
+            this.children.get(i).getEventTimes(treeSet, z || equals);
+        }
+    }
+
+    public final List<Cue> getCues(long j, Map<String, TtmlStyle> map, Map<String, TtmlRegion> map2) {
+        TreeMap treeMap = new TreeMap();
+        traverseForText(j, false, this.regionId, treeMap);
+        traverseForStyle(j, map, treeMap);
+        ArrayList arrayList = new ArrayList();
+        for (Map.Entry entry : treeMap.entrySet()) {
+            TtmlRegion ttmlRegion = map2.get(entry.getKey());
+            arrayList.add(new Cue(cleanUpText((SpannableStringBuilder) entry.getValue()), (Layout.Alignment) null, ttmlRegion.line, ttmlRegion.lineType, ttmlRegion.lineAnchor, ttmlRegion.position, Integer.MIN_VALUE, ttmlRegion.width, ttmlRegion.textSizeType, ttmlRegion.textSize));
+        }
+        return arrayList;
+    }
+
+    private void traverseForText(long j, boolean z, String str, Map<String, SpannableStringBuilder> map) {
+        this.nodeStartsByRegion.clear();
+        this.nodeEndsByRegion.clear();
+        if ("metadata".equals(this.tag)) {
+            return;
+        }
+        if (!"".equals(this.regionId)) {
+            str = this.regionId;
+        }
+        if (this.isTextNode && z) {
+            getRegionOutput(str, map).append((CharSequence) this.text);
+            return;
+        }
+        if (TAG_BR.equals(this.tag) && z) {
+            getRegionOutput(str, map).append('\n');
+            return;
+        }
+        if (isActive(j)) {
+            for (Map.Entry<String, SpannableStringBuilder> entry : map.entrySet()) {
+                this.nodeStartsByRegion.put(entry.getKey(), Integer.valueOf(entry.getValue().length()));
+            }
+            boolean equals = TAG_P.equals(this.tag);
+            for (int i = 0; i < getChildCount(); i++) {
+                getChild(i).traverseForText(j, z || equals, str, map);
+            }
+            if (equals) {
+                TtmlRenderUtil.endParagraph(getRegionOutput(str, map));
+            }
+            for (Map.Entry<String, SpannableStringBuilder> entry2 : map.entrySet()) {
+                this.nodeEndsByRegion.put(entry2.getKey(), Integer.valueOf(entry2.getValue().length()));
+            }
+        }
+    }
+
+    private static SpannableStringBuilder getRegionOutput(String str, Map<String, SpannableStringBuilder> map) {
+        if (!map.containsKey(str)) {
+            map.put(str, new SpannableStringBuilder());
+        }
+        return map.get(str);
+    }
+
+    private void traverseForStyle(long j, Map<String, TtmlStyle> map, Map<String, SpannableStringBuilder> map2) {
+        int i;
+        if (isActive(j)) {
+            Iterator<Map.Entry<String, Integer>> it = this.nodeEndsByRegion.entrySet().iterator();
+            while (true) {
+                if (!it.hasNext()) {
+                    break;
+                }
+                Map.Entry<String, Integer> next = it.next();
+                String key = next.getKey();
+                i = this.nodeStartsByRegion.containsKey(key) ? this.nodeStartsByRegion.get(key).intValue() : 0;
+                int intValue = next.getValue().intValue();
+                if (i != intValue) {
+                    applyStyleToOutput(map, map2.get(key), i, intValue);
+                }
+            }
+            while (i < getChildCount()) {
+                getChild(i).traverseForStyle(j, map, map2);
+                i++;
+            }
+        }
+    }
+
+    private void applyStyleToOutput(Map<String, TtmlStyle> map, SpannableStringBuilder spannableStringBuilder, int i, int i2) {
+        TtmlStyle resolveStyle = TtmlRenderUtil.resolveStyle(this.style, this.styleIds, map);
+        if (resolveStyle != null) {
+            TtmlRenderUtil.applyStylesToSpan(spannableStringBuilder, i, i2, resolveStyle);
+        }
+    }
+
+    private SpannableStringBuilder cleanUpText(SpannableStringBuilder spannableStringBuilder) {
+        int i;
+        int i2;
+        int length = spannableStringBuilder.length();
+        int i3 = 0;
+        for (int i4 = 0; i4 < length; i4++) {
+            if (spannableStringBuilder.charAt(i4) == ' ') {
+                int i5 = i4 + 1;
+                int i6 = i5;
+                while (i6 < spannableStringBuilder.length() && spannableStringBuilder.charAt(i6) == ' ') {
+                    i6++;
+                }
+                int i7 = i6 - i5;
+                if (i7 > 0) {
+                    spannableStringBuilder.delete(i4, i4 + i7);
+                    length -= i7;
+                }
+            }
+        }
+        if (length > 0 && spannableStringBuilder.charAt(0) == ' ') {
+            spannableStringBuilder.delete(0, 1);
+            length--;
+        }
+        int i8 = 0;
+        while (true) {
+            i = length - 1;
+            if (i8 >= i) {
+                break;
+            }
+            if (spannableStringBuilder.charAt(i8) == '\n') {
+                int i9 = i8 + 1;
+                if (spannableStringBuilder.charAt(i9) == ' ') {
+                    spannableStringBuilder.delete(i9, i8 + 2);
+                    length--;
+                }
+            }
+            i8++;
+        }
+        if (length > 0 && spannableStringBuilder.charAt(i) == ' ') {
+            spannableStringBuilder.delete(i, length);
+            length--;
+        }
+        while (true) {
+            i2 = length - 1;
+            if (i3 >= i2) {
+                break;
+            }
+            if (spannableStringBuilder.charAt(i3) == ' ') {
+                int i10 = i3 + 1;
+                if (spannableStringBuilder.charAt(i10) == '\n') {
+                    spannableStringBuilder.delete(i3, i10);
+                    length--;
+                }
+            }
+            i3++;
+        }
+        if (length > 0 && spannableStringBuilder.charAt(i2) == '\n') {
+            spannableStringBuilder.delete(i2, length);
+        }
+        return spannableStringBuilder;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/ttml/TtmlRegion.java

@@ -0,0 +1,28 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.ttml;
+
+/* loaded from: classes4.dex */
+final class TtmlRegion {
+    public final String id;
+    public final float line;
+    public final int lineAnchor;
+    public final int lineType;
+    public final float position;
+    public final float textSize;
+    public final int textSizeType;
+    public final float width;
+
+    public TtmlRegion(String str) {
+        this(str, Float.MIN_VALUE, Float.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE, Float.MIN_VALUE, Integer.MIN_VALUE, Float.MIN_VALUE);
+    }
+
+    public TtmlRegion(String str, float f, float f2, int i, int i2, float f3, int i3, float f4) {
+        this.id = str;
+        this.position = f;
+        this.line = f2;
+        this.lineType = i;
+        this.lineAnchor = i2;
+        this.width = f3;
+        this.textSizeType = i3;
+        this.textSize = f4;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/ttml/TtmlRenderUtil.java

@@ -0,0 +1,99 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.ttml;
+
+import android.text.SpannableStringBuilder;
+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 java.util.Map;
+
+/* loaded from: classes4.dex */
+final class TtmlRenderUtil {
+    private TtmlRenderUtil() {
+    }
+
+    public static TtmlStyle resolveStyle(TtmlStyle ttmlStyle, String[] strArr, Map<String, TtmlStyle> map) {
+        if (ttmlStyle == null && strArr == null) {
+            return null;
+        }
+        int i = 0;
+        if (ttmlStyle == null && strArr.length == 1) {
+            return map.get(strArr[0]);
+        }
+        if (ttmlStyle == null && strArr.length > 1) {
+            TtmlStyle ttmlStyle2 = new TtmlStyle();
+            int length = strArr.length;
+            while (i < length) {
+                ttmlStyle2.chain(map.get(strArr[i]));
+                i++;
+            }
+            return ttmlStyle2;
+        }
+        if (ttmlStyle != null && strArr != null && strArr.length == 1) {
+            return ttmlStyle.chain(map.get(strArr[0]));
+        }
+        if (ttmlStyle != null && strArr != null && strArr.length > 1) {
+            int length2 = strArr.length;
+            while (i < length2) {
+                ttmlStyle.chain(map.get(strArr[i]));
+                i++;
+            }
+        }
+        return ttmlStyle;
+    }
+
+    public static void applyStylesToSpan(SpannableStringBuilder spannableStringBuilder, int i, int i2, TtmlStyle ttmlStyle) {
+        if (ttmlStyle.getStyle() != -1) {
+            spannableStringBuilder.setSpan(new StyleSpan(ttmlStyle.getStyle()), i, i2, 33);
+        }
+        if (ttmlStyle.isLinethrough()) {
+            spannableStringBuilder.setSpan(new StrikethroughSpan(), i, i2, 33);
+        }
+        if (ttmlStyle.isUnderline()) {
+            spannableStringBuilder.setSpan(new UnderlineSpan(), i, i2, 33);
+        }
+        if (ttmlStyle.hasFontColor()) {
+            spannableStringBuilder.setSpan(new ForegroundColorSpan(ttmlStyle.getFontColor()), i, i2, 33);
+        }
+        if (ttmlStyle.hasBackgroundColor()) {
+            spannableStringBuilder.setSpan(new BackgroundColorSpan(ttmlStyle.getBackgroundColor()), i, i2, 33);
+        }
+        if (ttmlStyle.getFontFamily() != null) {
+            spannableStringBuilder.setSpan(new TypefaceSpan(ttmlStyle.getFontFamily()), i, i2, 33);
+        }
+        if (ttmlStyle.getTextAlign() != null) {
+            spannableStringBuilder.setSpan(new AlignmentSpan.Standard(ttmlStyle.getTextAlign()), i, i2, 33);
+        }
+        int fontSizeUnit = ttmlStyle.getFontSizeUnit();
+        if (fontSizeUnit == 1) {
+            spannableStringBuilder.setSpan(new AbsoluteSizeSpan((int) ttmlStyle.getFontSize(), true), i, i2, 33);
+        } else if (fontSizeUnit == 2) {
+            spannableStringBuilder.setSpan(new RelativeSizeSpan(ttmlStyle.getFontSize()), i, i2, 33);
+        } else {
+            if (fontSizeUnit != 3) {
+                return;
+            }
+            spannableStringBuilder.setSpan(new RelativeSizeSpan(ttmlStyle.getFontSize() / 100.0f), i, i2, 33);
+        }
+    }
+
+    public static void endParagraph(SpannableStringBuilder spannableStringBuilder) {
+        int length = spannableStringBuilder.length() - 1;
+        while (length >= 0 && spannableStringBuilder.charAt(length) == ' ') {
+            length--;
+        }
+        if (length < 0 || spannableStringBuilder.charAt(length) == '\n') {
+            return;
+        }
+        spannableStringBuilder.append('\n');
+    }
+
+    public static String applyTextElementSpacePolicy(String str) {
+        return str.replaceAll("\r\n", "\n").replaceAll(" *\n *", "\n").replaceAll("\n", " ").replaceAll("[ \t\\x0B\f\r]+", " ");
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/ttml/TtmlStyle.java

@@ -0,0 +1,209 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.ttml;
+
+import android.text.Layout;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+final class TtmlStyle {
+    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 fontColor;
+    private String fontFamily;
+    private float fontSize;
+    private boolean hasBackgroundColor;
+    private boolean hasFontColor;
+    private String id;
+    private TtmlStyle inheritableStyle;
+    private Layout.Alignment textAlign;
+    private int linethrough = -1;
+    private int underline = -1;
+    private int bold = -1;
+    private int italic = -1;
+    private int fontSizeUnit = -1;
+
+    @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 String getId() {
+        return this.id;
+    }
+
+    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 TtmlStyle setBackgroundColor(int i) {
+        this.backgroundColor = i;
+        this.hasBackgroundColor = true;
+        return this;
+    }
+
+    public final TtmlStyle setFontSize(float f) {
+        this.fontSize = f;
+        return this;
+    }
+
+    public final TtmlStyle setFontSizeUnit(int i) {
+        this.fontSizeUnit = i;
+        return this;
+    }
+
+    public final TtmlStyle setId(String str) {
+        this.id = str;
+        return this;
+    }
+
+    public final TtmlStyle setTextAlign(Layout.Alignment alignment) {
+        this.textAlign = alignment;
+        return this;
+    }
+
+    public final TtmlStyle setLinethrough(boolean z) {
+        Assertions.checkState(this.inheritableStyle == null);
+        this.linethrough = z ? 1 : 0;
+        return this;
+    }
+
+    public final TtmlStyle setUnderline(boolean z) {
+        Assertions.checkState(this.inheritableStyle == null);
+        this.underline = z ? 1 : 0;
+        return this;
+    }
+
+    public final TtmlStyle setBold(boolean z) {
+        Assertions.checkState(this.inheritableStyle == null);
+        this.bold = z ? 1 : 0;
+        return this;
+    }
+
+    public final TtmlStyle setItalic(boolean z) {
+        Assertions.checkState(this.inheritableStyle == null);
+        this.italic = z ? 1 : 0;
+        return this;
+    }
+
+    public final TtmlStyle setFontFamily(String str) {
+        Assertions.checkState(this.inheritableStyle == null);
+        this.fontFamily = str;
+        return this;
+    }
+
+    public final int getFontColor() {
+        if (this.hasFontColor) {
+            return this.fontColor;
+        }
+        throw new IllegalStateException("Font color has not been defined.");
+    }
+
+    public final TtmlStyle setFontColor(int i) {
+        Assertions.checkState(this.inheritableStyle == null);
+        this.fontColor = i;
+        this.hasFontColor = true;
+        return this;
+    }
+
+    public final int getBackgroundColor() {
+        if (this.hasBackgroundColor) {
+            return this.backgroundColor;
+        }
+        throw new IllegalStateException("Background color has not been defined.");
+    }
+
+    public final TtmlStyle inherit(TtmlStyle ttmlStyle) {
+        return inherit(ttmlStyle, false);
+    }
+
+    public final TtmlStyle chain(TtmlStyle ttmlStyle) {
+        return inherit(ttmlStyle, true);
+    }
+
+    private TtmlStyle inherit(TtmlStyle ttmlStyle, boolean z) {
+        if (ttmlStyle != null) {
+            if (!this.hasFontColor && ttmlStyle.hasFontColor) {
+                setFontColor(ttmlStyle.fontColor);
+            }
+            if (this.bold == -1) {
+                this.bold = ttmlStyle.bold;
+            }
+            if (this.italic == -1) {
+                this.italic = ttmlStyle.italic;
+            }
+            if (this.fontFamily == null) {
+                this.fontFamily = ttmlStyle.fontFamily;
+            }
+            if (this.linethrough == -1) {
+                this.linethrough = ttmlStyle.linethrough;
+            }
+            if (this.underline == -1) {
+                this.underline = ttmlStyle.underline;
+            }
+            if (this.textAlign == null) {
+                this.textAlign = ttmlStyle.textAlign;
+            }
+            if (this.fontSizeUnit == -1) {
+                this.fontSizeUnit = ttmlStyle.fontSizeUnit;
+                this.fontSize = ttmlStyle.fontSize;
+            }
+            if (z && !this.hasBackgroundColor && ttmlStyle.hasBackgroundColor) {
+                setBackgroundColor(ttmlStyle.backgroundColor);
+            }
+        }
+        return this;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/ttml/TtmlSubtitle.java

@@ -0,0 +1,55 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.ttml;
+
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+final class TtmlSubtitle implements Subtitle {
+    private final long[] eventTimesUs;
+    private final Map<String, TtmlStyle> globalStyles;
+    private final Map<String, TtmlRegion> regionMap;
+    private final TtmlNode root;
+
+    public final Map<String, TtmlStyle> getGlobalStyles() {
+        return this.globalStyles;
+    }
+
+    public final TtmlNode getRoot() {
+        return this.root;
+    }
+
+    public TtmlSubtitle(TtmlNode ttmlNode, Map<String, TtmlStyle> map, Map<String, TtmlRegion> map2) {
+        this.root = ttmlNode;
+        this.regionMap = map2;
+        this.globalStyles = map != null ? Collections.unmodifiableMap(map) : Collections.emptyMap();
+        this.eventTimesUs = ttmlNode.getEventTimesUs();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final int getNextEventTimeIndex(long j) {
+        int binarySearchCeil = Util.binarySearchCeil(this.eventTimesUs, j, false, false);
+        if (binarySearchCeil < this.eventTimesUs.length) {
+            return binarySearchCeil;
+        }
+        return -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final int getEventTimeCount() {
+        return this.eventTimesUs.length;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final long getEventTime(int i) {
+        return this.eventTimesUs[i];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle
+    public final List<Cue> getCues(long j) {
+        return this.root.getCues(j, this.globalStyles, this.regionMap);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/tx3g/Tx3gDecoder.java

@@ -0,0 +1,177 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.tx3g;
+
+import android.text.SpannableStringBuilder;
+import android.text.style.ForegroundColorSpan;
+import android.text.style.StyleSpan;
+import android.text.style.TypefaceSpan;
+import android.text.style.UnderlineSpan;
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Subtitle;
+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.nio.charset.Charset;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class Tx3gDecoder extends SimpleSubtitleDecoder {
+    private static final char BOM_UTF16_BE = 65279;
+    private static final char BOM_UTF16_LE = 65534;
+    private static final int DEFAULT_COLOR = -1;
+    private static final int DEFAULT_FONT_FACE = 0;
+    private static final String DEFAULT_FONT_FAMILY = "sans-serif";
+    private static final float DEFAULT_VERTICAL_PLACEMENT = 0.85f;
+    private static final int FONT_FACE_BOLD = 1;
+    private static final int FONT_FACE_ITALIC = 2;
+    private static final int FONT_FACE_UNDERLINE = 4;
+    private static final int SIZE_ATOM_HEADER = 8;
+    private static final int SIZE_BOM_UTF16 = 2;
+    private static final int SIZE_SHORT = 2;
+    private static final int SIZE_STYLE_RECORD = 12;
+    private static final int SPAN_PRIORITY_HIGH = 0;
+    private static final int SPAN_PRIORITY_LOW = 16711680;
+    private static final String TX3G_SERIF = "Serif";
+    private static final int TYPE_STYL = Util.getIntegerCodeForString("styl");
+    private static final int TYPE_TBOX = Util.getIntegerCodeForString("tbox");
+    private int calculatedVideoTrackHeight;
+    private boolean customVerticalPlacement;
+    private int defaultColorRgba;
+    private int defaultFontFace;
+    private String defaultFontFamily;
+    private float defaultVerticalPlacement;
+    private final ParsableByteArray parsableByteArray;
+
+    public Tx3gDecoder(List<byte[]> list) {
+        super("Tx3gDecoder");
+        this.parsableByteArray = new ParsableByteArray();
+        decodeInitializationData(list);
+    }
+
+    private void decodeInitializationData(List<byte[]> list) {
+        if (list == null || list.size() != 1 || (list.get(0).length != 48 && list.get(0).length != 53)) {
+            this.defaultFontFace = 0;
+            this.defaultColorRgba = -1;
+            this.defaultFontFamily = "sans-serif";
+            this.customVerticalPlacement = false;
+            this.defaultVerticalPlacement = DEFAULT_VERTICAL_PLACEMENT;
+            return;
+        }
+        byte[] bArr = list.get(0);
+        this.defaultFontFace = bArr[24];
+        this.defaultColorRgba = ((bArr[26] & 255) << 24) | ((bArr[27] & 255) << 16) | ((bArr[28] & 255) << 8) | (bArr[29] & 255);
+        this.defaultFontFamily = TX3G_SERIF.equals(Util.fromUtf8Bytes(bArr, 43, bArr.length - 43)) ? C.SERIF_NAME : "sans-serif";
+        int i = bArr[25] * Ascii.DC4;
+        this.calculatedVideoTrackHeight = i;
+        boolean z = (bArr[0] & 32) != 0;
+        this.customVerticalPlacement = z;
+        if (!z) {
+            this.defaultVerticalPlacement = DEFAULT_VERTICAL_PLACEMENT;
+            return;
+        }
+        float f = ((bArr[11] & 255) | ((bArr[10] & 255) << 8)) / i;
+        this.defaultVerticalPlacement = f;
+        this.defaultVerticalPlacement = Util.constrainValue(f, 0.0f, 0.95f);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.text.SimpleSubtitleDecoder
+    public final Subtitle decode(byte[] bArr, int i, boolean z) throws SubtitleDecoderException {
+        this.parsableByteArray.reset(bArr, i);
+        String readSubtitleText = readSubtitleText(this.parsableByteArray);
+        if (readSubtitleText.isEmpty()) {
+            return Tx3gSubtitle.EMPTY;
+        }
+        SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(readSubtitleText);
+        attachFontFace(spannableStringBuilder, this.defaultFontFace, 0, 0, spannableStringBuilder.length(), SPAN_PRIORITY_LOW);
+        attachColor(spannableStringBuilder, this.defaultColorRgba, -1, 0, spannableStringBuilder.length(), SPAN_PRIORITY_LOW);
+        attachFontFamily(spannableStringBuilder, this.defaultFontFamily, "sans-serif", 0, spannableStringBuilder.length(), SPAN_PRIORITY_LOW);
+        float f = this.defaultVerticalPlacement;
+        while (this.parsableByteArray.bytesLeft() >= 8) {
+            int position = this.parsableByteArray.getPosition();
+            int readInt = this.parsableByteArray.readInt();
+            int readInt2 = this.parsableByteArray.readInt();
+            if (readInt2 == TYPE_STYL) {
+                assertTrue(this.parsableByteArray.bytesLeft() >= 2);
+                int readUnsignedShort = this.parsableByteArray.readUnsignedShort();
+                for (int i2 = 0; i2 < readUnsignedShort; i2++) {
+                    applyStyleRecord(this.parsableByteArray, spannableStringBuilder);
+                }
+            } else if (readInt2 == TYPE_TBOX && this.customVerticalPlacement) {
+                assertTrue(this.parsableByteArray.bytesLeft() >= 2);
+                f = Util.constrainValue(this.parsableByteArray.readUnsignedShort() / this.calculatedVideoTrackHeight, 0.0f, 0.95f);
+            }
+            this.parsableByteArray.setPosition(position + readInt);
+        }
+        return new Tx3gSubtitle(new Cue(spannableStringBuilder, null, f, 0, 0, Float.MIN_VALUE, Integer.MIN_VALUE, Float.MIN_VALUE));
+    }
+
+    private static String readSubtitleText(ParsableByteArray parsableByteArray) throws SubtitleDecoderException {
+        char peekChar;
+        assertTrue(parsableByteArray.bytesLeft() >= 2);
+        int readUnsignedShort = parsableByteArray.readUnsignedShort();
+        if (readUnsignedShort == 0) {
+            return "";
+        }
+        if (parsableByteArray.bytesLeft() >= 2 && ((peekChar = parsableByteArray.peekChar()) == 65279 || peekChar == 65534)) {
+            return parsableByteArray.readString(readUnsignedShort, Charset.forName("UTF-16"));
+        }
+        return parsableByteArray.readString(readUnsignedShort, Charset.forName("UTF-8"));
+    }
+
+    private void applyStyleRecord(ParsableByteArray parsableByteArray, SpannableStringBuilder spannableStringBuilder) throws SubtitleDecoderException {
+        assertTrue(parsableByteArray.bytesLeft() >= 12);
+        int readUnsignedShort = parsableByteArray.readUnsignedShort();
+        int readUnsignedShort2 = parsableByteArray.readUnsignedShort();
+        parsableByteArray.skipBytes(2);
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        parsableByteArray.skipBytes(1);
+        int readInt = parsableByteArray.readInt();
+        attachFontFace(spannableStringBuilder, readUnsignedByte, this.defaultFontFace, readUnsignedShort, readUnsignedShort2, 0);
+        attachColor(spannableStringBuilder, readInt, this.defaultColorRgba, readUnsignedShort, readUnsignedShort2, 0);
+    }
+
+    private static void attachFontFace(SpannableStringBuilder spannableStringBuilder, int i, int i2, int i3, int i4, int i5) {
+        if (i != i2) {
+            int i6 = i5 | 33;
+            boolean z = (i & 1) != 0;
+            boolean z2 = (i & 2) != 0;
+            if (z) {
+                if (z2) {
+                    spannableStringBuilder.setSpan(new StyleSpan(3), i3, i4, i6);
+                } else {
+                    spannableStringBuilder.setSpan(new StyleSpan(1), i3, i4, i6);
+                }
+            } else if (z2) {
+                spannableStringBuilder.setSpan(new StyleSpan(2), i3, i4, i6);
+            }
+            boolean z3 = (i & 4) != 0;
+            if (z3) {
+                spannableStringBuilder.setSpan(new UnderlineSpan(), i3, i4, i6);
+            }
+            if (z3 || z || z2) {
+                return;
+            }
+            spannableStringBuilder.setSpan(new StyleSpan(0), i3, i4, i6);
+        }
+    }
+
+    private static void attachColor(SpannableStringBuilder spannableStringBuilder, int i, int i2, int i3, int i4, int i5) {
+        if (i != i2) {
+            spannableStringBuilder.setSpan(new ForegroundColorSpan((i >>> 8) | ((i & 255) << 24)), i3, i4, i5 | 33);
+        }
+    }
+
+    private static void attachFontFamily(SpannableStringBuilder spannableStringBuilder, String str, String str2, int i, int i2, int i3) {
+        if (str != str2) {
+            spannableStringBuilder.setSpan(new TypefaceSpan(str), i, i2, i3 | 33);
+        }
+    }
+
+    private static void assertTrue(boolean z) throws SubtitleDecoderException {
+        if (!z) {
+            throw new SubtitleDecoderException("Unexpected subtitle format.");
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/tx3g/Tx3gSubtitle.java

@@ -0,0 +1,42 @@
+package com.mbridge.msdk.playercommon.exoplayer2.text.tx3g;
+
+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 Tx3gSubtitle implements Subtitle {
+    public static final Tx3gSubtitle EMPTY = new Tx3gSubtitle();
+    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 Tx3gSubtitle(Cue cue) {
+        this.cues = Collections.singletonList(cue);
+    }
+
+    private Tx3gSubtitle() {
+        this.cues = Collections.emptyList();
+    }
+
+    @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();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/CssParser.java

@@ -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));
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/Mp4WebvttDecoder.java

@@ -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();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/Mp4WebvttSubtitle.java

@@ -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();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttCssStyle.java

@@ -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;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttCue.java

@@ -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) {
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttCueParser.java

@@ -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]);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttDecoder.java

@@ -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())) {
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttParserUtil.java

@@ -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;
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/text/webvtt/WebvttSubtitle.java

@@ -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();
+    }
+}