feat: add CW decoder and linear calculator page

feature/cw/src/main/java/k3/a.java

@@ -0,0 +1,11 @@
+package k3;
+
+import java.lang.Thread;
+
+/* loaded from: classes.dex */
+public final class a implements Thread.UncaughtExceptionHandler {
+    @Override // java.lang.Thread.UncaughtExceptionHandler
+    public final void uncaughtException(Thread thread, Throwable th) {
+        th.printStackTrace();
+    }
+}

feature/cw/src/main/java/k3/b.java

@@ -0,0 +1,25 @@
+package k3;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+
+/* loaded from: classes.dex */
+public final class b implements ThreadFactory {
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final ThreadFactory f12091b = Executors.defaultThreadFactory();
+
+    /* renamed from: a, reason: collision with root package name */
+    public final a f12092a;
+
+    public b(a aVar) {
+        this.f12092a = aVar;
+    }
+
+    @Override // java.util.concurrent.ThreadFactory
+    public final Thread newThread(Runnable runnable) {
+        Thread newThread = f12091b.newThread(runnable);
+        newThread.setUncaughtExceptionHandler(this.f12092a);
+        return newThread;
+    }
+}

feature/cw/src/main/java/k3/c.java

@@ -0,0 +1,42 @@
+package k3;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+/* loaded from: classes.dex */
+public abstract class c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final ExecutorService f12093a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public static ExecutorService f12094b;
+    public static final int c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public static final long f12095d;
+
+    /* JADX WARN: Type inference failed for: r1v0, types: [java.lang.Object, k3.a] */
+    static {
+        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool(new b(new a()));
+        f12093a = newCachedThreadPool;
+        f12094b = newCachedThreadPool;
+        c = Runtime.getRuntime().availableProcessors();
+        f12095d = 100000L;
+    }
+
+    public static Future a(Runnable runnable) {
+        if (f12094b.isShutdown() || f12094b.isTerminated()) {
+            f12094b = f12093a;
+        }
+        return f12094b.submit(runnable);
+    }
+
+    public static void b(Future[] futureArr) throws InterruptedException, java.util.concurrent.ExecutionException {
+        // smali: 无 catch 直接向上抛 -> Java 声明 throws(忠实表达)
+        for (Future future : futureArr) {
+            future.get();
+        }
+    }
+}

feature/cw/src/main/java/k3/d.java

