116 lines
4.3 KiB
Python
116 lines
4.3 KiB
Python
#!/usr/bin/env python3
|
|
"""Generate Kotlin tables from csdk C headers (palette256, t2e)."""
|
|
import re, sys, io
|
|
|
|
CSDK = r"C:\Project\MAG160C\csdk\src"
|
|
OUT = r"C:\Project\MAG160C\android\app\src\main\kotlin\com\mag160c\thermal\core\OfficialTables.kt"
|
|
|
|
def read(fn):
|
|
with open(fn, encoding="utf-8") as f:
|
|
return f.read()
|
|
|
|
def parse_matrix(text, rows=256):
|
|
vals = []
|
|
for m in re.finditer(r"\{\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\}", text):
|
|
vals.append((int(m.group(3)), int(m.group(2)), int(m.group(1)))) # R,G,B from (B,G,R,0)
|
|
if len(vals) == rows:
|
|
break
|
|
return vals
|
|
|
|
def parse_int32(text):
|
|
body = text[text.index("{"):]
|
|
return [int(x) for x in re.findall(r"-?\d+", body)]
|
|
|
|
pal_txt = read(rf"{CSDK}\mag160c_official_palette256.h")
|
|
t2e_txt = read(rf"{CSDK}\mag160c_official_t2e.h")
|
|
tables_txt = read(rf"{CSDK}\mag160c_tables.h")
|
|
|
|
pal = parse_matrix(pal_txt)
|
|
assert len(pal) == 256, f"palette entries: {len(pal)}"
|
|
t2e = parse_int32(t2e_txt)
|
|
assert len(t2e) == 646, f"t2e entries: {len(t2e)}"
|
|
|
|
# mag160c_t2e (274 entries, hex) + mag160c_e2t_acc_q10 (274 entries)
|
|
def parse_hex_array(text, name):
|
|
m = re.search(rf"static const uint32_t {name}\[MAG160C_TEMP_CURVE_ENTRIES\] = \{{(.*?)\}};", text, re.S)
|
|
assert m, name
|
|
return [int(x, 16) for x in re.findall(r"0x[0-9a-fA-F]+", m.group(1))]
|
|
|
|
t2e274 = parse_hex_array(tables_txt, "mag160c_t2e")
|
|
assert len(t2e274) == 274, f"t2e274: {len(t2e274)}"
|
|
e2t = parse_hex_array(tables_txt, "mag160c_e2t_acc_q10")
|
|
assert len(e2t) == 274, f"e2t: {len(e2t)}"
|
|
|
|
# palette ARGB int per gray index
|
|
lines = []
|
|
lines.append("package com.mag160c.thermal.core")
|
|
lines.append("")
|
|
lines.append("/** Generated from csdk C headers by analysis/gen_kotlin_tables.py. DO NOT EDIT. */")
|
|
lines.append("object OfficialTables {")
|
|
lines.append(" /** Official default palette (256 gray levels -> ARGB int), source: CoreSDKLib dev+0xb18. */")
|
|
lines.append(" val PALETTE256_ARGB = intArrayBuilder {")
|
|
for i, (r, g, b) in enumerate(pal):
|
|
argb = (0xFF << 24) | (r << 16) | (g << 8) | b
|
|
lines.append(f" add({argb}) // {i}")
|
|
lines.append(" }")
|
|
lines.append("")
|
|
lines.append(" /** Official T2E table (646 int32), temp = slope*diff>>12 + (i<<12) - 0x249f0. */")
|
|
lines.append(" val T2E = intArrayBuilder {")
|
|
for i in range(0, len(t2e), 8):
|
|
chunk = t2e[i:i+8]
|
|
lines.append(" add(" + ", ".join(str(v) for v in chunk) + (")" if i + 8 >= len(t2e) else ""))
|
|
lines.append(" }")
|
|
lines.append("}")
|
|
kt = "\n".join(lines) + "\n"
|
|
|
|
# intArrayBuilder trick is overkill; use direct arrays with chunked lines instead.
|
|
argb_lines = []
|
|
def signed(v):
|
|
return v if v < 2**31 else v - 2**32
|
|
for i in range(0, len(pal), 6):
|
|
row = ", ".join(str(signed((0xFF << 24) | (r << 16) | (g << 8) | b)) for (r, g, b) in pal[i:i+6])
|
|
argb_lines.append(" " + row + ",")
|
|
t2e_lines = []
|
|
for i in range(0, len(t2e), 8):
|
|
row = ", ".join(str(v) for v in t2e[i:i+8])
|
|
t2e_lines.append(" " + row + ("," if i + 8 < len(t2e) else ""))
|
|
|
|
t2e274_lines = []
|
|
for i in range(0, len(t2e274), 8):
|
|
row = ", ".join(f"0x{v:08x}" for v in t2e274[i:i+8])
|
|
t2e274_lines.append(" " + row + ("," if i + 8 < len(t2e274) else ""))
|
|
|
|
e2t_lines = []
|
|
for i in range(0, len(e2t), 8):
|
|
row = ", ".join(f"0x{v:08x}" for v in e2t[i:i+8])
|
|
e2t_lines.append(" " + row + ("," if i + 8 < len(e2t) else ""))
|
|
|
|
kt = f"""package com.mag160c.thermal.core
|
|
|
|
/** Generated from csdk C headers by analysis/gen_kotlin_tables.py. DO NOT EDIT. */
|
|
object OfficialTables {{
|
|
/** Official default palette: 256 gray levels -> ARGB int (from CoreSDKLib dev+0xb18, B,G,R order swapped). */
|
|
val PALETTE256_ARGB = intArrayOf(
|
|
{chr(10).join(argb_lines)}
|
|
)
|
|
|
|
/** Official T2E table (646 int32): temp = slope*diff>>12 + (i<<12) - 0x249f0. */
|
|
val T2E = intArrayOf(
|
|
{chr(10).join(t2e_lines)}
|
|
)
|
|
|
|
/** Vendor T2E curve from libcoresdk.so ARM64 @0x402010 (274 uint32 entries). */
|
|
val T2E274 = intArrayOf(
|
|
{chr(10).join(t2e274_lines)}
|
|
)
|
|
|
|
/** Vendor E2TAccQ10 curve from libcoresdk.so ARM64 @0x40245c (274 uint32 entries). */
|
|
val E2T_ACC_Q10 = intArrayOf(
|
|
{chr(10).join(e2t_lines)}
|
|
)
|
|
}}
|
|
"""
|
|
with open(OUT, "w", encoding="utf-8", newline="\n") as f:
|
|
f.write(kt)
|
|
print(f"written {OUT}: palette {len(pal)} entries, t2e {len(t2e)} entries")
|