Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/metadata/scte35/PrivateCommand.java

@@ -0,0 +1,55 @@
+package com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+
+/* loaded from: classes4.dex */
+public final class PrivateCommand extends SpliceCommand {
+    public static final Parcelable.Creator<PrivateCommand> CREATOR = new Parcelable.Creator<PrivateCommand>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35.PrivateCommand.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public PrivateCommand createFromParcel(Parcel parcel) {
+            return new PrivateCommand(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public PrivateCommand[] newArray(int i) {
+            return new PrivateCommand[i];
+        }
+    };
+    public final byte[] commandBytes;
+    public final long identifier;
+    public final long ptsAdjustment;
+
+    private PrivateCommand(long j, byte[] bArr, long j2) {
+        this.ptsAdjustment = j2;
+        this.identifier = j;
+        this.commandBytes = bArr;
+    }
+
+    private PrivateCommand(Parcel parcel) {
+        this.ptsAdjustment = parcel.readLong();
+        this.identifier = parcel.readLong();
+        byte[] bArr = new byte[parcel.readInt()];
+        this.commandBytes = bArr;
+        parcel.readByteArray(bArr);
+    }
+
+    public static PrivateCommand parseFromSection(ParsableByteArray parsableByteArray, int i, long j) {
+        long readUnsignedInt = parsableByteArray.readUnsignedInt();
+        int i2 = i - 4;
+        byte[] bArr = new byte[i2];
+        parsableByteArray.readBytes(bArr, 0, i2);
+        return new PrivateCommand(readUnsignedInt, bArr, j);
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        parcel.writeLong(this.ptsAdjustment);
+        parcel.writeLong(this.identifier);
+        parcel.writeInt(this.commandBytes.length);
+        parcel.writeByteArray(this.commandBytes);
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/metadata/scte35/SpliceCommand.java

@@ -0,0 +1,15 @@
+package com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35;
+
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+
+/* loaded from: classes4.dex */
+public abstract class SpliceCommand implements Metadata.Entry {
+    @Override // android.os.Parcelable
+    public int describeContents() {
+        return 0;
+    }
+
+    public String toString() {
+        return "SCTE-35 splice command: type=" + getClass().getSimpleName();
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/metadata/scte35/SpliceInfoDecoder.java

@@ -0,0 +1,56 @@
+package com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35;
+
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataDecoderException;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes4.dex */
+public final class SpliceInfoDecoder implements MetadataDecoder {
+    private static final int TYPE_PRIVATE_COMMAND = 255;
+    private static final int TYPE_SPLICE_INSERT = 5;
+    private static final int TYPE_SPLICE_NULL = 0;
+    private static final int TYPE_SPLICE_SCHEDULE = 4;
+    private static final int TYPE_TIME_SIGNAL = 6;
+    private final ParsableByteArray sectionData = new ParsableByteArray();
+    private final ParsableBitArray sectionHeader = new ParsableBitArray();
+    private TimestampAdjuster timestampAdjuster;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataDecoder
+    public final Metadata decode(MetadataInputBuffer metadataInputBuffer) throws MetadataDecoderException {
+        Metadata.Entry spliceNullCommand;
+        TimestampAdjuster timestampAdjuster = this.timestampAdjuster;
+        if (timestampAdjuster == null || metadataInputBuffer.subsampleOffsetUs != timestampAdjuster.getTimestampOffsetUs()) {
+            TimestampAdjuster timestampAdjuster2 = new TimestampAdjuster(metadataInputBuffer.timeUs);
+            this.timestampAdjuster = timestampAdjuster2;
+            timestampAdjuster2.adjustSampleTimestamp(metadataInputBuffer.timeUs - metadataInputBuffer.subsampleOffsetUs);
+        }
+        ByteBuffer byteBuffer = metadataInputBuffer.data;
+        byte[] array = byteBuffer.array();
+        int limit = byteBuffer.limit();
+        this.sectionData.reset(array, limit);
+        this.sectionHeader.reset(array, limit);
+        this.sectionHeader.skipBits(39);
+        long readBits = (this.sectionHeader.readBits(1) << 32) | this.sectionHeader.readBits(32);
+        this.sectionHeader.skipBits(20);
+        int readBits2 = this.sectionHeader.readBits(12);
+        int readBits3 = this.sectionHeader.readBits(8);
+        this.sectionData.skipBytes(14);
+        if (readBits3 == 0) {
+            spliceNullCommand = new SpliceNullCommand();
+        } else if (readBits3 == 255) {
+            spliceNullCommand = PrivateCommand.parseFromSection(this.sectionData, readBits2, readBits);
+        } else if (readBits3 == 4) {
+            spliceNullCommand = SpliceScheduleCommand.parseFromSection(this.sectionData);
+        } else if (readBits3 == 5) {
+            spliceNullCommand = SpliceInsertCommand.parseFromSection(this.sectionData, readBits, this.timestampAdjuster);
+        } else {
+            spliceNullCommand = readBits3 != 6 ? null : TimeSignalCommand.parseFromSection(this.sectionData, readBits, this.timestampAdjuster);
+        }
+        return spliceNullCommand == null ? new Metadata(new Metadata.Entry[0]) : new Metadata(spliceNullCommand);
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/metadata/scte35/SpliceInsertCommand.java

@@ -0,0 +1,188 @@
+package com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class SpliceInsertCommand extends SpliceCommand {
+    public static final Parcelable.Creator<SpliceInsertCommand> CREATOR = new Parcelable.Creator<SpliceInsertCommand>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35.SpliceInsertCommand.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public SpliceInsertCommand createFromParcel(Parcel parcel) {
+            return new SpliceInsertCommand(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public SpliceInsertCommand[] newArray(int i) {
+            return new SpliceInsertCommand[i];
+        }
+    };
+    public final boolean autoReturn;
+    public final int availNum;
+    public final int availsExpected;
+    public final long breakDurationUs;
+    public final List<ComponentSplice> componentSpliceList;
+    public final boolean outOfNetworkIndicator;
+    public final boolean programSpliceFlag;
+    public final long programSplicePlaybackPositionUs;
+    public final long programSplicePts;
+    public final boolean spliceEventCancelIndicator;
+    public final long spliceEventId;
+    public final boolean spliceImmediateFlag;
+    public final int uniqueProgramId;
+
+    private SpliceInsertCommand(long j, boolean z, boolean z2, boolean z3, boolean z4, long j2, long j3, List<ComponentSplice> list, boolean z5, long j4, int i, int i2, int i3) {
+        this.spliceEventId = j;
+        this.spliceEventCancelIndicator = z;
+        this.outOfNetworkIndicator = z2;
+        this.programSpliceFlag = z3;
+        this.spliceImmediateFlag = z4;
+        this.programSplicePts = j2;
+        this.programSplicePlaybackPositionUs = j3;
+        this.componentSpliceList = Collections.unmodifiableList(list);
+        this.autoReturn = z5;
+        this.breakDurationUs = j4;
+        this.uniqueProgramId = i;
+        this.availNum = i2;
+        this.availsExpected = i3;
+    }
+
+    private SpliceInsertCommand(Parcel parcel) {
+        this.spliceEventId = parcel.readLong();
+        this.spliceEventCancelIndicator = parcel.readByte() == 1;
+        this.outOfNetworkIndicator = parcel.readByte() == 1;
+        this.programSpliceFlag = parcel.readByte() == 1;
+        this.spliceImmediateFlag = parcel.readByte() == 1;
+        this.programSplicePts = parcel.readLong();
+        this.programSplicePlaybackPositionUs = parcel.readLong();
+        int readInt = parcel.readInt();
+        ArrayList arrayList = new ArrayList(readInt);
+        for (int i = 0; i < readInt; i++) {
+            arrayList.add(ComponentSplice.createFromParcel(parcel));
+        }
+        this.componentSpliceList = Collections.unmodifiableList(arrayList);
+        this.autoReturn = parcel.readByte() == 1;
+        this.breakDurationUs = parcel.readLong();
+        this.uniqueProgramId = parcel.readInt();
+        this.availNum = parcel.readInt();
+        this.availsExpected = parcel.readInt();
+    }
+
+    public static SpliceInsertCommand parseFromSection(ParsableByteArray parsableByteArray, long j, TimestampAdjuster timestampAdjuster) {
+        List list;
+        boolean z;
+        boolean z2;
+        long j2;
+        boolean z3;
+        long j3;
+        int i;
+        int i2;
+        int i3;
+        boolean z4;
+        boolean z5;
+        long j4;
+        long readUnsignedInt = parsableByteArray.readUnsignedInt();
+        boolean z6 = (parsableByteArray.readUnsignedByte() & 128) != 0;
+        List emptyList = Collections.emptyList();
+        if (z6) {
+            list = emptyList;
+            z = false;
+            z2 = false;
+            j2 = C.TIME_UNSET;
+            z3 = false;
+            j3 = C.TIME_UNSET;
+            i = 0;
+            i2 = 0;
+            i3 = 0;
+            z4 = false;
+        } else {
+            int readUnsignedByte = parsableByteArray.readUnsignedByte();
+            boolean z7 = (readUnsignedByte & 128) != 0;
+            boolean z8 = (readUnsignedByte & 64) != 0;
+            boolean z9 = (readUnsignedByte & 32) != 0;
+            boolean z10 = (readUnsignedByte & 16) != 0;
+            long parseSpliceTime = (!z8 || z10) ? C.TIME_UNSET : TimeSignalCommand.parseSpliceTime(parsableByteArray, j);
+            if (!z8) {
+                int readUnsignedByte2 = parsableByteArray.readUnsignedByte();
+                ArrayList arrayList = new ArrayList(readUnsignedByte2);
+                for (int i4 = 0; i4 < readUnsignedByte2; i4++) {
+                    int readUnsignedByte3 = parsableByteArray.readUnsignedByte();
+                    long parseSpliceTime2 = !z10 ? TimeSignalCommand.parseSpliceTime(parsableByteArray, j) : C.TIME_UNSET;
+                    arrayList.add(new ComponentSplice(readUnsignedByte3, parseSpliceTime2, timestampAdjuster.adjustTsTimestamp(parseSpliceTime2)));
+                }
+                emptyList = arrayList;
+            }
+            if (z9) {
+                long readUnsignedByte4 = parsableByteArray.readUnsignedByte();
+                boolean z11 = (128 & readUnsignedByte4) != 0;
+                j4 = ((((readUnsignedByte4 & 1) << 32) | parsableByteArray.readUnsignedInt()) * 1000) / 90;
+                z5 = z11;
+            } else {
+                z5 = false;
+                j4 = C.TIME_UNSET;
+            }
+            i = parsableByteArray.readUnsignedShort();
+            z4 = z8;
+            i2 = parsableByteArray.readUnsignedByte();
+            i3 = parsableByteArray.readUnsignedByte();
+            list = emptyList;
+            long j5 = parseSpliceTime;
+            z3 = z5;
+            j3 = j4;
+            z2 = z10;
+            z = z7;
+            j2 = j5;
+        }
+        return new SpliceInsertCommand(readUnsignedInt, z6, z, z4, z2, j2, timestampAdjuster.adjustTsTimestamp(j2), list, z3, j3, i, i2, i3);
+    }
+
+    public static final class ComponentSplice {
+        public final long componentSplicePlaybackPositionUs;
+        public final long componentSplicePts;
+        public final int componentTag;
+
+        private ComponentSplice(int i, long j, long j2) {
+            this.componentTag = i;
+            this.componentSplicePts = j;
+            this.componentSplicePlaybackPositionUs = j2;
+        }
+
+        public final void writeToParcel(Parcel parcel) {
+            parcel.writeInt(this.componentTag);
+            parcel.writeLong(this.componentSplicePts);
+            parcel.writeLong(this.componentSplicePlaybackPositionUs);
+        }
+
+        public static ComponentSplice createFromParcel(Parcel parcel) {
+            return new ComponentSplice(parcel.readInt(), parcel.readLong(), parcel.readLong());
+        }
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        parcel.writeLong(this.spliceEventId);
+        parcel.writeByte(this.spliceEventCancelIndicator ? (byte) 1 : (byte) 0);
+        parcel.writeByte(this.outOfNetworkIndicator ? (byte) 1 : (byte) 0);
+        parcel.writeByte(this.programSpliceFlag ? (byte) 1 : (byte) 0);
+        parcel.writeByte(this.spliceImmediateFlag ? (byte) 1 : (byte) 0);
+        parcel.writeLong(this.programSplicePts);
+        parcel.writeLong(this.programSplicePlaybackPositionUs);
+        int size = this.componentSpliceList.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            this.componentSpliceList.get(i2).writeToParcel(parcel);
+        }
+        parcel.writeByte(this.autoReturn ? (byte) 1 : (byte) 0);
+        parcel.writeLong(this.breakDurationUs);
+        parcel.writeInt(this.uniqueProgramId);
+        parcel.writeInt(this.availNum);
+        parcel.writeInt(this.availsExpected);
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/metadata/scte35/SpliceNullCommand.java

@@ -0,0 +1,25 @@
+package com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/* loaded from: classes4.dex */
+public final class SpliceNullCommand extends SpliceCommand {
+    public static final Parcelable.Creator<SpliceNullCommand> CREATOR = new Parcelable.Creator<SpliceNullCommand>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35.SpliceNullCommand.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public SpliceNullCommand createFromParcel(Parcel parcel) {
+            return new SpliceNullCommand();
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public SpliceNullCommand[] newArray(int i) {
+            return new SpliceNullCommand[i];
+        }
+    };
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/metadata/scte35/SpliceScheduleCommand.java

@@ -0,0 +1,216 @@
+package com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class SpliceScheduleCommand extends SpliceCommand {
+    public static final Parcelable.Creator<SpliceScheduleCommand> CREATOR = new Parcelable.Creator<SpliceScheduleCommand>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35.SpliceScheduleCommand.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public SpliceScheduleCommand createFromParcel(Parcel parcel) {
+            return new SpliceScheduleCommand(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public SpliceScheduleCommand[] newArray(int i) {
+            return new SpliceScheduleCommand[i];
+        }
+    };
+    public final List<Event> events;
+
+    public static final class Event {
+        public final boolean autoReturn;
+        public final int availNum;
+        public final int availsExpected;
+        public final long breakDurationUs;
+        public final List<ComponentSplice> componentSpliceList;
+        public final boolean outOfNetworkIndicator;
+        public final boolean programSpliceFlag;
+        public final boolean spliceEventCancelIndicator;
+        public final long spliceEventId;
+        public final int uniqueProgramId;
+        public final long utcSpliceTime;
+
+        private Event(long j, boolean z, boolean z2, boolean z3, List<ComponentSplice> list, long j2, boolean z4, long j3, int i, int i2, int i3) {
+            this.spliceEventId = j;
+            this.spliceEventCancelIndicator = z;
+            this.outOfNetworkIndicator = z2;
+            this.programSpliceFlag = z3;
+            this.componentSpliceList = Collections.unmodifiableList(list);
+            this.utcSpliceTime = j2;
+            this.autoReturn = z4;
+            this.breakDurationUs = j3;
+            this.uniqueProgramId = i;
+            this.availNum = i2;
+            this.availsExpected = i3;
+        }
+
+        private Event(Parcel parcel) {
+            this.spliceEventId = parcel.readLong();
+            this.spliceEventCancelIndicator = parcel.readByte() == 1;
+            this.outOfNetworkIndicator = parcel.readByte() == 1;
+            this.programSpliceFlag = parcel.readByte() == 1;
+            int readInt = parcel.readInt();
+            ArrayList arrayList = new ArrayList(readInt);
+            for (int i = 0; i < readInt; i++) {
+                arrayList.add(ComponentSplice.createFromParcel(parcel));
+            }
+            this.componentSpliceList = Collections.unmodifiableList(arrayList);
+            this.utcSpliceTime = parcel.readLong();
+            this.autoReturn = parcel.readByte() == 1;
+            this.breakDurationUs = parcel.readLong();
+            this.uniqueProgramId = parcel.readInt();
+            this.availNum = parcel.readInt();
+            this.availsExpected = parcel.readInt();
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static Event parseFromSection(ParsableByteArray parsableByteArray) {
+            ArrayList arrayList;
+            boolean z;
+            long j;
+            boolean z2;
+            long j2;
+            int i;
+            int i2;
+            int i3;
+            boolean z3;
+            boolean z4;
+            long j3;
+            long readUnsignedInt = parsableByteArray.readUnsignedInt();
+            boolean z5 = (parsableByteArray.readUnsignedByte() & 128) != 0;
+            ArrayList arrayList2 = new ArrayList();
+            if (z5) {
+                arrayList = arrayList2;
+                z = false;
+                j = C.TIME_UNSET;
+                z2 = false;
+                j2 = C.TIME_UNSET;
+                i = 0;
+                i2 = 0;
+                i3 = 0;
+                z3 = false;
+            } else {
+                int readUnsignedByte = parsableByteArray.readUnsignedByte();
+                boolean z6 = (readUnsignedByte & 128) != 0;
+                boolean z7 = (readUnsignedByte & 64) != 0;
+                boolean z8 = (readUnsignedByte & 32) != 0;
+                long readUnsignedInt2 = z7 ? parsableByteArray.readUnsignedInt() : C.TIME_UNSET;
+                if (!z7) {
+                    int readUnsignedByte2 = parsableByteArray.readUnsignedByte();
+                    ArrayList arrayList3 = new ArrayList(readUnsignedByte2);
+                    for (int i4 = 0; i4 < readUnsignedByte2; i4++) {
+                        arrayList3.add(new ComponentSplice(parsableByteArray.readUnsignedByte(), parsableByteArray.readUnsignedInt()));
+                    }
+                    arrayList2 = arrayList3;
+                }
+                if (z8) {
+                    long readUnsignedByte3 = parsableByteArray.readUnsignedByte();
+                    boolean z9 = (128 & readUnsignedByte3) != 0;
+                    j3 = ((((readUnsignedByte3 & 1) << 32) | parsableByteArray.readUnsignedInt()) * 1000) / 90;
+                    z4 = z9;
+                } else {
+                    z4 = false;
+                    j3 = C.TIME_UNSET;
+                }
+                int readUnsignedShort = parsableByteArray.readUnsignedShort();
+                int readUnsignedByte4 = parsableByteArray.readUnsignedByte();
+                z3 = z7;
+                i3 = parsableByteArray.readUnsignedByte();
+                j2 = j3;
+                arrayList = arrayList2;
+                long j4 = readUnsignedInt2;
+                i = readUnsignedShort;
+                i2 = readUnsignedByte4;
+                j = j4;
+                boolean z10 = z6;
+                z2 = z4;
+                z = z10;
+            }
+            return new Event(readUnsignedInt, z5, z, z3, arrayList, j, z2, j2, i, i2, i3);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void writeToParcel(Parcel parcel) {
+            parcel.writeLong(this.spliceEventId);
+            parcel.writeByte(this.spliceEventCancelIndicator ? (byte) 1 : (byte) 0);
+            parcel.writeByte(this.outOfNetworkIndicator ? (byte) 1 : (byte) 0);
+            parcel.writeByte(this.programSpliceFlag ? (byte) 1 : (byte) 0);
+            int size = this.componentSpliceList.size();
+            parcel.writeInt(size);
+            for (int i = 0; i < size; i++) {
+                this.componentSpliceList.get(i).writeToParcel(parcel);
+            }
+            parcel.writeLong(this.utcSpliceTime);
+            parcel.writeByte(this.autoReturn ? (byte) 1 : (byte) 0);
+            parcel.writeLong(this.breakDurationUs);
+            parcel.writeInt(this.uniqueProgramId);
+            parcel.writeInt(this.availNum);
+            parcel.writeInt(this.availsExpected);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static Event createFromParcel(Parcel parcel) {
+            return new Event(parcel);
+        }
+    }
+
+    public static final class ComponentSplice {
+        public final int componentTag;
+        public final long utcSpliceTime;
+
+        private ComponentSplice(int i, long j) {
+            this.componentTag = i;
+            this.utcSpliceTime = j;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static ComponentSplice createFromParcel(Parcel parcel) {
+            return new ComponentSplice(parcel.readInt(), parcel.readLong());
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void writeToParcel(Parcel parcel) {
+            parcel.writeInt(this.componentTag);
+            parcel.writeLong(this.utcSpliceTime);
+        }
+    }
+
+    private SpliceScheduleCommand(List<Event> list) {
+        this.events = Collections.unmodifiableList(list);
+    }
+
+    private SpliceScheduleCommand(Parcel parcel) {
+        int readInt = parcel.readInt();
+        ArrayList arrayList = new ArrayList(readInt);
+        for (int i = 0; i < readInt; i++) {
+            arrayList.add(Event.createFromParcel(parcel));
+        }
+        this.events = Collections.unmodifiableList(arrayList);
+    }
+
+    public static SpliceScheduleCommand parseFromSection(ParsableByteArray parsableByteArray) {
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        ArrayList arrayList = new ArrayList(readUnsignedByte);
+        for (int i = 0; i < readUnsignedByte; i++) {
+            arrayList.add(Event.parseFromSection(parsableByteArray));
+        }
+        return new SpliceScheduleCommand(arrayList);
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int size = this.events.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            this.events.get(i2).writeToParcel(parcel);
+        }
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/metadata/scte35/TimeSignalCommand.java

@@ -0,0 +1,47 @@
+package com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TimestampAdjuster;
+
+/* loaded from: classes4.dex */
+public final class TimeSignalCommand extends SpliceCommand {
+    public static final Parcelable.Creator<TimeSignalCommand> CREATOR = new Parcelable.Creator<TimeSignalCommand>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.metadata.scte35.TimeSignalCommand.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public TimeSignalCommand createFromParcel(Parcel parcel) {
+            return new TimeSignalCommand(parcel.readLong(), parcel.readLong());
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public TimeSignalCommand[] newArray(int i) {
+            return new TimeSignalCommand[i];
+        }
+    };
+    public final long playbackPositionUs;
+    public final long ptsTime;
+
+    private TimeSignalCommand(long j, long j2) {
+        this.ptsTime = j;
+        this.playbackPositionUs = j2;
+    }
+
+    public static TimeSignalCommand parseFromSection(ParsableByteArray parsableByteArray, long j, TimestampAdjuster timestampAdjuster) {
+        long parseSpliceTime = parseSpliceTime(parsableByteArray, j);
+        return new TimeSignalCommand(parseSpliceTime, timestampAdjuster.adjustTsTimestamp(parseSpliceTime));
+    }
+
+    public static long parseSpliceTime(ParsableByteArray parsableByteArray, long j) {
+        long readUnsignedByte = parsableByteArray.readUnsignedByte();
+        return (128 & readUnsignedByte) != 0 ? 8589934591L & ((((readUnsignedByte & 1) << 32) | parsableByteArray.readUnsignedInt()) + j) : C.TIME_UNSET;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        parcel.writeLong(this.ptsTime);
+        parcel.writeLong(this.playbackPositionUs);
+    }
+}