Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/g0/C0373a.java

@@ -0,0 +1,60 @@
+package g0;
+
+import android.media.MediaDataSource;
+import java.io.IOException;
+
+/* renamed from: g0.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0373a extends MediaDataSource {
+
+    /* renamed from: a, reason: collision with root package name */
+    public long f6680a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ f f6681b;
+
+    public C0373a(f fVar) {
+        this.f6681b = fVar;
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+    }
+
+    @Override // android.media.MediaDataSource
+    public final long getSize() {
+        return -1L;
+    }
+
+    @Override // android.media.MediaDataSource
+    public final int readAt(long j4, byte[] bArr, int i, int i4) {
+        if (i4 == 0) {
+            return 0;
+        }
+        if (j4 < 0) {
+            return -1;
+        }
+        try {
+            long j5 = this.f6680a;
+            f fVar = this.f6681b;
+            if (j5 != j4) {
+                if (j5 >= 0 && j4 >= j5 + fVar.f6684a.available()) {
+                    return -1;
+                }
+                fVar.e(j4);
+                this.f6680a = j4;
+            }
+            if (i4 > fVar.f6684a.available()) {
+                i4 = fVar.f6684a.available();
+            }
+            int read = fVar.read(bArr, i, i4);
+            if (read >= 0) {
+                this.f6680a += read;
+                return read;
+            }
+        } catch (IOException unused) {
+        }
+        this.f6680a = -1L;
+        return -1;
+    }
+}

apk_decompiled/sources/g0/b.java

