471 lines
21 KiB
C#
471 lines
21 KiB
C#
using System.Globalization;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using TuneBoss.Core.Models;
|
|
|
|
namespace TuneBoss.Core.IO;
|
|
|
|
/// <summary>
|
|
/// Reader/writer for the TuneBoss <c>.fsr</c> configuration format (v1) — a
|
|
/// text-based, self-describing container for a full ECU tuning configuration.
|
|
/// See FSR_FORMAT_SPEC.md for the authoritative specification.
|
|
///
|
|
/// This type is model-based and standalone: it (de)serialises the actual table
|
|
/// models, so it does not depend on the app's nav-tree/codec plumbing.
|
|
/// </summary>
|
|
public static class FsrFile
|
|
{
|
|
public const int FormatVersion = 1;
|
|
|
|
// ── Public data structures ──────────────────────────────────────────────
|
|
|
|
public sealed class FsrDocument
|
|
{
|
|
public FsrHeader Header { get; set; } = new();
|
|
public List<FsrSection> Sections { get; } = new();
|
|
|
|
public FsrSection? Find(string name) =>
|
|
Sections.FirstOrDefault(s => string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
public sealed class FsrHeader
|
|
{
|
|
public int FsrVersion { get; set; } = FormatVersion;
|
|
public string Generator { get; set; } = "";
|
|
public string CreatedUtc { get; set; } = "";
|
|
public string CreatorId { get; set; } = "";
|
|
public int FwVersion { get; set; }
|
|
public int HwVersion { get; set; }
|
|
public int Make { get; set; }
|
|
public int Model { get; set; }
|
|
public int Cylinders { get; set; } = 1;
|
|
public int Generation { get; set; } = 3;
|
|
public string SaveType { get; set; } = "full_config";
|
|
public string Note { get; set; } = "none";
|
|
// Modification tags
|
|
public string ModEngineBlock { get; set; } = "none";
|
|
public string ModCamshaft { get; set; } = "none";
|
|
public string ModExhaust { get; set; } = "none";
|
|
public string ModAirFilter { get; set; } = "none";
|
|
public string ModCylinderHead { get; set; } = "none";
|
|
public string ModInjector { get; set; } = "none";
|
|
public string ModThrottleBody { get; set; } = "none";
|
|
public string ModJackRod { get; set; } = "none";
|
|
/// <summary>Any header keys not recognised — preserved on round-trip.</summary>
|
|
public Dictionary<string, string> Extra { get; } = new(StringComparer.OrdinalIgnoreCase);
|
|
}
|
|
|
|
public enum SectionType { Table2D, Table1D, SubTable, Afr, Misc, Unknown }
|
|
|
|
public sealed class FsrSection
|
|
{
|
|
public SectionType Type { get; set; }
|
|
public string TypeToken { get; set; } = ""; // raw token, preserves Unknown
|
|
public string Name { get; set; } = ""; // stable feature key
|
|
public string Label { get; set; } = "";
|
|
public ushort Addr { get; set; }
|
|
public byte Length { get; set; } // last-inclusive-offset (bytes-1)
|
|
public int Gen { get; set; }
|
|
|
|
// Exactly one of these is populated depending on Type.
|
|
public TuningTable? Table2D { get; set; }
|
|
public AfrTable? Afr { get; set; }
|
|
public OneDimTable? Table1D { get; set; }
|
|
public SubTable? Sub { get; set; }
|
|
public byte[]? MiscBytes { get; set; }
|
|
|
|
/// <summary>Raw field lines for Unknown sections / unrecognised keys.</summary>
|
|
public Dictionary<string, string> Extra { get; } = new(StringComparer.OrdinalIgnoreCase);
|
|
}
|
|
|
|
// ════════════════════════════════════════════════════════════════════════
|
|
// WRITE
|
|
// ════════════════════════════════════════════════════════════════════════
|
|
|
|
/// <summary>Serialises a document to .fsr text (with an optional whole-body sha256).</summary>
|
|
public static string Write(FsrDocument doc, bool includeSha256 = true)
|
|
{
|
|
var body = new StringBuilder();
|
|
WriteHeader(body, doc.Header);
|
|
body.Append('\n');
|
|
foreach (var s in doc.Sections)
|
|
WriteSection(body, s);
|
|
|
|
if (!includeSha256)
|
|
return body.ToString();
|
|
|
|
// sha256 covers everything after the sha256 line — write header line first.
|
|
string bodyText = body.ToString();
|
|
string hash = Sha256Hex(bodyText);
|
|
return $"# integrity\nsha256 = {hash}\n{bodyText}";
|
|
}
|
|
|
|
private static void WriteHeader(StringBuilder sb, FsrHeader h)
|
|
{
|
|
sb.Append("# TuneBoss configuration — .fsr v").Append(h.FsrVersion).Append('\n');
|
|
void F(string k, object v) => sb.Append(k).Append(" = ").Append(v).Append('\n');
|
|
F("fsr_version", h.FsrVersion);
|
|
if (!string.IsNullOrEmpty(h.Generator)) F("generator", h.Generator);
|
|
if (!string.IsNullOrEmpty(h.CreatedUtc)) F("created_utc", h.CreatedUtc);
|
|
F("creator_id", h.CreatorId);
|
|
F("fw_version", h.FwVersion);
|
|
F("hw_version", h.HwVersion);
|
|
F("make", h.Make);
|
|
F("model", h.Model);
|
|
F("cylinders", h.Cylinders);
|
|
F("generation", h.Generation);
|
|
F("save_type", h.SaveType);
|
|
F("mod_engine_block", h.ModEngineBlock);
|
|
F("mod_camshaft", h.ModCamshaft);
|
|
F("mod_exhaust", h.ModExhaust);
|
|
F("mod_air_filter", h.ModAirFilter);
|
|
F("mod_cylinder_head", h.ModCylinderHead);
|
|
F("mod_injector", h.ModInjector);
|
|
F("mod_throttle_body", h.ModThrottleBody);
|
|
F("mod_jack_rod", h.ModJackRod);
|
|
F("note", h.Note);
|
|
foreach (var kv in h.Extra) F(kv.Key, kv.Value);
|
|
}
|
|
|
|
private static void WriteSection(StringBuilder sb, FsrSection s)
|
|
{
|
|
string typeToken = s.Type switch
|
|
{
|
|
SectionType.Table2D => "TABLE2D",
|
|
SectionType.Afr => "AFR",
|
|
SectionType.Table1D => "TABLE1D",
|
|
SectionType.SubTable => "SUBTABLE",
|
|
SectionType.Misc => "MISC",
|
|
_ => s.TypeToken,
|
|
};
|
|
sb.Append('[').Append(typeToken).Append(' ').Append(s.Name).Append("]\n");
|
|
void F(string k, object v) => sb.Append(k).Append(" = ").Append(v).Append('\n');
|
|
F("label", s.Label);
|
|
F("addr", Hex16(s.Addr));
|
|
F("length", Hex8(s.Length));
|
|
if (s.Gen != 0) F("gen", s.Gen);
|
|
|
|
switch (s.Type)
|
|
{
|
|
case SectionType.Table2D when s.Table2D is { } t: Write2D(sb, t.Data, t.RpmAxis, t.LoadAxis, t.Sign, t.MaxRaw, t.MinRaw, t.Mult); break;
|
|
case SectionType.Afr when s.Afr is { } a: Write2D(sb, a.Data, a.RpmAxis, a.LoadAxis, a.Sign, a.MaxRaw, a.MinRaw, a.Mult); break;
|
|
case SectionType.Table1D when s.Table1D is { } o: Write1D(sb, o); break;
|
|
case SectionType.SubTable when s.Sub is { } sub: WriteSub(sb, sub); break;
|
|
case SectionType.Misc when s.MiscBytes is { } b: WriteBytes(sb, b); break;
|
|
default:
|
|
foreach (var kv in s.Extra) F(kv.Key, kv.Value);
|
|
break;
|
|
}
|
|
sb.Append('\n');
|
|
}
|
|
|
|
private static void Write2D(StringBuilder sb, byte[] data, byte[] rpm, byte[] load, byte sign, byte maxRaw, byte minRaw, byte mult)
|
|
{
|
|
sb.Append("signed = ").Append(sign > 0 ? 1 : 0).Append('\n');
|
|
sb.Append("mult = ").Append(mult).Append('\n');
|
|
sb.Append("max_raw = ").Append(maxRaw).Append('\n');
|
|
sb.Append("min_raw = ").Append(minRaw).Append('\n');
|
|
sb.Append("rpm_axis = ").Append(HexBytes(rpm)).Append('\n');
|
|
sb.Append("load_axis = ").Append(HexBytes(load)).Append('\n');
|
|
for (int r = 0; r < TuningTable.Rows; r++)
|
|
{
|
|
sb.Append("row").Append(r).Append(" = ");
|
|
for (int c = 0; c < TuningTable.Cols; c++)
|
|
{
|
|
if (c > 0) sb.Append(' ');
|
|
sb.Append(Hex8(data[r * TuningTable.Cols + c]));
|
|
}
|
|
sb.Append('\n');
|
|
}
|
|
}
|
|
|
|
private static void Write1D(StringBuilder sb, OneDimTable o)
|
|
{
|
|
sb.Append("raw_signed = ").Append(o.RawSignedFlag > 0 ? 1 : 0).Append('\n');
|
|
sb.Append("conv_signed = ").Append(o.ConvSignedFlag > 0 ? 1 : 0).Append('\n');
|
|
sb.Append("raw_mult = ").Append(o.RawMultiplier).Append('\n');
|
|
sb.Append("conv_mult = ").Append(o.ConvMultiplier).Append('\n');
|
|
sb.Append("raw_round = ").Append(o.RawRounding).Append('\n');
|
|
sb.Append("conv_offset = ").Append((int)o.ConvOffset).Append('\n');
|
|
sb.Append("max_raw = ").Append(o.MaxRaw).Append('\n');
|
|
sb.Append("min_raw = ").Append(o.MinRaw).Append('\n');
|
|
for (int i = 0; i < OneDimTable.PointCount; i++)
|
|
sb.Append('p').Append(i).Append(" = ").Append(o.RawAxis[i]).Append(", ").Append(o.ConvValues[i]).Append('\n');
|
|
}
|
|
|
|
private static void WriteSub(StringBuilder sb, SubTable sub)
|
|
{
|
|
for (int r = 0; r < SubTable.Rows; r++)
|
|
{
|
|
sb.Append("row").Append(r).Append(" = ");
|
|
for (int c = 0; c < SubTable.Cols; c++)
|
|
{
|
|
if (c > 0) sb.Append(", ");
|
|
sb.Append((int)unchecked((sbyte)sub.Data[r * SubTable.Cols + c]));
|
|
}
|
|
sb.Append('\n');
|
|
}
|
|
}
|
|
|
|
private static void WriteBytes(StringBuilder sb, byte[] bytes)
|
|
{
|
|
const int perLine = 32;
|
|
for (int off = 0; off < bytes.Length; off += perLine)
|
|
{
|
|
int n = Math.Min(perLine, bytes.Length - off);
|
|
sb.Append("bytes = ");
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
if (i > 0) sb.Append(' ');
|
|
sb.Append(Hex8(bytes[off + i]));
|
|
}
|
|
sb.Append('\n');
|
|
}
|
|
}
|
|
|
|
// ════════════════════════════════════════════════════════════════════════
|
|
// READ
|
|
// ════════════════════════════════════════════════════════════════════════
|
|
|
|
public static FsrDocument Read(string text)
|
|
{
|
|
var doc = new FsrDocument();
|
|
FsrSection? cur = null;
|
|
var secFields = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
var rowLines = new List<(string key, string val)>();
|
|
|
|
void Flush()
|
|
{
|
|
if (cur == null) return;
|
|
BuildSection(cur, secFields, rowLines);
|
|
doc.Sections.Add(cur);
|
|
secFields = new(StringComparer.OrdinalIgnoreCase);
|
|
rowLines = new();
|
|
}
|
|
|
|
foreach (var raw in text.Split('\n'))
|
|
{
|
|
var line = raw.TrimEnd('\r');
|
|
var t = line.TrimStart();
|
|
if (t.Length == 0 || t[0] == '#') continue;
|
|
|
|
if (t[0] == '[')
|
|
{
|
|
Flush();
|
|
int close = t.IndexOf(']');
|
|
var inner = (close > 0 ? t[1..close] : t[1..]).Trim();
|
|
int sp = inner.IndexOf(' ');
|
|
string typeTok = sp > 0 ? inner[..sp] : inner;
|
|
string name = sp > 0 ? inner[(sp + 1)..].Trim() : "";
|
|
cur = new FsrSection { TypeToken = typeTok, Type = ParseType(typeTok), Name = name };
|
|
continue;
|
|
}
|
|
|
|
int eq = line.IndexOf('=');
|
|
if (eq < 0) continue;
|
|
string key = line[..eq].Trim();
|
|
string val = line[(eq + 1)..].Trim();
|
|
|
|
if (cur == null) { ApplyHeader(doc.Header, key, val); continue; }
|
|
|
|
// Row-style keys accumulate (rowN, pN, bytes); everything else is a field.
|
|
if (IsRowKey(key)) rowLines.Add((key, val));
|
|
else secFields[key] = val;
|
|
}
|
|
Flush();
|
|
return doc;
|
|
}
|
|
|
|
private static bool IsRowKey(string k) =>
|
|
k.StartsWith("row", StringComparison.OrdinalIgnoreCase) ||
|
|
(k.Length >= 2 && (k[0] == 'p' || k[0] == 'P') && char.IsDigit(k[1])) ||
|
|
k.Equals("bytes", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static SectionType ParseType(string tok) => tok.ToUpperInvariant() switch
|
|
{
|
|
"TABLE2D" => SectionType.Table2D,
|
|
"AFR" => SectionType.Afr,
|
|
"TABLE1D" => SectionType.Table1D,
|
|
"SUBTABLE" => SectionType.SubTable,
|
|
"MISC" => SectionType.Misc,
|
|
_ => SectionType.Unknown,
|
|
};
|
|
|
|
private static void ApplyHeader(FsrHeader h, string key, string val)
|
|
{
|
|
switch (key.ToLowerInvariant())
|
|
{
|
|
case "fsr_version": h.FsrVersion = ParseInt(val); break;
|
|
case "generator": h.Generator = val; break;
|
|
case "created_utc": h.CreatedUtc = val; break;
|
|
case "creator_id": h.CreatorId = val; break;
|
|
case "fw_version": h.FwVersion = ParseInt(val); break;
|
|
case "hw_version": h.HwVersion = ParseInt(val); break;
|
|
case "make": h.Make = ParseInt(val); break;
|
|
case "model": h.Model = ParseInt(val); break;
|
|
case "cylinders": h.Cylinders = ParseInt(val); break;
|
|
case "generation": h.Generation = ParseInt(val); break;
|
|
case "save_type": h.SaveType = val; break;
|
|
case "note": h.Note = val; break;
|
|
case "mod_engine_block": h.ModEngineBlock = val; break;
|
|
case "mod_camshaft": h.ModCamshaft = val; break;
|
|
case "mod_exhaust": h.ModExhaust = val; break;
|
|
case "mod_air_filter": h.ModAirFilter = val; break;
|
|
case "mod_cylinder_head": h.ModCylinderHead = val; break;
|
|
case "mod_injector": h.ModInjector = val; break;
|
|
case "mod_throttle_body": h.ModThrottleBody = val; break;
|
|
case "mod_jack_rod": h.ModJackRod = val; break;
|
|
case "sha256": break; // integrity only; not structural
|
|
default: h.Extra[key] = val; break; // forward-compat
|
|
}
|
|
}
|
|
|
|
private static void BuildSection(FsrSection s, Dictionary<string, string> f, List<(string key, string val)> rows)
|
|
{
|
|
s.Label = f.GetValueOrDefault("label", s.Name);
|
|
s.Addr = (ushort)ParseInt(f.GetValueOrDefault("addr", "0"));
|
|
s.Length = (byte)ParseInt(f.GetValueOrDefault("length", "0"));
|
|
s.Gen = ParseInt(f.GetValueOrDefault("gen", "0"));
|
|
|
|
switch (s.Type)
|
|
{
|
|
case SectionType.Table2D: s.Table2D = Build2D(f, rows); break;
|
|
case SectionType.Afr: s.Afr = BuildAfr(f, rows); break;
|
|
case SectionType.Table1D: s.Table1D = Build1D(f, rows); break;
|
|
case SectionType.SubTable:s.Sub = BuildSub(rows); break;
|
|
case SectionType.Misc: s.MiscBytes = BuildBytes(rows); break;
|
|
default:
|
|
foreach (var kv in f) s.Extra[kv.Key] = kv.Value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static (byte[] data, byte[] rpm, byte[] load, byte sign, byte maxRaw, byte minRaw, byte mult) Read2DCore(
|
|
Dictionary<string, string> f, List<(string key, string val)> rows)
|
|
{
|
|
var rpm = ParseHexBytes(f.GetValueOrDefault("rpm_axis", ""));
|
|
var load = ParseHexBytes(f.GetValueOrDefault("load_axis", ""));
|
|
byte sign = (byte)(ParseInt(f.GetValueOrDefault("signed", "0")) > 0 ? 1 : 0);
|
|
byte maxRaw = (byte)ParseInt(f.GetValueOrDefault("max_raw", "0"));
|
|
byte minRaw = (byte)ParseInt(f.GetValueOrDefault("min_raw", "0"));
|
|
byte mult = (byte)ParseInt(f.GetValueOrDefault("mult", "1"));
|
|
var data = new byte[TuningTable.DataBytes];
|
|
foreach (var (key, val) in rows)
|
|
{
|
|
if (!key.StartsWith("row", StringComparison.OrdinalIgnoreCase)) continue;
|
|
int r = ParseInt(key[3..]);
|
|
var cells = ParseHexBytes(val);
|
|
for (int c = 0; c < cells.Length && c < TuningTable.Cols; c++)
|
|
data[r * TuningTable.Cols + c] = cells[c];
|
|
}
|
|
return (data, rpm, load, sign, maxRaw, minRaw, mult);
|
|
}
|
|
|
|
private static TuningTable Build2D(Dictionary<string, string> f, List<(string, string)> rows)
|
|
{
|
|
var (data, rpm, load, sign, maxRaw, minRaw, mult) = Read2DCore(f, rows);
|
|
return new TuningTable { Data = data, RpmAxis = rpm, LoadAxis = load, Sign = sign, MaxRaw = maxRaw, MinRaw = minRaw, Mult = mult };
|
|
}
|
|
|
|
private static AfrTable BuildAfr(Dictionary<string, string> f, List<(string, string)> rows)
|
|
{
|
|
var (data, rpm, load, sign, maxRaw, minRaw, mult) = Read2DCore(f, rows);
|
|
return new AfrTable { Data = data, RpmAxis = rpm, LoadAxis = load, Sign = sign, MaxRaw = maxRaw, MinRaw = minRaw, Mult = mult };
|
|
}
|
|
|
|
private static OneDimTable Build1D(Dictionary<string, string> f, List<(string key, string val)> rows)
|
|
{
|
|
var o = new OneDimTable
|
|
{
|
|
RawSignedFlag = (byte)(ParseInt(f.GetValueOrDefault("raw_signed", "0")) > 0 ? 1 : 0),
|
|
ConvSignedFlag = (byte)(ParseInt(f.GetValueOrDefault("conv_signed", "0")) > 0 ? 1 : 0),
|
|
RawMultiplier = (byte)ParseInt(f.GetValueOrDefault("raw_mult", "1")),
|
|
ConvMultiplier = (byte)ParseInt(f.GetValueOrDefault("conv_mult", "1")),
|
|
RawRounding = (byte)ParseInt(f.GetValueOrDefault("raw_round", "0")),
|
|
ConvOffset = (sbyte)ParseInt(f.GetValueOrDefault("conv_offset", "0")),
|
|
MaxRaw = ParseInt(f.GetValueOrDefault("max_raw", "0")),
|
|
MinRaw = ParseInt(f.GetValueOrDefault("min_raw", "0")),
|
|
};
|
|
foreach (var (key, val) in rows)
|
|
{
|
|
if (key.Length < 2 || (key[0] != 'p' && key[0] != 'P')) continue;
|
|
int i = ParseInt(key[1..]);
|
|
if (i < 0 || i >= OneDimTable.PointCount) continue;
|
|
var parts = val.Split(',');
|
|
if (parts.Length >= 1) o.RawAxis[i] = ParseInt(parts[0].Trim());
|
|
if (parts.Length >= 2) o.ConvValues[i] = ParseInt(parts[1].Trim());
|
|
}
|
|
return o;
|
|
}
|
|
|
|
private static SubTable BuildSub(List<(string key, string val)> rows)
|
|
{
|
|
var data = new byte[SubTable.DataBytes];
|
|
foreach (var (key, val) in rows)
|
|
{
|
|
if (!key.StartsWith("row", StringComparison.OrdinalIgnoreCase)) continue;
|
|
int r = ParseInt(key[3..]);
|
|
var parts = val.Split(',');
|
|
for (int c = 0; c < parts.Length && c < SubTable.Cols; c++)
|
|
data[r * SubTable.Cols + c] = unchecked((byte)(sbyte)ParseInt(parts[c].Trim()));
|
|
}
|
|
return new SubTable { Data = data };
|
|
}
|
|
|
|
private static byte[] BuildBytes(List<(string key, string val)> rows)
|
|
{
|
|
var all = new List<byte>();
|
|
foreach (var (key, val) in rows)
|
|
if (key.Equals("bytes", StringComparison.OrdinalIgnoreCase))
|
|
all.AddRange(ParseHexBytes(val));
|
|
return all.ToArray();
|
|
}
|
|
|
|
// ── Helpers ─────────────────────────────────────────────────────────────
|
|
|
|
private static string Hex8(byte b) => "0x" + b.ToString("X2", CultureInfo.InvariantCulture);
|
|
private static string Hex16(ushort v) => "0x" + v.ToString("X4", CultureInfo.InvariantCulture);
|
|
|
|
private static string HexBytes(byte[] bytes)
|
|
{
|
|
var sb = new StringBuilder(bytes.Length * 3);
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
{
|
|
if (i > 0) sb.Append(' ');
|
|
sb.Append(bytes[i].ToString("X2", CultureInfo.InvariantCulture));
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static byte[] ParseHexBytes(string s)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(s)) return Array.Empty<byte>();
|
|
var toks = s.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
|
|
var outp = new byte[toks.Length];
|
|
for (int i = 0; i < toks.Length; i++)
|
|
{
|
|
var tok = toks[i];
|
|
if (tok.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) tok = tok[2..];
|
|
outp[i] = byte.Parse(tok, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
|
|
}
|
|
return outp;
|
|
}
|
|
|
|
private static int ParseInt(string s)
|
|
{
|
|
s = s.Trim();
|
|
if (s.Length == 0) return 0;
|
|
if (s.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
|
|
return int.Parse(s[2..], NumberStyles.HexNumber, CultureInfo.InvariantCulture);
|
|
return int.Parse(s, NumberStyles.Integer | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
private static string Sha256Hex(string body)
|
|
{
|
|
var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(body));
|
|
var sb = new StringBuilder(bytes.Length * 2);
|
|
foreach (var b in bytes) sb.Append(b.ToString("x2", CultureInfo.InvariantCulture));
|
|
return sb.ToString();
|
|
}
|
|
}
|