@e04/ft8ts 0.0.6 → 0.0.9

package/src/cli.ts

@@ -0,0 +1,171 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import {
+	type DecodedMessage,
+	type DecodeOptions,
+	decodeFT4,
+	decodeFT8,
+	encodeFT8,
+} from "./index.js";
+import { parseWavBuffer, writeMono16WavFile } from "./util/wav.js";
+
+const SAMPLE_RATE = 12_000;
+const DEFAULT_OUTPUT = "output.wav";
+const DEFAULT_DF_HZ = 1_000;
+
+function printUsage(): void {
+	console.error(`ft8ts - FT8 encoder/decoder
+
+Usage:
+  ft8ts decode <file.wav> [options]
+  ft8ts encode "<message>" [options]
+
+Decode options:
+  --mode <ft8|ft4>  Mode: ft8 (default) or ft4
+  --low <hz>     Lower frequency bound (default: 200)
+  --high <hz>    Upper frequency bound (default: 3000)
+  --depth <1|2|3>  Decoding depth (default: 2)
+
+Encode options:
+  --out <file>   Output WAV file (default: output.wav)
+  --df <hz>      Base frequency in Hz (default: 1000)
+`);
+}
+
+function formatMessage(d: DecodedMessage): string {
+	const freq = d.freq.toFixed(0).padStart(5);
+	const dt = (d.dt >= 0 ? "+" : "") + d.dt.toFixed(1);
+	const snr = (d.snr >= 0 ? "+" : "") + Math.round(d.snr).toString().padStart(3);
+	return `${dt.padStart(5)}  ${snr}  ${freq}  ${d.msg}`;
+}
+
+function runDecode(argv: string[]): void {
+	if (argv.length === 0) {
+		console.error("Error: missing input file");
+		printUsage();
+		process.exit(1);
+	}
+
+	const wavFile = argv[0]!;
+	const options: DecodeOptions = {};
+	let mode: "ft8" | "ft4" = "ft8";
+
+	for (let i = 1; i < argv.length; i++) {
+		const arg = argv[i]!;
+		if (arg === "--mode") {
+			const value = argv[++i];
+			if (value === "ft8" || value === "ft4") {
+				mode = value;
+			} else {
+				throw new Error(`Invalid --mode: ${value ?? "(missing)"}. Use ft8 or ft4`);
+			}
+		} else if (arg === "--low") {
+			options.freqLow = Number(argv[++i]);
+		} else if (arg === "--high") {
+			options.freqHigh = Number(argv[++i]);
+		} else if (arg === "--depth") {
+			options.depth = Number(argv[++i]);
+		} else {
+			throw new Error(`Unknown argument: ${arg}`);
+		}
+	}
+
+	const filePath = resolve(process.cwd(), wavFile);
+	console.log(`Reading ${filePath}...`);
+
+	const { sampleRate, samples } = parseWavBuffer(readFileSync(filePath));
+	console.log(
+		`WAV: ${sampleRate} Hz, ${samples.length} samples, ${(samples.length / sampleRate).toFixed(1)}s`,
+	);
+
+	const startTime = performance.now();
+	const decoded =
+		mode === "ft4"
+			? decodeFT4(samples, { ...options, sampleRate })
+			: decodeFT8(samples, { ...options, sampleRate });
+	const elapsed = performance.now() - startTime;
+
+	console.log(`\nDecoded ${decoded.length} messages in ${(elapsed / 1000).toFixed(2)}s:\n`);
+	console.log("   dt  snr   freq  message");
+	console.log("  ---  ---  -----  -------");
+	for (const d of decoded) {
+		console.log(formatMessage(d));
+	}
+}
+
+function runEncode(argv: string[]): void {
+	if (argv.length === 0) {
+		console.error("Error: missing message");
+		printUsage();
+		process.exit(1);
+	}
+
+	const message = argv[0]!;
+	let outputFile = DEFAULT_OUTPUT;
+	let dfHz = DEFAULT_DF_HZ;
+
+	for (let i = 1; i < argv.length; i++) {
+		const arg = argv[i]!;
+		if (arg === "--out") {
+			i++;
+			const value = argv[i];
+			if (!value) throw new Error("Missing value for --out");
+			outputFile = value;
+		} else if (arg === "--df") {
+			i++;
+			const value = argv[i];
+			if (!value) throw new Error("Missing value for --df");
+			const parsed = Number(value);
+			if (!Number.isFinite(parsed) || parsed < 0) {
+				throw new Error(`Invalid --df value: ${value}`);
+			}
+			dfHz = parsed;
+		} else {
+			throw new Error(`Unknown argument: ${arg}`);
+		}
+	}
+
+	const waveform = encodeFT8(message, {
+		sampleRate: SAMPLE_RATE,
+		samplesPerSymbol: 1_920,
+		baseFrequency: dfHz,
+	});
+
+	const outPath = resolve(process.cwd(), outputFile);
+	writeMono16WavFile(outPath, waveform, SAMPLE_RATE);
+
+	console.log(
+		`Wrote ${outPath} (${waveform.length} samples, ${(waveform.length / SAMPLE_RATE).toFixed(3)} s)`,
+	);
+}
+
+function main(): void {
+	const args = process.argv.slice(2);
+	const subcommand = args[0];
+	const subArgs = args.slice(1);
+
+	if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+		printUsage();
+		process.exit(0);
+	}
+
+	try {
+		if (subcommand === "decode") {
+			runDecode(subArgs);
+		} else if (subcommand === "encode") {
+			runEncode(subArgs);
+		} else {
+			console.error(`Error: unknown subcommand '${subcommand}'`);
+			printUsage();
+			process.exit(1);
+		}
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.error(`Error: ${msg}`);
+		printUsage();
+		process.exit(1);
+	}
+}
+
+main();

