1069 lines
37 KiB
Java
1069 lines
37 KiB
Java
package defpackage;
|
|
|
|
import java.io.IOException;
|
|
import java.nio.ByteBuffer;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
final class ans {
|
|
private static final int HEADER_SIZE = 8;
|
|
private static final int LARGE_HEADER_SIZE = 16;
|
|
private static final int LARGE_SIZE_MARKER = 1;
|
|
private static final int FULL_BOX_HEADER = 4;
|
|
private static final int MAX_INIT_BOX = 4194304;
|
|
private static final int MAX_FRAGMENT_BOX = 8388608;
|
|
private static final int MAX_SAMPLE = 4194304;
|
|
private static final long MILLIS_PER_SECOND = 1000L;
|
|
private static final int VISUAL_ENTRY_FIELDS = 78;
|
|
private static final int AUDIO_ENTRY_FIELDS = 28;
|
|
private static final int TAG_ES = 3;
|
|
private static final int TAG_DECODER_CONFIG = 4;
|
|
private static final int TAG_DECODER_SPECIFIC = 5;
|
|
private static final int DECODER_CONFIG_FIELDS = 13;
|
|
private static final int ES_FLAG_DEPENDENCE = 128;
|
|
private static final int ES_FLAG_URL = 64;
|
|
private static final int ES_FLAG_OCR = 32;
|
|
private static final int DESCRIPTOR_LENGTH_BYTES = 4;
|
|
private static final int DESCRIPTOR_CONTINUE = 128;
|
|
private static final int DESCRIPTOR_VALUE = 127;
|
|
private static final int DESCRIPTOR_SHIFT = 7;
|
|
private static final int REFERENCE_SIZE_MASK = Integer.MAX_VALUE;
|
|
private static final int TFHD_BASE_OFFSET = 1;
|
|
private static final int TFHD_DESCRIPTION_INDEX = 2;
|
|
private static final int TFHD_DEFAULT_DURATION = 8;
|
|
private static final int TFHD_DEFAULT_SIZE = 16;
|
|
private static final int TFHD_DEFAULT_FLAGS = 32;
|
|
private static final int TRUN_DATA_OFFSET = 1;
|
|
private static final int TRUN_FIRST_FLAGS = 4;
|
|
private static final int TRUN_DURATION = 256;
|
|
private static final int TRUN_SIZE = 512;
|
|
private static final int TRUN_FLAGS = 1024;
|
|
private static final int TRUN_COMPOSITION = 2048;
|
|
private static final int NON_SYNC_FLAG = 65536;
|
|
private static final int FLAGS_MASK = 16777215;
|
|
private static final int VERSION_SHIFT = 24;
|
|
private static final String MOOV = "moov";
|
|
private static final String SIDX = "sidx";
|
|
private static final String MOOF = "moof";
|
|
private static final String TRAK = "trak";
|
|
private static final String MDIA = "mdia";
|
|
private static final String MDHD = "mdhd";
|
|
private static final String MINF = "minf";
|
|
private static final String STBL = "stbl";
|
|
private static final String STSD = "stsd";
|
|
private static final String MVEX = "mvex";
|
|
private static final String TREX = "trex";
|
|
private static final String TRAF = "traf";
|
|
private static final String TFHD = "tfhd";
|
|
private static final String TFDT = "tfdt";
|
|
private static final String TRUN = "trun";
|
|
private static final String AVC1 = "avc1";
|
|
private static final String AVC3 = "avc3";
|
|
private static final String MP4A = "mp4a";
|
|
private static final String AVCC = "avcC";
|
|
private static final String ESDS = "esds";
|
|
private static final String NO_INDEX = "stream has no segment index";
|
|
private static final String NO_CODEC = "stream has no supported codec";
|
|
private static final String BAD_BOX = "malformed mp4 box ";
|
|
private final ant channel;
|
|
private final List<anr> segments = new ArrayList<>();
|
|
private int timescale;
|
|
private boolean video;
|
|
private byte[] codecConfig;
|
|
private anp trackDefaults = new anp(
|
|
0,
|
|
0,
|
|
(-989610675 ^ 989610675) + ((-989610675 & 989610675) << 1)
|
|
);
|
|
private String headerType;
|
|
private String lastType;
|
|
|
|
private ans(ant var1) {
|
|
this.channel = var1;
|
|
}
|
|
|
|
static ans open(ant var0) throws IOException {
|
|
ans var1 = new ans(var0);
|
|
var1.readInit();
|
|
return var1;
|
|
}
|
|
|
|
boolean isVideo() {
|
|
return this.video;
|
|
}
|
|
|
|
byte[] codecConfig() {
|
|
return this.codecConfig;
|
|
}
|
|
|
|
int segmentCount() {
|
|
return this.segments.size();
|
|
}
|
|
|
|
int segmentAt(long var1) {
|
|
int var3 = 0;
|
|
int var4 = 0;
|
|
int var5 = 0;
|
|
int var6 = 0;
|
|
int var7 = -1375977729;
|
|
|
|
while (true) {
|
|
switch (var7) {
|
|
case -1434743073:
|
|
var7 = 886457760;
|
|
break;
|
|
case -1384642667:
|
|
var6 = var3 + var4 >>> 1;
|
|
if (this.segments.get(var6).startMs() <= var1) {
|
|
var7 = -256902951;
|
|
} else {
|
|
var7 = -455469975;
|
|
}
|
|
break;
|
|
case -1375977729:
|
|
default:
|
|
var3 = 0;
|
|
var4 = this.segments.size() - (1);
|
|
var5 = 0;
|
|
var7 = 886457760;
|
|
break;
|
|
case -564277243:
|
|
return var5;
|
|
case -455469975:
|
|
var4 = var6 - (1);
|
|
var7 = -1434743073;
|
|
break;
|
|
case -256902951:
|
|
var5 = var6;
|
|
var3 = var6 + 1;
|
|
var7 = -1434743073;
|
|
break;
|
|
case 886457760:
|
|
if (var3 <= var4) {
|
|
var7 = -1384642667;
|
|
} else {
|
|
var7 = -564277243;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
List<anq> readSegment(int var1) throws IOException {
|
|
anr var2 = null;
|
|
ByteBuffer var3 = null;
|
|
ArrayList var4 = null;
|
|
ByteBuffer var5 = null;
|
|
int var6 = -1556286043;
|
|
|
|
while (true) {
|
|
switch (var6) {
|
|
case -1687150231:
|
|
this.parseTraf(var5, var2.offset(), var4);
|
|
var6 = 142604501;
|
|
break;
|
|
case -1556286043:
|
|
default:
|
|
var2 = this.segments.get(var1);
|
|
var3 = this.readBox(
|
|
var2.offset(),
|
|
"moof",
|
|
(-1748646828 ^ 1757035436) + ((-1748646828 & 1757035436) << 1)
|
|
);
|
|
var4 = new ArrayList();
|
|
var6 = 429576451;
|
|
break;
|
|
case -117190557:
|
|
var4.sort((var0, var1x) -> Long.compare(var0.offset(), var1x.offset()));
|
|
return var4;
|
|
case 142604501:
|
|
var6 = 429576451;
|
|
break;
|
|
case 429576451:
|
|
if (var3.hasRemaining()) {
|
|
var6 = 790007517;
|
|
} else {
|
|
var6 = -117190557;
|
|
}
|
|
break;
|
|
case 790007517:
|
|
var5 = this.nextChild(var3);
|
|
if ("traf".equals(this.lastType)) {
|
|
var6 = -1687150231;
|
|
} else {
|
|
var6 = 142604501;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ByteBuffer read(anq var1, ByteBuffer var2) throws IOException {
|
|
if (var1.size() > 0 && var1.size() <= (703881152 ^ -699686848) + ((703881152 & -699686848) << 1)) {
|
|
ByteBuffer var3 = var2 != null && var2.capacity() >= var1.size()
|
|
? var2.clear()
|
|
: ByteBuffer.allocate(
|
|
Math.max(
|
|
var1.size(),
|
|
var2 == null
|
|
? 0: var2.capacity() * ((-1041923229 | 1041923231) + (-1041923229 & 1041923231))
|
|
)
|
|
);
|
|
var3.limit(var1.size());
|
|
this.channel.setPosition(var1.offset());
|
|
this.readFully(var3);
|
|
var3.flip();
|
|
return var3;
|
|
} else {
|
|
throw new IOException("malformed mp4 box trun");
|
|
}
|
|
}
|
|
|
|
private void readInit() throws IOException {
|
|
long var1 = (7411397759284608797L ^ -7411397759284608797L) + ((7411397759284608797L & -7411397759284608797L) << 1);
|
|
ByteBuffer var3 = null;
|
|
long var4 = (3805654444444626470L | -3805654444444626470L) + (3805654444444626470L & -3805654444444626470L);
|
|
long var6 = (9141068795157752576L | -9141068795157752576L) + (9141068795157752576L & -9141068795157752576L);
|
|
Object var8 = null;
|
|
long var9 = (-7573062104143992540L ^ 7573062104143992540L) + ((-7573062104143992540L & 7573062104143992540L) << 1);
|
|
int var11 = 0;
|
|
String var12 = null;
|
|
int var13 = 440056696;
|
|
|
|
while (true) {
|
|
switch (var13) {
|
|
case -2139693340:
|
|
this.parseSidx(var3, var4);
|
|
return;
|
|
case -1634972743:
|
|
if ("sidx".equals(var12)) {
|
|
var13 = 54234298;
|
|
} else {
|
|
var13 = 172949529;
|
|
}
|
|
break;
|
|
case -1462951968:
|
|
if (var1 < var6) {
|
|
var13 = -465831660;
|
|
} else {
|
|
var13 = 1798056365;
|
|
}
|
|
break;
|
|
case -1457415919:
|
|
var13 = 1798056365;
|
|
break;
|
|
case -1171543993:
|
|
if (this.timescale <= 0) {
|
|
var13 = 2072484515;
|
|
} else {
|
|
var13 = 945788598;
|
|
}
|
|
break;
|
|
case -672257516:
|
|
var1 += var9;
|
|
var13 = -1462951968;
|
|
break;
|
|
case -465831660:
|
|
if (var3 == null) {
|
|
var13 = -67413064;
|
|
} else {
|
|
var13 = 1798056365;
|
|
}
|
|
break;
|
|
case -259764133:
|
|
this.parseMoov(this.readBody(var1 + var11, var9 - var11));
|
|
var13 = -672257516;
|
|
break;
|
|
case -67413064:
|
|
var8 = this.readHeader(var1);
|
|
var9 = (long)((Object[])var8)[0];
|
|
var11 = (int)((Object[])var8)[1];
|
|
var12 = this.headerType;
|
|
if (var9 >= var11) {
|
|
var13 = 1760847170;
|
|
} else {
|
|
var13 = 756152629;
|
|
}
|
|
break;
|
|
case 54234298:
|
|
var3 = this.readBody(var1 + var11, var9 - var11);
|
|
var4 = var1 + var9;
|
|
var13 = -672257516;
|
|
break;
|
|
case 172949529:
|
|
if ("moof".equals(var12)) {
|
|
var13 = -1457415919;
|
|
} else {
|
|
var13 = -672257516;
|
|
}
|
|
break;
|
|
case 440056696:
|
|
default:
|
|
var1 = (2552891194613996489L ^ -2552891194613996489L) + ((2552891194613996489L & -2552891194613996489L) << 1);
|
|
var3 = null;
|
|
var4 = (940066504459481028L ^ -940066504459481028L) + ((940066504459481028L & -940066504459481028L) << 1);
|
|
var6 = this.channel.size();
|
|
var13 = -1462951968;
|
|
break;
|
|
case 452914626:
|
|
if ("moov".equals(var12)) {
|
|
var13 = -259764133;
|
|
} else {
|
|
var13 = -1634972743;
|
|
}
|
|
break;
|
|
case 594968410:
|
|
throw new IOException("stream has no segment index");
|
|
case 756152629:
|
|
throw new IOException("malformed mp4 box " + var12);
|
|
case 945788598:
|
|
if (var3 == null) {
|
|
var13 = 594968410;
|
|
} else {
|
|
var13 = -2139693340;
|
|
}
|
|
break;
|
|
case 1760847170:
|
|
if (var9 > var6 - var1 + var11) {
|
|
var13 = 756152629;
|
|
} else {
|
|
var13 = 452914626;
|
|
}
|
|
break;
|
|
case 1798056365:
|
|
if (this.codecConfig != null) {
|
|
var13 = -1171543993;
|
|
} else {
|
|
var13 = 2072484515;
|
|
}
|
|
break;
|
|
case 2072484515:
|
|
throw new IOException(
|
|
"stream has no supported codec"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void parseMoov(ByteBuffer var1) throws IOException {
|
|
ByteBuffer var2 = null;
|
|
String var3 = null;
|
|
ByteBuffer var4 = null;
|
|
int var5 = -301528956;
|
|
|
|
while (true) {
|
|
switch (var5) {
|
|
case -2104894051:
|
|
var4 = this.nextChild(var2);
|
|
if ("trex".equals(this.lastType)) {
|
|
var5 = -1451465374;
|
|
} else {
|
|
var5 = -1884663492;
|
|
}
|
|
break;
|
|
case -1884663492:
|
|
var5 = 2059330867;
|
|
break;
|
|
case -1451465374:
|
|
var4.getInt();
|
|
var4.getInt();
|
|
var4.getInt();
|
|
this.trackDefaults = new anp(var4.getInt(), var4.getInt(), var4.getInt());
|
|
var5 = -1884663492;
|
|
break;
|
|
case -422340387:
|
|
if ("mvex".equals(var3)) {
|
|
var5 = 2059330867;
|
|
} else {
|
|
var5 = 692881069;
|
|
}
|
|
break;
|
|
case -301528956:
|
|
default:
|
|
if (var1.hasRemaining()) {
|
|
var5 = 323594408;
|
|
} else {
|
|
var5 = 166103649;
|
|
}
|
|
break;
|
|
case 166103649:
|
|
return;
|
|
case 323594408:
|
|
var2 = this.nextChild(var1);
|
|
var3 = this.lastType;
|
|
if ("trak".equals(var3)) {
|
|
var5 = 1727192512;
|
|
} else {
|
|
var5 = -422340387;
|
|
}
|
|
break;
|
|
case 692881069:
|
|
var5 = -301528956;
|
|
break;
|
|
case 717544781:
|
|
this.parseTrak(var2);
|
|
var5 = 692881069;
|
|
break;
|
|
case 1727192512:
|
|
if (this.codecConfig == null) {
|
|
var5 = 717544781;
|
|
} else {
|
|
var5 = -422340387;
|
|
}
|
|
break;
|
|
case 2059330867:
|
|
if (var2.hasRemaining()) {
|
|
var5 = -2104894051;
|
|
} else {
|
|
var5 = 692881069;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void parseTrak(ByteBuffer var1) throws IOException {
|
|
ByteBuffer var2 = this.findChild(var1, "mdia");
|
|
if (var2 != null) {
|
|
ByteBuffer var3 = this.findChild(var2.duplicate(), "mdhd");
|
|
ByteBuffer var4 = this.findChild(var2.duplicate(), "minf");
|
|
ByteBuffer var5 = var4 == null ? null : this.findChild(var4, "stbl");
|
|
ByteBuffer var6 = var5 == null ? null : this.findChild(var5, "stsd");
|
|
if (var3 != null && var6 != null) {
|
|
int var7 = var3.get() & 255;
|
|
var3.position(
|
|
var3.position()
|
|
+ (-685824852 | 685824856)
|
|
+ (-685824852 & 685824856)
|
|
- ((-1401865506 ^ 1401865507) + ((-1401865506 & 1401865507) << 1))
|
|
+ (
|
|
var7 == 1? 16: (693468506 ^ -693468498) + ((693468506 & -693468498) << 1)
|
|
)
|
|
);
|
|
this.timescale = var3.getInt();
|
|
var6.position(var6.position() + (876033248 | -876033244) + (876033248 & -876033244) + (865572086 | -865572082) + (865572086 & -865572082));
|
|
ByteBuffer var8 = this.nextChild(var6);
|
|
String var9 = this.lastType;
|
|
if (!"avc1".equals(var9)
|
|
&& !"avc3".equals(var9)) {
|
|
if ("mp4a".equals(var9)) {
|
|
var8.position(var8.position() + (-1695756714 | 1695756742) + (-1695756714 & 1695756742));
|
|
ByteBuffer var11 = this.findChild(var8, "esds");
|
|
if (var11 != null) {
|
|
var11.position(var11.position() + (-1674133520 ^ 1674133524) + ((-1674133520 & 1674133524) << 1));
|
|
this.codecConfig = audioSpecificConfig(var11);
|
|
this.video = (boolean)(((0)) != 0);
|
|
}
|
|
}
|
|
} else {
|
|
var8.position(var8.position() + (-566438694 ^ 566438772) + ((-566438694 & 566438772) << 1));
|
|
ByteBuffer var10 = this.findChild(var8, "avcC");
|
|
if (var10 != null) {
|
|
this.video = (boolean)(((1)) != 0);
|
|
this.codecConfig = bytes(var10);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static byte[] audioSpecificConfig(ByteBuffer var0) throws IOException {
|
|
int var1 = 0;
|
|
int var2 = 0;
|
|
B var3 = null;
|
|
int var4 = -1096445122;
|
|
|
|
while (true) {
|
|
switch (var4) {
|
|
case -1997685852:
|
|
if (var2 > var0.remaining()) {
|
|
var4 = -1764616459;
|
|
} else {
|
|
var4 = -1968286316;
|
|
}
|
|
break;
|
|
case -1968286316:
|
|
var3 = new byte[var2];
|
|
var0.get((byte[])var3);
|
|
return (byte[])var3;
|
|
case -1764616459:
|
|
throw new IOException(
|
|
"malformed mp4 box esds"
|
|
);
|
|
case -1305548382:
|
|
var2 = descriptorLength(var0);
|
|
if (var2 > 0) {
|
|
var4 = -1997685852;
|
|
} else {
|
|
var4 = -1764616459;
|
|
}
|
|
break;
|
|
case -1204162978:
|
|
throw new IOException("malformed mp4 box esds");
|
|
case -1119606006:
|
|
if ((var1 & (-1309597121 | 1309597185) + (-1309597121 & 1309597185)) != 0) {
|
|
var4 = 1774782979;
|
|
} else {
|
|
var4 = 832155241;
|
|
}
|
|
break;
|
|
case -1096445122:
|
|
default:
|
|
if ((var0.get() & (1483213758 ^ -1483213503) + ((1483213758 & -1483213503) << 1)) != (988814225 ^ -988814222) + ((988814225 & -988814222) << 1)) {
|
|
var4 = -1204162978;
|
|
} else {
|
|
var4 = 1190173442;
|
|
}
|
|
break;
|
|
case -749808190:
|
|
throw new IOException(
|
|
"malformed mp4 box esds"
|
|
);
|
|
case -269512334:
|
|
var0.getShort();
|
|
var4 = -195629486;
|
|
break;
|
|
case -195629486:
|
|
if ((var0.get() & (229069346 | -229069091) + (229069346 & -229069091)) != (-125974441 ^ 125974445) + ((-125974441 & 125974445) << 1)) {
|
|
var4 = 1409742169;
|
|
} else {
|
|
var4 = 587537308;
|
|
}
|
|
break;
|
|
case 431210569:
|
|
var0.getShort();
|
|
var4 = -1119606006;
|
|
break;
|
|
case 587537308:
|
|
descriptorLength(var0);
|
|
var0.position(var0.position() + (213567955 ^ -213567942) + ((213567955 & -213567942) << 1));
|
|
if ((var0.get() & (-1603401203 | 1603401458) + (-1603401203 & 1603401458)) != (1561493147 ^ -1561493142) + ((1561493147 & -1561493142) << 1)) {
|
|
var4 = -749808190;
|
|
} else {
|
|
var4 = -1305548382;
|
|
}
|
|
break;
|
|
case 832155241:
|
|
if ((var1 & (-41635529 ^ 41635561) + ((-41635529 & 41635561) << 1)) != 0) {
|
|
var4 = -269512334;
|
|
} else {
|
|
var4 = -195629486;
|
|
}
|
|
break;
|
|
case 1190173442:
|
|
descriptorLength(var0);
|
|
var0.getShort();
|
|
var1 = var0.get() & 255;
|
|
if ((var1 & (-1389192563 | 1389192691) + (-1389192563 & 1389192691)) != 0) {
|
|
var4 = 431210569;
|
|
} else {
|
|
var4 = -1119606006;
|
|
}
|
|
break;
|
|
case 1409742169:
|
|
throw new IOException(
|
|
"malformed mp4 box esds"
|
|
);
|
|
case 1774782979:
|
|
var0.position(var0.position() + (var0.get() & (-489906828 | 489907083) + (-489906828 & 489907083)));
|
|
var4 = 832155241;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static int descriptorLength(ByteBuffer var0) {
|
|
int var1 = 0;
|
|
int var2 = 0;
|
|
int var3 = 0;
|
|
int var4 = 2036729414;
|
|
|
|
while (true) {
|
|
switch (var4) {
|
|
case -1873015505:
|
|
var2++;
|
|
var4 = 1237330076;
|
|
break;
|
|
case -1441293489:
|
|
return var1;
|
|
case -1044781650:
|
|
var4 = -1441293489;
|
|
break;
|
|
case -346707391:
|
|
var3 = var0.get() & 255;
|
|
var1 = var1 << (2061741280 | -2061741273) + (2061741280 & -2061741273) | var3 & 127;
|
|
if ((var3 & (635745314 ^ -635745186) + ((635745314 & -635745186) << 1)) == 0) {
|
|
var4 = -1044781650;
|
|
} else {
|
|
var4 = -1873015505;
|
|
}
|
|
break;
|
|
case 1237330076:
|
|
if (var2 < (1194279294 | -1194279290) + (1194279294 & -1194279290)) {
|
|
var4 = -346707391;
|
|
} else {
|
|
var4 = -1441293489;
|
|
}
|
|
break;
|
|
case 2036729414:
|
|
default:
|
|
var1 = 0;
|
|
var2 = 0;
|
|
var4 = 1237330076;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void parseSidx(ByteBuffer var1, long var2) throws IOException {
|
|
int var4 = 0;
|
|
long var5 = (3831471514619511095L | -3831471514619511095L) + (3831471514619511095L & -3831471514619511095L);
|
|
long var7 = (1821138891753438902L | -1821138891753438902L) + (1821138891753438902L & -1821138891753438902L);
|
|
long var9 = (-1061455935572584451L | 1061455935572584451L) + (-1061455935572584451L & 1061455935572584451L);
|
|
int var11 = 0;
|
|
long var12 = (4171997177025757527L | -4171997177025757527L) + (4171997177025757527L & -4171997177025757527L);
|
|
long var14 = (-2460661822976514631L | 2460661822976514631L) + (-2460661822976514631L & 2460661822976514631L);
|
|
int var16 = 0;
|
|
long var17 = (-3780586801239854412L ^ 3780586801239854412L) + ((-3780586801239854412L & 3780586801239854412L) << 1);
|
|
long var19 = (3456051884729680349L | -3456051884729680349L) + (3456051884729680349L & -3456051884729680349L);
|
|
long var22 = (3128965157428713979L ^ -3128965157428713979L) + ((3128965157428713979L & -3128965157428713979L) << 1);
|
|
long var24 = (-8517966229240719283L | 8517966229240719283L) + (-8517966229240719283L & 8517966229240719283L);
|
|
int var21 = 1929521438;
|
|
|
|
while (true) {
|
|
switch (var21) {
|
|
case -2138543696:
|
|
var22 = Integer.toUnsignedLong(var1.getInt());
|
|
var21 = -2078374584;
|
|
break;
|
|
case -2078374584:
|
|
var7 = var22;
|
|
if (var4 == 0) {
|
|
var21 = 611360565;
|
|
} else {
|
|
var21 = 825211583;
|
|
}
|
|
break;
|
|
case -1968474426:
|
|
return;
|
|
case -1836119336:
|
|
throw new IOException(
|
|
"stream has no segment index"
|
|
);
|
|
case -1737082648:
|
|
var12 = var2 + var9;
|
|
var14 = var7;
|
|
var16 = 0;
|
|
var21 = -824854579;
|
|
break;
|
|
case -1439015422:
|
|
var9 = var24;
|
|
var1.getShort();
|
|
var11 = var1.getShort() & 65535;
|
|
if (var5 > (8413449736749540036L ^ -8413449736749540036L) + ((8413449736749540036L & -8413449736749540036L) << 1)) {
|
|
var21 = 344581089;
|
|
} else {
|
|
var21 = -1836119336;
|
|
}
|
|
break;
|
|
case -824854579:
|
|
if (var16 < var11) {
|
|
var21 = 101280181;
|
|
} else {
|
|
var21 = -1968474426;
|
|
}
|
|
break;
|
|
case -290906332:
|
|
var22 = var1.getLong();
|
|
var21 = -2078374584;
|
|
break;
|
|
case 101280181:
|
|
var17 = var1.getInt() & 2147483647;
|
|
var19 = Integer.toUnsignedLong(var1.getInt());
|
|
var1.getInt();
|
|
this.segments
|
|
.add(new anr(var12, var14 * ((5500300374376334535L | -5500300374376333535L) + (5500300374376334535L & -5500300374376333535L)) / var5));
|
|
var12 += var17;
|
|
var14 += var19;
|
|
var16++;
|
|
var21 = -824854579;
|
|
break;
|
|
case 344581089:
|
|
if (var11 == 0) {
|
|
var21 = -1836119336;
|
|
} else {
|
|
var21 = -1737082648;
|
|
}
|
|
break;
|
|
case 611360565:
|
|
var24 = Integer.toUnsignedLong(var1.getInt());
|
|
var21 = -1439015422;
|
|
break;
|
|
case 825211583:
|
|
var24 = var1.getLong();
|
|
var21 = -1439015422;
|
|
break;
|
|
case 1929521438:
|
|
default:
|
|
var4 = var1.get() & 255;
|
|
var1.position(
|
|
var1.position() + (-1280611948 | 1280611952) + (-1280611948 & 1280611952) - ((980245715 ^ -980245714) + ((980245715 & -980245714) << 1))
|
|
);
|
|
var1.getInt();
|
|
var5 = Integer.toUnsignedLong(var1.getInt());
|
|
if (var4 == 0) {
|
|
var21 = -2138543696;
|
|
} else {
|
|
var21 = -290906332;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void parseTraf(ByteBuffer var1, long var2, List<anq> var4) throws IOException {
|
|
long var5 = var2;
|
|
long var7 = (-4904487195750384624L | 4904487195750384624L) + (-4904487195750384624L & 4904487195750384624L);
|
|
int var9 = this.trackDefaults.duration();
|
|
int var10 = this.trackDefaults.size();
|
|
int var11 = this.trackDefaults.flags();
|
|
ArrayList var12 = new ArrayList();
|
|
|
|
while (var1.hasRemaining()) {
|
|
ByteBuffer var13 = this.nextChild(var1);
|
|
String var14 = this.lastType;
|
|
if ("tfhd".equals(var14)) {
|
|
int var15 = var13.getInt() & 16777215;
|
|
var13.getInt();
|
|
if ((var15 & (-2116886066 ^ 2116886067) + ((-2116886066 & 2116886067) << 1)) != 0) {
|
|
var5 = var13.getLong();
|
|
}
|
|
|
|
if ((var15 & (568500500 ^ -568500498) + ((568500500 & -568500498) << 1)) != 0) {
|
|
var13.getInt();
|
|
}
|
|
|
|
if ((var15 & (1768970636 | -1768970628) + (1768970636 & -1768970628)) != 0) {
|
|
var9 = var13.getInt();
|
|
}
|
|
|
|
if ((var15 & (728567715 ^ -728567699) + ((728567715 & -728567699) << 1)) != 0) {
|
|
var10 = var13.getInt();
|
|
}
|
|
|
|
if ((var15 & (1214956429 | -1214956397) + (1214956429 & -1214956397)) != 0) {
|
|
var11 = var13.getInt();
|
|
}
|
|
} else if ("tfdt".equals(var14)) {
|
|
int var30 = var13.getInt() >>> 24;
|
|
var7 = var30 == 1? var13.getLong() : Integer.toUnsignedLong(var13.getInt());
|
|
} else if ("trun".equals(var14)) {
|
|
var12.add(var13);
|
|
}
|
|
}
|
|
|
|
for (ByteBuffer var29 : (Iterable<ByteBuffer>)var12) {
|
|
int var31 = var29.getInt();
|
|
int var16 = var31 & 16777215;
|
|
int var17 = var29.getInt();
|
|
long var18 = var5;
|
|
if ((var16 & (-130552350 | 130552351) + (-130552350 & 130552351)) != 0) {
|
|
var18 = var5 + var29.getInt();
|
|
}
|
|
|
|
int var20 = (var16 & (800770923 ^ -800770919) + ((800770923 & -800770919) << 1)) != 0
|
|
? var29.getInt()
|
|
: -1;
|
|
|
|
for (int var21 = 0; var21 < var17; var21++) {
|
|
int var22 = (var16 & (-1770260101 | 1770260357) + (-1770260101 & 1770260357)) != 0 ? var29.getInt() : var9;
|
|
int var23 = (var16 & (890095412 | -890094900) + (890095412 & -890094900)) != 0 ? var29.getInt() : var10;
|
|
int var24 = (var16 & (-37984295 ^ 37985319) + ((-37984295 & 37985319) << 1)) != 0 ? var29.getInt() : (var21 == 0 && var20 >= 0 ? var20 : var11);
|
|
int var25 = (var16 & (-1137172152 | 1137174200) + (-1137172152 & 1137174200)) != 0
|
|
? var29.getInt()
|
|
: 0;
|
|
long var26 = (var7 + var25)
|
|
* ((8324970555036979122L ^ -8324970555036978122L) + ((8324970555036979122L & -8324970555036978122L) << 1))
|
|
/ this.timescale;
|
|
var4.add(
|
|
new anq(
|
|
var26,
|
|
var18,
|
|
var23,
|
|
(boolean)((((var24 & (-171303705 | 171369241) + (-171303705 & 171369241)) == 0
|
|
? 1: (2018186926 | -2018186926) + (2018186926 & -2018186926))
|
|
) != 0))
|
|
);
|
|
var18 += Integer.toUnsignedLong(var23);
|
|
var7 += Integer.toUnsignedLong(var22);
|
|
}
|
|
}
|
|
}
|
|
|
|
private long[] readHeader(long var1) throws IOException {
|
|
ByteBuffer var3 = null;
|
|
long var4 = (3231648927111230452L ^ -3231648927111230452L) + ((3231648927111230452L & -3231648927111230452L) << 1);
|
|
int var6 = -423888311;
|
|
|
|
while (true) {
|
|
switch (var6) {
|
|
case -805875744:
|
|
long[] var7 = new long[2];
|
|
var7[0] = var4;
|
|
var7[1] = (7320995526534565662L | -7320995526534565654L)
|
|
+ (7320995526534565662L & -7320995526534565654L);
|
|
return var7;
|
|
case -423888311:
|
|
default:
|
|
var3 = ByteBuffer.allocate((2143588260 | -2143588244) + (2143588260 & -2143588244));
|
|
var3.limit((1540542962 | -1540542954) + (1540542962 & -1540542954));
|
|
this.channel.setPosition(var1);
|
|
this.readFully(var3);
|
|
var3.flip();
|
|
var4 = Integer.toUnsignedLong(var3.getInt());
|
|
this.headerType = fourcc(var3);
|
|
if (var4 == (-6814894446849728777L ^ 6814894446849728778L) + ((-6814894446849728777L & 6814894446849728778L) << 1)) {
|
|
var6 = 804506090;
|
|
} else {
|
|
var6 = -805875744;
|
|
}
|
|
break;
|
|
case 804506090:
|
|
var3.clear();
|
|
var3.limit((-877307175 ^ 877307183) + ((-877307175 & 877307183) << 1));
|
|
this.readFully(var3);
|
|
var3.flip();
|
|
long[] var10000 = new long[2];
|
|
var10000[0] = var3.getLong();
|
|
var10000[1] = (2434810948995596201L ^ -2434810948995596185L)
|
|
+ ((2434810948995596201L & -2434810948995596185L) << 1);
|
|
return var10000;
|
|
}
|
|
}
|
|
}
|
|
|
|
private ByteBuffer readBox(long var1, String var3, int var4) throws IOException {
|
|
long[] var5 = null;
|
|
int var6 = -1621090942;
|
|
|
|
while (true) {
|
|
switch (var6) {
|
|
case -1621090942:
|
|
default:
|
|
var5 = this.readHeader(var1);
|
|
if (var3.equals(this.headerType)) {
|
|
var6 = -906418742;
|
|
} else {
|
|
var6 = 1007665017;
|
|
}
|
|
break;
|
|
case -1219065191:
|
|
return this.readBody(
|
|
var1 + var5[1],
|
|
var5[0] - var5[1]
|
|
);
|
|
case -906418742:
|
|
if (var5[0] >= var5[1]) {
|
|
var6 = 1048125538;
|
|
} else {
|
|
var6 = 1007665017;
|
|
}
|
|
break;
|
|
case 1007665017:
|
|
throw new IOException("malformed mp4 box " + this.headerType);
|
|
case 1048125538:
|
|
if (var5[0] > var4) {
|
|
var6 = 1007665017;
|
|
} else {
|
|
var6 = -1219065191;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private ByteBuffer readBody(long var1, long var3) throws IOException {
|
|
ByteBuffer var5 = null;
|
|
int var6 = 1236545215;
|
|
|
|
while (true) {
|
|
switch (var6) {
|
|
case -814841221:
|
|
var5 = ByteBuffer.allocate((int)var3);
|
|
this.channel.setPosition(var1);
|
|
this.readFully(var5);
|
|
var5.flip();
|
|
return var5;
|
|
case 861717400:
|
|
throw new IOException("malformed mp4 box " + this.headerType);
|
|
case 1236545215:
|
|
}
|
|
|
|
if (var3 > (7571846619419810277L ^ -7571846619411421669L) + ((7571846619419810277L & -7571846619411421669L) << 1)) {
|
|
var6 = 861717400;
|
|
} else {
|
|
var6 = -814841221;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void readFully(ByteBuffer var1) throws IOException {
|
|
int var2 = 653934146;
|
|
|
|
while (true) {
|
|
switch (var2) {
|
|
case -1123486463:
|
|
if (this.channel.read(var1) < 0) {
|
|
var2 = 1565434703;
|
|
} else {
|
|
var2 = 653934146;
|
|
}
|
|
break;
|
|
case -835982463:
|
|
return;
|
|
case 653934146:
|
|
default:
|
|
if (var1.hasRemaining()) {
|
|
var2 = -1123486463;
|
|
} else {
|
|
var2 = -835982463;
|
|
}
|
|
break;
|
|
case 1565434703:
|
|
throw new IOException("malformed mp4 box " + this.headerType);
|
|
}
|
|
}
|
|
}
|
|
|
|
private ByteBuffer nextChild(ByteBuffer var1) throws IOException {
|
|
long var2 = (-2503122657854808208L ^ 2503122657854808208L) + ((-2503122657854808208L & 2503122657854808208L) << 1);
|
|
int var4 = 0;
|
|
long var5 = (-236149922448909385L | 236149922448909385L) + (-236149922448909385L & 236149922448909385L);
|
|
ByteBuffer var7 = null;
|
|
int var8 = -1972605173;
|
|
|
|
while (true) {
|
|
switch (var8) {
|
|
case -1993588768:
|
|
var5 = var2 - var4;
|
|
if (var5 >= (165396616700685102L ^ -165396616700685102L) + ((165396616700685102L & -165396616700685102L) << 1)) {
|
|
var8 = 1518288467;
|
|
} else {
|
|
var8 = 808143016;
|
|
}
|
|
break;
|
|
case -1972605173:
|
|
default:
|
|
if (var1.remaining() < (-1877086113 ^ 1877086121) + ((-1877086113 & 1877086121) << 1)) {
|
|
var8 = -255762832;
|
|
} else {
|
|
var8 = -1081115078;
|
|
}
|
|
break;
|
|
case -1764455227:
|
|
var7 = var1.slice(var1.position(), (int)var5);
|
|
var1.position(var1.position() + (int)var5);
|
|
return var7;
|
|
case -1081115078:
|
|
var2 = Integer.toUnsignedLong(var1.getInt());
|
|
this.lastType = fourcc(var1);
|
|
var4 = 8;
|
|
if (var2 == (1720352128774993448L ^ -1720352128774993447L) + ((1720352128774993448L & -1720352128774993447L) << 1)) {
|
|
var8 = 962253841;
|
|
} else {
|
|
var8 = 383432441;
|
|
}
|
|
break;
|
|
case -255762832:
|
|
this.lastType = "";
|
|
var1.position(var1.limit());
|
|
return ByteBuffer.allocate((-2019184955 ^ 2019184955) + ((-2019184955 & 2019184955) << 1));
|
|
case 383432441:
|
|
if (var2 == (-3879194029498667517L ^ 3879194029498667517L) + ((-3879194029498667517L & 3879194029498667517L) << 1)) {
|
|
var8 = 1066781826;
|
|
} else {
|
|
var8 = -1993588768;
|
|
}
|
|
break;
|
|
case 808143016:
|
|
throw new IOException("malformed mp4 box " + this.lastType);
|
|
case 962253841:
|
|
var2 = var1.getLong();
|
|
var4 = 16;
|
|
var8 = -1993588768;
|
|
break;
|
|
case 1066781826:
|
|
var2 = (long)var1.remaining() + var4;
|
|
var8 = -1993588768;
|
|
break;
|
|
case 1518288467:
|
|
if (var5 > var1.remaining()) {
|
|
var8 = 808143016;
|
|
} else {
|
|
var8 = -1764455227;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private ByteBuffer findChild(ByteBuffer var1, String var2) throws IOException {
|
|
ByteBuffer var3 = null;
|
|
int var4 = -1123289809;
|
|
|
|
while (true) {
|
|
switch (var4) {
|
|
case -1774680113:
|
|
return null;
|
|
case -1123289809:
|
|
default:
|
|
if (var1.hasRemaining()) {
|
|
var4 = 71772650;
|
|
} else {
|
|
var4 = -1774680113;
|
|
}
|
|
break;
|
|
case 71772650:
|
|
var3 = this.nextChild(var1);
|
|
if (var2.equals(this.lastType)) {
|
|
var4 = 1134754558;
|
|
} else {
|
|
var4 = 1713597196;
|
|
}
|
|
break;
|
|
case 1134754558:
|
|
return var3;
|
|
case 1713597196:
|
|
var4 = -1123289809;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static String fourcc(ByteBuffer var0) {
|
|
char[] var1 = null;
|
|
int var2 = 0;
|
|
int var3 = 1310070610;
|
|
|
|
while (true) {
|
|
switch (var3) {
|
|
case 899162500:
|
|
var1[var2] = (char)(var0.get() & (-1682982377 | 1682982632) + (-1682982377 & 1682982632));
|
|
var2++;
|
|
var3 = 1477720923;
|
|
break;
|
|
case 1310070610:
|
|
default:
|
|
var1 = new char[4];
|
|
var2 = 0;
|
|
var3 = 1477720923;
|
|
break;
|
|
case 1344566532:
|
|
return new String(var1);
|
|
case 1477720923:
|
|
if (var2 < var1.length) {
|
|
var3 = 899162500;
|
|
} else {
|
|
var3 = 1344566532;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static byte[] bytes(ByteBuffer var0) {
|
|
byte[] var1 = new byte[var0.remaining()];
|
|
var0.get(var1);
|
|
return var1;
|
|
}
|
|
}
|