@@ -0,0 +1,268 @@
+package g0;
+
+import C.w;
+import android.util.Log;
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteOrder;
+
+/* loaded from: classes.dex */
+public class b extends InputStream implements DataInput {
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final ByteOrder f6682e = ByteOrder.LITTLE_ENDIAN;
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final ByteOrder f6683f = ByteOrder.BIG_ENDIAN;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final DataInputStream f6684a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public ByteOrder f6685b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f6686c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public byte[] f6687d;
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public b(byte[] r2) {
+        /*
+            r1 = this;
+            java.io.ByteArrayInputStream r0 = new java.io.ByteArrayInputStream
+            r0.<init>(r2)
+            java.nio.ByteOrder r2 = java.nio.ByteOrder.BIG_ENDIAN
+            r2 = 0
+            r1.<init>(r0, r2)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: g0.b.<init>(byte[]):void");
+    }
+
+    @Override // java.io.InputStream
+    public final int available() {
+        return this.f6684a.available();
+    }
+
+    public final void d(int i) {
+        int i4 = 0;
+        while (i4 < i) {
+            DataInputStream dataInputStream = this.f6684a;
+            int i5 = i - i4;
+            int skip = (int) dataInputStream.skip(i5);
+            if (skip <= 0) {
+                if (this.f6687d == null) {
+                    this.f6687d = new byte[8192];
+                }
+                skip = dataInputStream.read(this.f6687d, 0, Math.min(8192, i5));
+                if (skip == -1) {
+                    throw new EOFException(w.i(i, "Reached EOF while skipping ", " bytes."));
+                }
+            }
+            i4 += skip;
+        }
+        this.f6686c += i4;
+    }
+
+    @Override // java.io.InputStream
+    public final void mark(int i) {
+        throw new UnsupportedOperationException("Mark is currently unsupported");
+    }
+
+    @Override // java.io.InputStream
+    public final int read() {
+        this.f6686c++;
+        return this.f6684a.read();
+    }
+
+    @Override // java.io.DataInput
+    public final boolean readBoolean() {
+        this.f6686c++;
+        return this.f6684a.readBoolean();
+    }
+
+    @Override // java.io.DataInput
+    public final byte readByte() {
+        this.f6686c++;
+        int read = this.f6684a.read();
+        if (read >= 0) {
+            return (byte) read;
+        }
+        throw new EOFException();
+    }
+
+    @Override // java.io.DataInput
+    public final char readChar() {
+        this.f6686c += 2;
+        return this.f6684a.readChar();
+    }
+
+    @Override // java.io.DataInput
+    public final double readDouble() {
+        return Double.longBitsToDouble(readLong());
+    }
+
+    @Override // java.io.DataInput
+    public final float readFloat() {
+        return Float.intBitsToFloat(readInt());
+    }
+
+    @Override // java.io.DataInput
+    public final void readFully(byte[] bArr, int i, int i4) {
+        this.f6686c += i4;
+        this.f6684a.readFully(bArr, i, i4);
+    }
+
+    @Override // java.io.DataInput
+    public final int readInt() {
+        this.f6686c += 4;
+        DataInputStream dataInputStream = this.f6684a;
+        int read = dataInputStream.read();
+        int read2 = dataInputStream.read();
+        int read3 = dataInputStream.read();
+        int read4 = dataInputStream.read();
+        if ((read | read2 | read3 | read4) < 0) {
+            throw new EOFException();
+        }
+        ByteOrder byteOrder = this.f6685b;
+        if (byteOrder == f6682e) {
+            return (read4 << 24) + (read3 << 16) + (read2 << 8) + read;
+        }
+        if (byteOrder == f6683f) {
+            return (read << 24) + (read2 << 16) + (read3 << 8) + read4;
+        }
+        throw new IOException("Invalid byte order: " + this.f6685b);
+    }
+
+    @Override // java.io.DataInput
+    public final String readLine() {
+        Log.d("ExifInterface", "Currently unsupported");
+        return null;
+    }
+
+    @Override // java.io.DataInput
+    public final long readLong() {
+        this.f6686c += 8;
+        DataInputStream dataInputStream = this.f6684a;
+        int read = dataInputStream.read();
+        int read2 = dataInputStream.read();
+        int read3 = dataInputStream.read();
+        int read4 = dataInputStream.read();
+        int read5 = dataInputStream.read();
+        int read6 = dataInputStream.read();
+        int read7 = dataInputStream.read();
+        int read8 = dataInputStream.read();
+        if ((read | read2 | read3 | read4 | read5 | read6 | read7 | read8) < 0) {
+            throw new EOFException();
+        }
+        ByteOrder byteOrder = this.f6685b;
+        if (byteOrder == f6682e) {
+            return (read8 << 56) + (read7 << 48) + (read6 << 40) + (read5 << 32) + (read4 << 24) + (read3 << 16) + (read2 << 8) + read;
+        }
+        if (byteOrder == f6683f) {
+            return (read << 56) + (read2 << 48) + (read3 << 40) + (read4 << 32) + (read5 << 24) + (read6 << 16) + (read7 << 8) + read8;
+        }
+        throw new IOException("Invalid byte order: " + this.f6685b);
+    }
+
+    @Override // java.io.DataInput
+    public final short readShort() {
+        int i;
+        this.f6686c += 2;
+        DataInputStream dataInputStream = this.f6684a;
+        int read = dataInputStream.read();
+        int read2 = dataInputStream.read();
+        if ((read | read2) < 0) {
+            throw new EOFException();
+        }
+        ByteOrder byteOrder = this.f6685b;
+        if (byteOrder == f6682e) {
+            i = (read2 << 8) + read;
+        } else {
+            if (byteOrder != f6683f) {
+                throw new IOException("Invalid byte order: " + this.f6685b);
+            }
+            i = (read << 8) + read2;
+        }
+        return (short) i;
+    }
+
+    @Override // java.io.DataInput
+    public final String readUTF() {
+        this.f6686c += 2;
+        return this.f6684a.readUTF();
+    }
+
+    @Override // java.io.DataInput
+    public final int readUnsignedByte() {
+        this.f6686c++;
+        return this.f6684a.readUnsignedByte();
+    }
+
+    @Override // java.io.DataInput
+    public final int readUnsignedShort() {
+        this.f6686c += 2;
+        DataInputStream dataInputStream = this.f6684a;
+        int read = dataInputStream.read();
+        int read2 = dataInputStream.read();
+        if ((read | read2) < 0) {
+            throw new EOFException();
+        }
+        ByteOrder byteOrder = this.f6685b;
+        if (byteOrder == f6682e) {
+            return (read2 << 8) + read;
+        }
+        if (byteOrder == f6683f) {
+            return (read << 8) + read2;
+        }
+        throw new IOException("Invalid byte order: " + this.f6685b);
+    }
+
+    @Override // java.io.InputStream
+    public final void reset() {
+        throw new UnsupportedOperationException("Reset is currently unsupported");
+    }
+
+    @Override // java.io.DataInput
+    public final int skipBytes(int i) {
+        throw new UnsupportedOperationException("skipBytes is currently unsupported");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public b(InputStream inputStream) {
+        this(inputStream, 0);
+        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
+    }
+
+    public b(InputStream inputStream, int i) {
+        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
+        this.f6685b = byteOrder;
+        DataInputStream dataInputStream = new DataInputStream(inputStream);
+        this.f6684a = dataInputStream;
+        dataInputStream.mark(0);
+        this.f6686c = 0;
+        this.f6685b = byteOrder;
+    }
+
+    @Override // java.io.InputStream
+    public final int read(byte[] bArr, int i, int i4) {
+        int read = this.f6684a.read(bArr, i, i4);
+        this.f6686c += read;
+        return read;
+    }
+
+    @Override // java.io.DataInput
+    public final void readFully(byte[] bArr) {
+        this.f6686c += bArr.length;
+        this.f6684a.readFully(bArr);
+    }
+}

apk_decompiled/sources/g0/c.java

@@ -0,0 +1,206 @@
+package g0;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes.dex */
+public final class c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f6688a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final int f6689b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final long f6690c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final byte[] f6691d;
+
+    public c(int i, int i4, byte[] bArr) {
+        this(-1L, bArr, i, i4);
+    }
+
+    public static c a(long j4, ByteOrder byteOrder) {
+        long[] jArr = {j4};
+        ByteBuffer wrap = ByteBuffer.wrap(new byte[g.f6702E[4]]);
+        wrap.order(byteOrder);
+        wrap.putInt((int) jArr[0]);
+        return new c(4, 1, wrap.array());
+    }
+
+    public static c b(e eVar, ByteOrder byteOrder) {
+        ByteBuffer wrap = ByteBuffer.wrap(new byte[g.f6702E[5]]);
+        wrap.order(byteOrder);
+        e eVar2 = new e[]{eVar}[0];
+        wrap.putInt((int) eVar2.f6696a);
+        wrap.putInt((int) eVar2.f6697b);
+        return new c(5, 1, wrap.array());
+    }
+
+    public static c c(int i, ByteOrder byteOrder) {
+        ByteBuffer wrap = ByteBuffer.wrap(new byte[g.f6702E[3]]);
+        wrap.order(byteOrder);
+        wrap.putShort((short) new int[]{i}[0]);
+        return new c(3, 1, wrap.array());
+    }
+
+    public final double d(ByteOrder byteOrder) {
+        Object g4 = g(byteOrder);
+        if (g4 == null) {
+            throw new NumberFormatException("NULL can't be converted to a double value");
+        }
+        if (g4 instanceof String) {
+            return Double.parseDouble((String) g4);
+        }
+        if (g4 instanceof long[]) {
+            if (((long[]) g4).length == 1) {
+                return r3[0];
+            }
+            throw new NumberFormatException("There are more than one component");
+        }
+        if (g4 instanceof int[]) {
+            if (((int[]) g4).length == 1) {
+                return r3[0];
+            }
+            throw new NumberFormatException("There are more than one component");
+        }
+        if (g4 instanceof double[]) {
+            double[] dArr = (double[]) g4;
+            if (dArr.length == 1) {
+                return dArr[0];
+            }
+            throw new NumberFormatException("There are more than one component");
+        }
+        if (!(g4 instanceof e[])) {
+            throw new NumberFormatException("Couldn't find a double value");
+        }
+        e[] eVarArr = (e[]) g4;
+        if (eVarArr.length != 1) {
+            throw new NumberFormatException("There are more than one component");
+        }
+        e eVar = eVarArr[0];
+        return eVar.f6696a / eVar.f6697b;
+    }
+
+    public final int e(ByteOrder byteOrder) {
+        Object g4 = g(byteOrder);
+        if (g4 == null) {
+            throw new NumberFormatException("NULL can't be converted to a integer value");
+        }
+        if (g4 instanceof String) {
+            return Integer.parseInt((String) g4);
+        }
+        if (g4 instanceof long[]) {
+            long[] jArr = (long[]) g4;
+            if (jArr.length == 1) {
+                return (int) jArr[0];
+            }
+            throw new NumberFormatException("There are more than one component");
+        }
+        if (!(g4 instanceof int[])) {
+            throw new NumberFormatException("Couldn't find a integer value");
+        }
+        int[] iArr = (int[]) g4;
+        if (iArr.length == 1) {
+            return iArr[0];
+        }
+        throw new NumberFormatException("There are more than one component");
+    }
+
+    public final String f(ByteOrder byteOrder) {
+        Object g4 = g(byteOrder);
+        if (g4 == null) {
+            return null;
+        }
+        if (g4 instanceof String) {
+            return (String) g4;
+        }
+        StringBuilder sb = new StringBuilder();
+        int i = 0;
+        if (g4 instanceof long[]) {
+            long[] jArr = (long[]) g4;
+            while (i < jArr.length) {
+                sb.append(jArr[i]);
+                i++;
+                if (i != jArr.length) {
+                    sb.append(",");
+                }
+            }
+            return sb.toString();
+        }
+        if (g4 instanceof int[]) {
+            int[] iArr = (int[]) g4;
+            while (i < iArr.length) {
+                sb.append(iArr[i]);
+                i++;
+                if (i != iArr.length) {
+                    sb.append(",");
+                }
+            }
+            return sb.toString();
+        }
+        if (g4 instanceof double[]) {
+            double[] dArr = (double[]) g4;
+            while (i < dArr.length) {
+                sb.append(dArr[i]);
+                i++;
+                if (i != dArr.length) {
+                    sb.append(",");
+                }
+            }
+            return sb.toString();
+        }
+        if (!(g4 instanceof e[])) {
+            return null;
+        }
+        e[] eVarArr = (e[]) g4;
+        while (i < eVarArr.length) {
+            sb.append(eVarArr[i].f6696a);
+            sb.append('/');
+            sb.append(eVarArr[i].f6697b);
+            i++;
+            if (i != eVarArr.length) {
+                sb.append(",");
+            }
+        }
+        return sb.toString();
+    }
+
+    /* JADX WARN: Not initialized variable reg: 6, insn: 0x0033: MOVE (r5 I:??[OBJECT, ARRAY]) = (r6 I:??[OBJECT, ARRAY]), block:B:162:0x0033 */
+    /* JADX WARN: Removed duplicated region for block: B:165:0x016d A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    /* JADX WARN: Type inference failed for: r14v14, types: [int[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v15, types: [long[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v16, types: [g0.e[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v17, types: [int[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v18, types: [int[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v19, types: [g0.e[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v20, types: [double[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v21, types: [double[], java.io.Serializable] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.io.Serializable g(java.nio.ByteOrder r14) {
+        /*
+            Method dump skipped, instructions count: 402
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: g0.c.g(java.nio.ByteOrder):java.io.Serializable");
+    }
+
+    public final String toString() {
+        StringBuilder sb = new StringBuilder("(");
+        sb.append(g.f6701D[this.f6688a]);
+        sb.append(", data length:");
+        return com.google.android.gms.measurement.internal.a.m(sb, this.f6691d.length, ")");
+    }
+
+    public c(long j4, byte[] bArr, int i, int i4) {
+        this.f6688a = i;
+        this.f6689b = i4;
+        this.f6690c = j4;
+        this.f6691d = bArr;
+    }
+}

apk_decompiled/sources/g0/d.java

@@ -0,0 +1,31 @@
+package g0;
+
+/* loaded from: classes.dex */
+public final class d {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f6692a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final String f6693b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final int f6694c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final int f6695d;
+
+    public d(String str, int i, int i4) {
+        this.f6693b = str;
+        this.f6692a = i;
+        this.f6694c = i4;
+        this.f6695d = -1;
+    }
+
+    public d(String str, int i, int i4, int i5) {
+        this.f6693b = str;
+        this.f6692a = i;
+        this.f6694c = i4;
+        this.f6695d = i5;
+    }
+}

apk_decompiled/sources/g0/e.java

@@ -0,0 +1,27 @@
+package g0;
+
+import com.google.firebase.sessions.settings.RemoteSettings;
+
+/* loaded from: classes.dex */
+public final class e {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final long f6696a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final long f6697b;
+
+    public e(long j4, long j5) {
+        if (j5 == 0) {
+            this.f6696a = 0L;
+            this.f6697b = 1L;
+        } else {
+            this.f6696a = j4;
+            this.f6697b = j5;
+        }
+    }
+
+    public final String toString() {
+        return this.f6696a + RemoteSettings.FORWARD_SLASH_STRING + this.f6697b;
+    }
+}

apk_decompiled/sources/g0/f.java

@@ -0,0 +1,31 @@
+package g0;
+
+import java.io.InputStream;
+
+/* loaded from: classes.dex */
+public final class f extends b {
+    public f(byte[] bArr) {
+        super(bArr);
+        this.f6684a.mark(Integer.MAX_VALUE);
+    }
+
+    public final void e(long j4) {
+        int i = this.f6686c;
+        if (i > j4) {
+            this.f6686c = 0;
+            this.f6684a.reset();
+        } else {
+            j4 -= i;
+        }
+        d((int) j4);
+    }
+
+    public f(InputStream inputStream) {
+        super(inputStream);
+        if (inputStream.markSupported()) {
+            this.f6684a.mark(Integer.MAX_VALUE);
+            return;
+        }
+        throw new IllegalArgumentException("Cannot create SeekableByteOrderedDataInputStream with stream that does not support mark/reset");
+    }
+}

apk_decompiled/sources/g0/h.java

@@ -0,0 +1,20 @@
+package g0;
+
+import android.system.ErrnoException;
+import android.system.Os;
+import java.io.FileDescriptor;
+
+/* loaded from: classes.dex */
+public abstract class h {
+    public static void a(FileDescriptor fileDescriptor) throws ErrnoException {
+        Os.close(fileDescriptor);
+    }
+
+    public static FileDescriptor b(FileDescriptor fileDescriptor) throws ErrnoException {
+        return Os.dup(fileDescriptor);
+    }
+
+    public static long c(FileDescriptor fileDescriptor, long j4, int i) throws ErrnoException {
+        return Os.lseek(fileDescriptor, j4, i);
+    }
+}

apk_decompiled/sources/g0/i.java

@@ -0,0 +1,11 @@
+package g0;
+
+import android.media.MediaDataSource;
+import android.media.MediaMetadataRetriever;
+
+/* loaded from: classes.dex */
+public abstract class i {
+    public static void a(MediaMetadataRetriever mediaMetadataRetriever, MediaDataSource mediaDataSource) {
+        mediaMetadataRetriever.setDataSource(mediaDataSource);
+    }
+}