package/src/ft4/constants.ts

@@ -0,0 +1,41 @@
+/** FT4-specific constants (lib/ft4/ft4_params.f90). */
+
+import { SAMPLE_RATE } from "../util/constants.js";
+
+export const COSTAS_A = [0, 1, 3, 2] as const;
+export const COSTAS_B = [1, 0, 2, 3] as const;
+export const COSTAS_C = [2, 3, 1, 0] as const;
+export const COSTAS_D = [3, 2, 0, 1] as const;
+export const GRAYMAP = [0, 1, 3, 2] as const;
+
+// Message scrambling vector (rvec) from WSJT-X.
+export const RVEC = [
+	0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1,
+	0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0,
+	1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1,
+] as const;
+
+export const NSPS = 576;
+export const NFFT1 = 4 * NSPS; // 2304
+export const NH1 = NFFT1 / 2; // 1152
+export const NSTEP = NSPS;
+export const NMAX = 21 * 3456; // 72576
+export const NHSYM = Math.floor((NMAX - NFFT1) / NSTEP); // 122
+export const NDOWN = 18;
+export const ND = 87;
+export const NS = 16;
+export const NN = NS + ND; // 103
+
+export const NFFT2 = NMAX / NDOWN; // 4032
+export const NSS = NSPS / NDOWN; // 32
+export const FS2 = SAMPLE_RATE / NDOWN; // 666.67 Hz
+export const MAX_FREQ = 4910;
+export const SYNC_PASS_MIN = 1.2;
+export const TWO_PI = 2 * Math.PI;
+
+export const HARD_SYNC_PATTERNS = [
+	{ offset: 0, bits: [0, 0, 0, 1, 1, 0, 1, 1] as const },
+	{ offset: 66, bits: [0, 1, 0, 0, 1, 1, 1, 0] as const },
+	{ offset: 132, bits: [1, 1, 1, 0, 0, 1, 0, 0] as const },
+	{ offset: 198, bits: [1, 0, 1, 1, 0, 0, 0, 1] as const },
+] as const;