@@ -0,0 +1,100 @@
+package k3;
+
+import com.rtbishop.look4sat.feature.cw.suncompat.Cleaner;
+
+/* loaded from: classes.dex */
+public final class d extends g {
+
+    /* renamed from: k, reason: collision with root package name */
+    public float[] f12096k;
+
+    public d() {
+    }
+
+    public d(long j4, boolean z3) {
+        this.f = q.f12106g;
+        this.f12103h = 4L;
+        if (j4 > 0) {
+            this.f12102g = j4;
+            if (j4 > 1073741824) {
+                this.f12105j = r.f12109a.allocateMemory(4 * j4);
+                if (z3) {
+                    a(j4);
+                }
+                Cleaner.create(this, new f(this.f12105j, this.f12102g, this.f12103h));
+                K1.a.c += this.f12102g * this.f12103h;
+                return;
+            }
+            this.f12096k = new float[(int) j4];
+            return;
+        }
+        throw new IllegalArgumentException(j4 + " is not a positive long value");
+    }
+
+    public final float b(long j4) {
+        float[] fArr = this.f12096k;
+        long j5 = this.f12105j;
+        if (j5 != 0) {
+            return r.f12109a.getFloat((this.f12103h * j4) + j5);
+        }
+        if (this.f12104i) {
+            return fArr[0];
+        }
+        return fArr[(int) j4];
+    }
+
+    public final void c(long j4, float f) {
+        long j5 = this.f12105j;
+        if (j5 != 0) {
+            r.f12109a.putFloat((this.f12103h * j4) + j5, f);
+        } else {
+            if (!this.f12104i) {
+                this.f12096k[(int) j4] = f;
+                return;
+            }
+            throw new IllegalAccessError("Constant arrays cannot be modified.");
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r0v1, types: [k3.g, java.lang.Object, k3.d] */
+    public final Object clone() {
+        if (this.f12104i) {
+            long j4 = this.f12102g;
+            float b4 = b(0L);
+            d gVar = new d();
+            gVar.f = q.f12106g;
+            gVar.f12103h = 4L;
+            if (j4 > 0) {
+                gVar.f12102g = j4;
+                gVar.f12104i = true;
+                gVar.f12096k = new float[]{b4};
+                return gVar;
+            }
+            throw new IllegalArgumentException(j4 + " is not a positive long value");
+        }
+        d dVar = new d(this.f12102g, false);
+        r.a(0L, 0L, this.f12102g, this, dVar);
+        return dVar;
+    }
+
+    @Override // k3.g
+    public final boolean equals(Object obj) {
+        if (!super.equals(obj) || this.f12096k != ((d) obj).f12096k) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override // k3.g
+    public final int hashCode() {
+        int i4;
+        int hashCode = super.hashCode() * 29;
+        float[] fArr = this.f12096k;
+        if (fArr != null) {
+            i4 = fArr.hashCode();
+        } else {
+            i4 = 0;
+        }
+        return hashCode + i4;
+    }
+}

feature/cw/src/main/java/k3/e.java

@@ -0,0 +1,79 @@
+package k3;
+
+/* loaded from: classes.dex */
+public final class e implements Runnable {
+    public final /* synthetic */ long f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final /* synthetic */ long f12097g;
+
+    /* renamed from: h, reason: collision with root package name */
+    public final /* synthetic */ long f12098h;
+
+    /* renamed from: i, reason: collision with root package name */
+    public final /* synthetic */ g f12099i;
+
+    public e(g gVar, long j4, long j5, long j6) {
+        this.f12099i = gVar;
+        this.f = j4;
+        this.f12097g = j5;
+        this.f12098h = j6;
+    }
+
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    /* JADX WARN: Failed to find 'out' block for switch in B:2:0x0011. Please report as an issue. */
+    @Override // java.lang.Runnable
+    public final void run() {
+        g gVar = this.f12099i;
+        int ordinal = gVar.f.ordinal();
+        long j4 = this.f12098h;
+        long j5 = this.f12097g;
+        long j6 = this.f;
+        switch (ordinal) {
+            case 0:
+            case 1:
+            case 2:
+            case 10:
+            case 11:
+                while (j6 < j5) {
+                    r.f12109a.putByte((gVar.f12103h * j6) + j4, (byte) 0);
+                    j6++;
+                }
+                return;
+            case 3:
+                while (j6 < j5) {
+                    r.f12109a.putShort((gVar.f12103h * j6) + j4, (short) 0);
+                    j6++;
+                }
+                return;
+            case 4:
+                while (j6 < j5) {
+                    r.f12109a.putInt((gVar.f12103h * j6) + j4, 0);
+                    j6++;
+                }
+                return;
+            case 5:
+                while (j6 < j5) {
+                    r.f12109a.putLong((gVar.f12103h * j6) + j4, 0L);
+                    j6++;
+                }
+                return;
+            case 6:
+                while (j6 < j5) {
+                    r.f12109a.putFloat((gVar.f12103h * j6) + j4, 0.0f);
+                    j6++;
+                }
+                return;
+            case 7:
+                while (j6 < j5) {
+                    r.f12109a.putDouble((gVar.f12103h * j6) + j4, 0.0d);
+                    j6++;
+                }
+                return;
+            case 8:
+            case 9:
+            default:
+                throw new IllegalArgumentException("Invalid array type.");
+        }
+    }
+}

feature/cw/src/main/java/k3/f.java

@@ -0,0 +1,32 @@
+package k3;
+
+/* loaded from: classes.dex */
+public final class f implements Runnable {
+    public long f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final long f12100g;
+
+    /* renamed from: h, reason: collision with root package name */
+    public final long f12101h;
+
+    public f(long j4, long j5, long j6) {
+        this.f = j4;
+        this.f12100g = j5;
+        this.f12101h = j6;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        long j4 = this.f;
+        if (j4 != 0) {
+            r.f12109a.freeMemory(j4);
+            this.f = 0L;
+            long j5 = K1.a.c - (this.f12100g * this.f12101h);
+            K1.a.c = j5;
+            if (j5 < 0) {
+                K1.a.c = 0L;
+            }
+        }
+    }
+}

feature/cw/src/main/java/k3/g.java

@@ -0,0 +1,92 @@
+package k3;
+
+import java.io.Serializable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+/* loaded from: classes.dex */
+public abstract class g implements Serializable, Cloneable {
+    public q f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public long f12102g;
+
+    /* renamed from: h, reason: collision with root package name */
+    public long f12103h;
+
+    /* renamed from: i, reason: collision with root package name */
+    public boolean f12104i = false;
+
+    /* renamed from: j, reason: collision with root package name */
+    public long f12105j = 0;
+
+    public final void a(long j4) {
+        long j5;
+        g gVar = this;
+        long j6 = gVar.f12105j;
+        if (j6 != 0) {
+            long j7 = c.c;
+            double[][] dArr = g3.c.f11585a;
+            if (j4 <= j7) {
+                j7 = j4;
+            }
+            int i4 = (int) j7;
+            if (i4 > 2 && j4 >= c.f12095d) {
+                long j8 = j4 / i4;
+                Future[] futureArr = new Future[i4];
+                int i5 = 0;
+                while (i5 < i4) {
+                    long j9 = i5 * j8;
+                    if (i5 == i4 - 1) {
+                        j5 = j4;
+                    } else {
+                        j5 = j9 + j8;
+                    }
+                    futureArr[i5] = c.a(new e(gVar, j9, j5, j6));
+                    i5++;
+                    gVar = gVar;
+                    j6 = j6;
+                }
+                g gVar2 = gVar;
+                try {
+                    c.b(futureArr);
+                    return;
+                } catch (InterruptedException unused) {
+                    r.f12109a.setMemory(gVar2.f12105j, gVar2.f12103h * j4, (byte) 0);
+                    return;
+                } catch (ExecutionException unused2) {
+                    r.f12109a.setMemory(gVar2.f12105j, j4 * gVar2.f12103h, (byte) 0);
+                    return;
+                }
+            }
+            r.f12109a.setMemory(j6, gVar.f12103h * j4, (byte) 0);
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (obj != null && (obj instanceof g)) {
+            g gVar = (g) obj;
+            if (this.f == gVar.f && this.f12102g == gVar.f12102g && this.f12103h == gVar.f12103h && this.f12104i == gVar.f12104i && this.f12105j == gVar.f12105j) {
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        int i4;
+        q qVar = this.f;
+        if (qVar != null) {
+            i4 = qVar.hashCode();
+        } else {
+            i4 = 0;
+        }
+        long j4 = this.f12102g;
+        int i5 = (((203 + i4) * 29) + ((int) (j4 ^ (j4 >>> 32)))) * 29;
+        long j5 = this.f12103h;
+        int i6 = (((i5 + ((int) (j5 ^ (j5 >>> 32)))) * 29) + (this.f12104i ? 1 : 0)) * 841;
+        long j6 = this.f12105j;
+        return i6 + ((int) (j6 ^ (j6 >>> 32)));
+    }
+}

feature/cw/src/main/java/k3/l.java

@@ -0,0 +1,8 @@
+package k3;
+
+/* loaded from: classes.dex */
+public final class l extends q {
+    public l() {
+        super("LONG", 5);
+    }
+}

feature/cw/src/main/java/k3/m.java

@@ -0,0 +1,8 @@
+package k3;
+
+/* loaded from: classes.dex */
+public final class m extends q {
+    public m() {
+        super("FLOAT", 6);
+    }
+}

feature/cw/src/main/java/k3/n.java

@@ -0,0 +1,8 @@
+package k3;
+
+/* loaded from: classes.dex */
+public final class n extends q {
+    public n() {
+        super("DOUBLE", 7);
+    }
+}

feature/cw/src/main/java/k3/q.java

@@ -0,0 +1,68 @@
+package k3;
+
+/**
+ * R8 生成的伪 enum(k3 FFT 库的数组类型枚举)。
+ * smali 中 q 的直接子类:l(LONG/5)、m(FLOAT/6)、n(DOUBLE/7),
+ * 其余常量(BYTE/UNSIGNED_BYTE/SHORT/INT/COMPLEX_FLOAT/COMPLEX_DOUBLE/STRING/OBJECT)
+ * 直接以 q 实例表达。
+ */
+public class q {
+    public static final l f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public static final m f12106g;
+
+    /* renamed from: h, reason: collision with root package name */
+    public static final n f12107h;
+
+    /* renamed from: i, reason: collision with root package name */
+    public static final /* synthetic */ q[] f12108i;
+
+    private final String name;
+    private final int ordinal;
+
+    protected q(String name, int ordinal) {
+        this.name = name;
+        this.ordinal = ordinal;
+    }
+
+    public final String name() {
+        return name;
+    }
+
+    public final int ordinal() {
+        return ordinal;
+    }
+
+    public static q valueOf(String str) {
+        for (q qVar : f12108i) {
+            if (qVar.name.equals(str)) {
+                return qVar;
+            }
+        }
+        throw new IllegalArgumentException("No enum constant k3.q." + str);
+    }
+
+    public static q[] values() {
+        return (q[]) f12108i.clone();
+    }
+
+    static {
+        q logic = new q("LOGIC", 0);
+        q byteType = new q("BYTE", 1);
+        q unsignedByte = new q("UNSIGNED_BYTE", 2);
+        q shortType = new q("SHORT", 3);
+        q intType = new q("INT", 4);
+        l longType = new l();
+        f = longType;
+        m floatType = new m();
+        f12106g = floatType;
+        n doubleType = new n();
+        f12107h = doubleType;
+        q complexFloat = new q("COMPLEX_FLOAT", 8);
+        q complexDouble = new q("COMPLEX_DOUBLE", 9);
+        q string = new q("STRING", 10);
+        q object = new q("OBJECT", 11);
+        f12108i = new q[]{logic, byteType, unsignedByte, shortType, intType, longType, floatType, doubleType, complexFloat, complexDouble, string, object};
+    }
+}

feature/cw/src/main/java/k3/r.java

@@ -0,0 +1,97 @@
+package k3;
+
+import java.lang.reflect.Field;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import com.rtbishop.look4sat.feature.cw.suncompat.Unsafe;
+
+/* loaded from: classes.dex */
+public abstract class r {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final Unsafe f12109a;
+
+    static {
+        Object obj = null;
+        try {
+            Class<?> cls = Class.forName("sun.misc.Unsafe");
+            Field declaredField = cls.getDeclaredField("theUnsafe");
+            declaredField.setAccessible(true);
+            obj = declaredField.get(cls);
+        } catch (ClassNotFoundException | IllegalAccessException | IllegalArgumentException | NoSuchFieldException | SecurityException ignored) {
+            // Android 适配: sun.misc.Unsafe 可能不可用(隐藏 API), 静默降级为 null;
+            // 大数组 native 路径(j4 > 1GB)不会在实际解码中触发
+        }
+        f12109a = (Unsafe) obj;
+    }
+
+    public static void a(long j4, long j5, long j6, d dVar, d dVar2) {
+        long j7;
+        if (j4 >= 0 && j4 < dVar.f12102g) {
+            if (j5 >= 0 && j5 < dVar2.f12102g) {
+                if (j6 >= 0) {
+                    if (!dVar2.f12104i) {
+                        long j8 = c.c;
+                        double[][] dArr = g3.c.f11585a;
+                        if (j6 <= j8) {
+                            j8 = j6;
+                        }
+                        int i4 = (int) j8;
+                        if (i4 >= 2 && j6 >= c.f12095d) {
+                            long j9 = j6 / i4;
+                            Future[] futureArr = new Future[i4];
+                            int i5 = 0;
+                            while (i5 < i4) {
+                                long j10 = i5 * j9;
+                                if (i5 == i4 - 1) {
+                                    j7 = j6;
+                                } else {
+                                    j7 = j10 + j9;
+                                }
+                                Future[] futureArr2 = futureArr;
+                                int i6 = i5;
+                                futureArr2[i6] = c.a(new j3.b(j10, j7, j5, j4, dVar2, dVar));
+                                i5 = i6 + 1;
+                                futureArr = futureArr2;
+                            }
+                            try {
+                                c.b(futureArr);
+                                return;
+                            } catch (InterruptedException unused) {
+                                long j11 = j4;
+                                long j12 = j5;
+                                while (j11 < j4 + j6) {
+                                    dVar2.c(j12, dVar.b(j11));
+                                    j11++;
+                                    j12++;
+                                }
+                                return;
+                            } catch (ExecutionException unused2) {
+                                long j13 = j4;
+                                long j14 = j5;
+                                while (j13 < j4 + j6) {
+                                    dVar2.c(j14, dVar.b(j13));
+                                    j13++;
+                                    j14++;
+                                }
+                                return;
+                            }
+                        }
+                        long j15 = j4;
+                        long j16 = j5;
+                        while (j15 < j4 + j6) {
+                            dVar2.c(j16, dVar.b(j15));
+                            j15++;
+                            j16++;
+                        }
+                        return;
+                    }
+                    throw new IllegalArgumentException("Constant arrays cannot be modified.");
+                }
+                throw new IllegalArgumentException("length < 0");
+            }
+            throw new ArrayIndexOutOfBoundsException("destPos < 0 || destPos >= dest.length()");
+        }
+        throw new ArrayIndexOutOfBoundsException("srcPos < 0 || srcPos >= src.length()");
+    }
+}

feature/cw/src/main/java/k3/s.java

@@ -0,0 +1,167 @@
+package k3;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import com.rtbishop.look4sat.feature.cw.suncompat.Cleaner;
+import com.rtbishop.look4sat.feature.cw.suncompat.Unsafe;
+
+/* loaded from: classes.dex */
+public final class s extends g {
+
+    /* renamed from: k, reason: collision with root package name */
+    public long[] f12110k;
+
+    public s() {
+    }
+
+    public s(long j4, boolean z3) {
+        this.f = q.f;
+        this.f12103h = 8L;
+        if (j4 > 0) {
+            this.f12102g = j4;
+            if (j4 > 1073741824) {
+                this.f12105j = r.f12109a.allocateMemory(8 * j4);
+                if (z3) {
+                    a(j4);
+                }
+                Cleaner.create(this, new f(this.f12105j, this.f12102g, this.f12103h));
+                K1.a.c += this.f12102g * this.f12103h;
+                return;
+            }
+            this.f12110k = new long[(int) j4];
+            return;
+        }
+        throw new IllegalArgumentException(j4 + " is not a positive long value");
+    }
+
+    public final long b(long j4) {
+        long[] jArr = this.f12110k;
+        long j5 = this.f12105j;
+        if (j5 != 0) {
+            return r.f12109a.getLong((this.f12103h * j4) + j5);
+        }
+        if (this.f12104i) {
+            return jArr[0];
+        }
+        return jArr[(int) j4];
+    }
+
+    public final void c(long j4, long j5) {
+        long j6 = this.f12105j;
+        if (j6 != 0) {
+            r.f12109a.putLong((this.f12103h * j4) + j6, j5);
+        } else {
+            if (!this.f12104i) {
+                this.f12110k[(int) j4] = j5;
+                return;
+            }
+            throw new IllegalAccessError("Constant arrays cannot be modified.");
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r0v29, types: [k3.g, java.lang.Object, k3.s] */
+    public final Object clone() {
+        long j4;
+        int i4 = 0;
+        long j5 = 0;
+        if (this.f12104i) {
+            long j6 = this.f12102g;
+            long b4 = b(0L);
+            s gVar = new s();
+            gVar.f = q.f12107h;
+            gVar.f12103h = 8L;
+            if (j6 > 0) {
+                gVar.f12102g = j6;
+                gVar.f12104i = true;
+                gVar.f12110k = new long[]{b4};
+                return gVar;
+            }
+            throw new IllegalArgumentException(j6 + " is not a positive long value");
+        }
+        s sVar = new s(this.f12102g, false);
+        long j7 = this.f12102g;
+        Unsafe unsafe = r.f12109a;
+        if (0 < j7) {
+            if (0 < sVar.f12102g) {
+                if (j7 >= 0) {
+                    if (!sVar.f12104i) {
+                        long j8 = c.c;
+                        double[][] dArr = g3.c.f11585a;
+                        if (j7 <= j8) {
+                            j8 = j7;
+                        }
+                        int i5 = (int) j8;
+                        if (i5 >= 2 && j7 >= c.f12095d) {
+                            long j9 = j7 / i5;
+                            Future[] futureArr = new Future[i5];
+                            while (i4 < i5) {
+                                long j10 = i4 * j9;
+                                if (i4 == i5 - 1) {
+                                    j4 = j7;
+                                } else {
+                                    j4 = j10 + j9;
+                                }
+                                Future[] futureArr2 = futureArr;
+                                int i6 = i4;
+                                futureArr2[i6] = c.a(new i3.c(j10, j4, sVar, this));
+                                i4 = i6 + 1;
+                                futureArr = futureArr2;
+                            }
+                            try {
+                                c.b(futureArr);
+                                return sVar;
+                            } catch (InterruptedException unused) {
+                                long j11 = 0;
+                                while (j5 < j7) {
+                                    sVar.c(j11, b(j5));
+                                    j5++;
+                                    j11++;
+                                }
+                            } catch (ExecutionException unused2) {
+                                long j12 = 0;
+                                while (j5 < j7) {
+                                    sVar.c(j12, b(j5));
+                                    j5++;
+                                    j12++;
+                                }
+                            }
+                        } else {
+                            long j13 = 0;
+                            while (j5 < j7) {
+                                sVar.c(j13, b(j5));
+                                j5++;
+                                j13++;
+                            }
+                        }
+                        return sVar;
+                    }
+                    throw new IllegalArgumentException("Constant arrays cannot be modified.");
+                }
+                throw new IllegalArgumentException("length < 0");
+            }
+            throw new ArrayIndexOutOfBoundsException("destPos < 0 || destPos >= dest.length()");
+        }
+        throw new ArrayIndexOutOfBoundsException("srcPos < 0 || srcPos >= src.length()");
+    }
+
+    @Override // k3.g
+    public final boolean equals(Object obj) {
+        if (!super.equals(obj) || this.f12110k != ((s) obj).f12110k) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override // k3.g
+    public final int hashCode() {
+        int i4;
+        int hashCode = super.hashCode() * 29;
+        long[] jArr = this.f12110k;
+        if (jArr != null) {
+            i4 = jArr.hashCode();
+        } else {
+            i4 = 0;
+        }
+        return hashCode + i4;
+    }
+}