@e04/ft8ts 0.0.1

package/src/ft8/encode.ts

@@ -0,0 +1,85 @@
+import { gHex, graymap, icos7 } from "../util/constants.js";
+import { pack77 } from "../util/pack_jt77.js";
+import { generateFT8Waveform, type WaveformOptions } from "../util/waveform.js";
+
+function generateLdpcGMatrix(): number[][] {
+	const K = 91;
+	const M = 83; // 174 - 91
+	const gen: number[][] = Array.from({ length: M }, () => new Array(K).fill(0));
+
+	for (let i = 0; i < M; i++) {
+		const hexStr = gHex[i]!;
+		for (let j = 0; j < 23; j++) {
+			const val = parseInt(hexStr[j]!, 16);
+			const limit = j === 22 ? 3 : 4;
+			for (let jj = 1; jj <= limit; jj++) {
+				const col = j * 4 + jj - 1; // 0-indexed
+				if ((val & (1 << (4 - jj))) !== 0) {
+					gen[i]![col] = 1;
+				}
+			}
+		}
+	}
+	return gen;
+}
+
+const G = generateLdpcGMatrix();
+
+export function encode174_91(msg77: number[]): number[] {
+	const poly = 0x2757;
+	let crc = 0;
+	// padded with 19 zeros (3 zeros + 16 zero-bits for flush)
+	const bitArray = [...msg77, 0, 0, 0, ...new Array(16).fill(0)];
+	for (let bit = 0; bit < 96; bit++) {
+		const nextBit = bitArray[bit]!;
+		if ((crc & 0x2000) !== 0) {
+			crc = ((crc << 1) | nextBit) ^ poly;
+		} else {
+			crc = (crc << 1) | nextBit;
+		}
+		crc &= 0x3fff;
+	}
+
+	const msg91 = [...msg77];
+	for (let i = 0; i < 14; i++) {
+		msg91.push((crc >> (13 - i)) & 1);
+	}
+
+	const codeword = [...msg91];
+	for (let i = 0; i < 83; i++) {
+		let sum = 0;
+		for (let j = 0; j < 91; j++) {
+			sum += msg91[j]! * G[i]![j]!;
+		}
+		codeword.push(sum % 2);
+	}
+	return codeword;
+}
+
+export function getTones(codeword: number[]): number[] {
+	const tones = new Array(79).fill(0);
+
+	for (let i = 0; i < 7; i++) tones[i] = icos7[i]!;
+	for (let i = 0; i < 7; i++) tones[36 + i] = icos7[i]!;
+	for (let i = 0; i < 7; i++) tones[72 + i] = icos7[i]!;
+
+	let k = 7;
+	for (let j = 1; j <= 58; j++) {
+		const i = j * 3 - 3; // codeword is 0-indexed in JS, but the loop was j=1 to 58
+		if (j === 30) k += 7;
+		const indx = codeword[i]! * 4 + codeword[i + 1]! * 2 + codeword[i + 2]!;
+		tones[k] = graymap[indx]!;
+		k++;
+	}
+	return tones;
+}
+
+export function encodeMessage(msg: string): number[] {
+	const bits77 = pack77(msg);
+	const codeword = encode174_91(bits77);
+	return getTones(codeword);
+}
+
+export function encode(msg: string, options: WaveformOptions = {}): Float32Array {
+	return generateFT8Waveform(encodeMessage(msg), options);
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { type DecodedMessage, type DecodeOptions, decode as decodeFT8 } from "./ft8/decode.js";
+export { encode as encodeFT8 } from "./ft8/encode.js";

package/src/util/constants.ts

@@ -0,0 +1,118 @@
+export const SAMPLE_RATE = 12_000;
+export const NSPS = 1920;
+export const NFFT1 = 2 * NSPS; // 3840
+export const NH1 = NFFT1 / 2; // 1920
+export const NSTEP = NSPS / 4; // 480
+export const NMAX = 15 * SAMPLE_RATE; // 180000
+export const NHSYM = Math.floor(NMAX / NSTEP) - 3; // 372
+export const NDOWN = 60;
+export const NN = 79;
+export const NS = 21;
+export const ND = 58;
+export const KK = 91;
+export const N_LDPC = 174;
+export const M_LDPC = N_LDPC - KK; // 83
+
+export const icos7 = [3, 1, 4, 0, 6, 5, 2] as const;
+export const graymap = [0, 1, 3, 2, 5, 6, 4, 7] as const;
+
+export const gHex = [
+	"8329ce11bf31eaf509f27fc",
+	"761c264e25c259335493132",
+	"dc265902fb277c6410a1bdc",
+	"1b3f417858cd2dd33ec7f62",
+	"09fda4fee04195fd034783a",
+	"077cccc11b8873ed5c3d48a",
+	"29b62afe3ca036f4fe1a9da",
+	"6054faf5f35d96d3b0c8c3e",
+	"e20798e4310eed27884ae90",
+	"775c9c08e80e26ddae56318",
+	"b0b811028c2bf997213487c",
+	"18a0c9231fc60adf5c5ea32",
+	"76471e8302a0721e01b12b8",
+	"ffbccb80ca8341fafb47b2e",
+	"66a72a158f9325a2bf67170",
+	"c4243689fe85b1c51363a18",
+	"0dff739414d1a1b34b1c270",
+	"15b48830636c8b99894972e",
+	"29a89c0d3de81d665489b0e",
+	"4f126f37fa51cbe61bd6b94",
+	"99c47239d0d97d3c84e0940",
+	"1919b75119765621bb4f1e8",
+	"09db12d731faee0b86df6b8",
+	"488fc33df43fbdeea4eafb4",
+	"827423ee40b675f756eb5fe",
+	"abe197c484cb74757144a9a",
+	"2b500e4bc0ec5a6d2bdbdd0",
+	"c474aa53d70218761669360",
+	"8eba1a13db3390bd6718cec",
+	"753844673a27782cc42012e",
+	"06ff83a145c37035a5c1268",
+	"3b37417858cc2dd33ec3f62",
+	"9a4a5a28ee17ca9c324842c",
+	"bc29f465309c977e89610a4",
+	"2663ae6ddf8b5ce2bb29488",
+	"46f231efe457034c1814418",
+	"3fb2ce85abe9b0c72e06fbe",
+	"de87481f282c153971a0a2e",
+	"fcd7ccf23c69fa99bba1412",
+	"f0261447e9490ca8e474cec",
+	"4410115818196f95cdd7012",
+	"088fc31df4bfbde2a4eafb4",
+	"b8fef1b6307729fb0a078c0",
+	"5afea7acccb77bbc9d99a90",
+	"49a7016ac653f65ecdc9076",
+	"1944d085be4e7da8d6cc7d0",
+	"251f62adc4032f0ee714002",
+	"56471f8702a0721e00b12b8",
+	"2b8e4923f2dd51e2d537fa0",
+	"6b550a40a66f4755de95c26",
+	"a18ad28d4e27fe92a4f6c84",
+	"10c2e586388cb82a3d80758",
+	"ef34a41817ee02133db2eb0",
+	"7e9c0c54325a9c15836e000",
+	"3693e572d1fde4cdf079e86",
+	"bfb2cec5abe1b0c72e07fbe",
+	"7ee18230c583cccc57d4b08",
+	"a066cb2fedafc9f52664126",
+	"bb23725abc47cc5f4cc4cd2",
+	"ded9dba3bee40c59b5609b4",
+	"d9a7016ac653e6decdc9036",
+	"9ad46aed5f707f280ab5fc4",
+	"e5921c77822587316d7d3c2",
+	"4f14da8242a8b86dca73352",
+	"8b8b507ad467d4441df770e",
+	"22831c9cf1169467ad04b68",
+	"213b838fe2ae54c38ee7180",
+	"5d926b6dd71f085181a4e12",
+	"66ab79d4b29ee6e69509e56",
+	"958148682d748a38dd68baa",
+	"b8ce020cf069c32a723ab14",
+	"f4331d6d461607e95752746",
+	"6da23ba424b9596133cf9c8",
+	"a636bcbc7b30c5fbeae67fe",
+	"5cb0d86a07df654a9089a20",
+	"f11f106848780fc9ecdd80a",
+	"1fbb5364fb8d2c9d730d5ba",
+	"fcb86bc70a50c9d02a5d034",
+	"a534433029eac15f322e34c",
+	"c989d9c7c3d3b8c55d75130",
+	"7bb38b2f0186d46643ae962",
+	"2644ebadeb44b9467d1f42c",
+	"608cc857594bfbb55d69600",
+];
+
+export const CRC_POLY = 0x2757;
+
+export const FTALPH = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?";
+
+export const A1 = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export const A2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export const A3 = "0123456789";
+export const A4 = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export const C38 = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ/";
+
+export const NTOKENS = 2063592;
+export const MAX22 = 4194304; // 2^22
+export const MAX28 = 268435456; // 2^28
+export const MAXGRID4 = 32400;

package/src/util/crc.ts

@@ -0,0 +1,39 @@
+/**
+ * CRC-14 computation and checking, shared between encoder and decoder.
+ * Polynomial: 0x2757 (x^14 + x^13 + x^10 + x^9 + x^8 + x^6 + x^4 + x^2 + x + 1)
+ */
+
+export function computeCRC14(msg77: number[]): number {
+	const poly = 0x2757;
+	let crc = 0;
+	const bitArray = [...msg77, 0, 0, 0, ...(new Array(16).fill(0) as number[])];
+	for (let bit = 0; bit < 96; bit++) {
+		const nextBit = bitArray[bit]!;
+		if ((crc & 0x2000) !== 0) {
+			crc = ((crc << 1) | nextBit) ^ poly;
+		} else {
+			crc = (crc << 1) | nextBit;
+		}
+		crc &= 0x3fff;
+	}
+	return crc;
+}
+
+/**
+ * Check CRC-14 of a 91-bit decoded message (77 message + 14 CRC).
+ * Returns true if CRC is valid.
+ */
+export function checkCRC14(bits91: number[]): boolean {
+	const msg77 = bits91.slice(0, 77);
+	const receivedCRC = bitsToInt(bits91, 77, 14);
+	const computedCRC = computeCRC14(msg77);
+	return receivedCRC === computedCRC;
+}
+
+function bitsToInt(bits: number[], offset: number, count: number): number {
+	let val = 0;
+	for (let i = 0; i < count; i++) {
+		val = (val << 1) | (bits[offset + i] ?? 0);
+	}
+	return val;
+}

package/src/util/decode174_91.ts

@@ -0,0 +1,375 @@
+/**
+ * LDPC (174,91) Belief Propagation decoder for FT8.
+ * Port of bpdecode174_91.f90 and decode174_91.f90.
+ */
+
+import { gHex, KK, M_LDPC, N_LDPC } from "./constants.js";
+import { checkCRC14 } from "./crc.js";
+import { Mn, Nm, ncw, nrw } from "./ldpc_tables.js";
+
+export interface DecodeResult {
+	message91: number[];
+	cw: number[];
+	nharderrors: number;
+	dmin: number;
+	ntype: number;
+}
+
+function platanh(x: number): number {
+	if (x > 0.9999999) return 18.71;
+	if (x < -0.9999999) return -18.71;
+	return 0.5 * Math.log((1 + x) / (1 - x));
+}
+
+/**
+ * BP decoder for (174,91) LDPC code.
+ * llr: log-likelihood ratios (174 values, positive = bit more likely 0)
+ * apmask: AP mask (174 values, 1 = a priori bit, don't update from check messages)
+ * maxIterations: max BP iterations
+ * Returns null if decoding fails, otherwise { message91, cw, nharderrors }
+ */
+export function bpDecode174_91(
+	llr: Float64Array,
+	apmask: Int8Array,
+	maxIterations: number,
+): DecodeResult | null {
+	const N = N_LDPC;
+	const M = M_LDPC;
+
+	const tov = new Float64Array(ncw * N);
+	const toc = new Float64Array(7 * M);
+	const tanhtoc = new Float64Array(7 * M);
+	const zn = new Float64Array(N);
+	const cw = new Int8Array(N);
+
+	// Initialize messages to checks
+	for (let j = 0; j < M; j++) {
+		const w = nrw[j]!;
+		for (let i = 0; i < w; i++) {
+			toc[i * M + j] = llr[Nm[j]![i]!]!;
+		}
+	}
+
+	let nclast = 0;
+	let ncnt = 0;
+
+	for (let iter = 0; iter <= maxIterations; iter++) {
+		// Update bit LLRs
+		for (let i = 0; i < N; i++) {
+			if (apmask[i] !== 1) {
+				let sum = 0;
+				for (let k = 0; k < ncw; k++) sum += tov[k * N + i]!;
+				zn[i] = llr[i]! + sum;
+			} else {
+				zn[i] = llr[i]!;
+			}
+		}
+
+		// Hard decision
+		for (let i = 0; i < N; i++) cw[i] = zn[i]! > 0 ? 1 : 0;
+
+		// Check parity
+		let ncheck = 0;
+		for (let i = 0; i < M; i++) {
+			const w = nrw[i]!;
+			let s = 0;
+			for (let k = 0; k < w; k++) s += cw[Nm[i]![k]!]!;
+			if (s % 2 !== 0) ncheck++;
+		}
+
+		if (ncheck === 0) {
+			const bits91 = Array.from(cw.slice(0, KK));
+			if (checkCRC14(bits91)) {
+				let nharderrors = 0;
+				for (let i = 0; i < N; i++) {
+					if ((2 * cw[i]! - 1) * llr[i]! < 0) nharderrors++;
+				}
+				return {
+					message91: bits91,
+					cw: Array.from(cw),
+					nharderrors,
+					dmin: 0,
+					ntype: 1,
+				};
+			}
+		}
+
+		// Early stopping
+		if (iter > 0) {
+			const nd = ncheck - nclast;
+			if (nd < 0) {
+				ncnt = 0;
+			} else {
+				ncnt++;
+			}
+			if (ncnt >= 5 && iter >= 10 && ncheck > 15) return null;
+		}
+		nclast = ncheck;
+
+		// Send messages from bits to check nodes
+		for (let j = 0; j < M; j++) {
+			const w = nrw[j]!;
+			for (let i = 0; i < w; i++) {
+				const ibj = Nm[j]![i]!;
+				let val = zn[ibj]!;
+				for (let kk = 0; kk < ncw; kk++) {
+					if (Mn[ibj]![kk] === j) {
+						val -= tov[kk * N + ibj]!;
+					}
+				}
+				toc[i * M + j] = val;
+			}
+		}
+
+		// Send messages from check nodes to variable nodes
+		for (let i = 0; i < M; i++) {
+			for (let k = 0; k < 7; k++) {
+				tanhtoc[k * M + i] = Math.tanh(-toc[k * M + i]! / 2);
+			}
+		}
+
+		for (let j = 0; j < N; j++) {
+			for (let i = 0; i < ncw; i++) {
+				const ichk = Mn[j]![i]!;
+				const w = nrw[ichk]!;
+				let Tmn = 1.0;
+				for (let k = 0; k < w; k++) {
+					if (Nm[ichk]![k] !== j) {
+						Tmn *= tanhtoc[k * M + ichk]!;
+					}
+				}
+				tov[i * N + j] = 2 * platanh(-Tmn);
+			}
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Hybrid BP + OSD-like decoder for (174,91) code.
+ * Tries BP first, then falls back to OSD approach for deeper decoding.
+ */
+export function decode174_91(
+	llr: Float64Array,
+	apmask: Int8Array,
+	maxosd: number,
+): DecodeResult | null {
+	const maxIterations = 30;
+
+	// Try BP decoding
+	const bpResult = bpDecode174_91(llr, apmask, maxIterations);
+	if (bpResult) return bpResult;
+
+	// OSD-0 fallback: try hard-decision with bit flipping for most unreliable bits
+	if (maxosd >= 0) {
+		return osdDecode174_91(llr, apmask, maxosd >= 1 ? 2 : 1);
+	}
+
+	return null;
+}
+
+/**
+ * Simplified OSD decoder for (174,91) code.
+ * Uses ordered statistics approach: sort bits by reliability,
+ * do Gaussian elimination, try flipping least reliable info bits.
+ */
+function osdDecode174_91(
+	llr: Float64Array,
+	apmask: Int8Array,
+	norder: number,
+): DecodeResult | null {
+	const N = N_LDPC;
+	const K = KK;
+
+	const gen = getGenerator();
+
+	// Sort by reliability (descending)
+	const indices = Array.from({ length: N }, (_, i) => i);
+	indices.sort((a, b) => Math.abs(llr[b]!) - Math.abs(llr[a]!));
+
+	// Reorder generator matrix columns
+	const genmrb = new Uint8Array(K * N);
+	for (let i = 0; i < N; i++) {
+		for (let k = 0; k < K; k++) {
+			genmrb[k * N + i] = gen[k * N + indices[i]!]!;
+		}
+	}
+
+	// Gaussian elimination to get systematic form on the K most-reliable bits
+	for (let id = 0; id < K; id++) {
+		let found = false;
+		for (let icol = id; icol < Math.min(K + 20, N); icol++) {
+			if (genmrb[id * N + icol] === 1) {
+				if (icol !== id) {
+					// Swap columns
+					for (let k = 0; k < K; k++) {
+						const tmp = genmrb[k * N + id]!;
+						genmrb[k * N + id] = genmrb[k * N + icol]!;
+						genmrb[k * N + icol] = tmp;
+					}
+					const tmp = indices[id]!;
+					indices[id] = indices[icol]!;
+					indices[icol] = tmp;
+				}
+				for (let ii = 0; ii < K; ii++) {
+					if (ii !== id && genmrb[ii * N + id] === 1) {
+						for (let c = 0; c < N; c++) {
+							genmrb[ii * N + c]! ^= genmrb[id * N + c]!;
+						}
+					}
+				}
+				found = true;
+				break;
+			}
+		}
+		if (!found) return null;
+	}
+
+	// Hard decisions on reordered received word
+	const hdec = new Int8Array(N);
+	for (let i = 0; i < N; i++) {
+		hdec[i] = llr[indices[i]!]! >= 0 ? 1 : 0;
+	}
+	const absrx = new Float64Array(N);
+	for (let i = 0; i < N; i++) {
+		absrx[i] = Math.abs(llr[indices[i]!]!);
+	}
+
+	// Transpose of reordered gen matrix
+	const g2 = new Uint8Array(N * K);
+	for (let i = 0; i < K; i++) {
+		for (let j = 0; j < N; j++) {
+			g2[j * K + i] = genmrb[i * N + j]!;
+		}
+	}
+
+	function mrbencode(me: Int8Array): Int8Array {
+		const codeword = new Int8Array(N);
+		for (let i = 0; i < K; i++) {
+			if (me[i] === 1) {
+				for (let j = 0; j < N; j++) {
+					codeword[j]! ^= g2[j * K + i]!;
+				}
+			}
+		}
+		return codeword;
+	}
+
+	const m0 = hdec.slice(0, K);
+	const c0 = mrbencode(m0);
+	const bestCw = new Int8Array(c0);
+	let dmin = 0;
+	for (let i = 0; i < N; i++) {
+		const x = c0[i]! ^ hdec[i]!;
+		dmin += x * absrx[i]!;
+	}
+
+	// Order-1: flip single bits in the info portion
+	for (let i1 = K - 1; i1 >= 0; i1--) {
+		if (apmask[indices[i1]!] === 1) continue;
+		const me = new Int8Array(m0);
+		me[i1]! ^= 1;
+		const ce = mrbencode(me);
+		let _nh = 0;
+		let dd = 0;
+		for (let j = 0; j < N; j++) {
+			const x = ce[j]! ^ hdec[j]!;
+			_nh += x;
+			dd += x * absrx[j]!;
+		}
+		if (dd < dmin) {
+			dmin = dd;
+			bestCw.set(ce);
+		}
+	}
+
+	// Order-2: flip pairs of least-reliable info bits (limited search)
+	if (norder >= 2) {
+		const ntry = Math.min(40, K);
+		for (let i1 = K - 1; i1 >= K - ntry; i1--) {
+			if (apmask[indices[i1]!] === 1) continue;
+			for (let i2 = i1 - 1; i2 >= K - ntry; i2--) {
+				if (apmask[indices[i2]!] === 1) continue;
+				const me = new Int8Array(m0);
+				me[i1]! ^= 1;
+				me[i2]! ^= 1;
+				const ce = mrbencode(me);
+				let _nh = 0;
+				let dd = 0;
+				for (let j = 0; j < N; j++) {
+					const x = ce[j]! ^ hdec[j]!;
+					_nh += x;
+					dd += x * absrx[j]!;
+				}
+				if (dd < dmin) {
+					dmin = dd;
+					bestCw.set(ce);
+				}
+			}
+		}
+	}
+
+	// Reorder codeword back to original order
+	const finalCw = new Int8Array(N);
+	for (let i = 0; i < N; i++) {
+		finalCw[indices[i]!] = bestCw[i]!;
+	}
+
+	const bits91 = Array.from(finalCw.slice(0, KK));
+	if (!checkCRC14(bits91)) return null;
+
+	// Compute dmin in original order
+	let dminOrig = 0;
+	const hdecOrig = new Int8Array(N);
+	for (let i = 0; i < N; i++) hdecOrig[i] = llr[i]! >= 0 ? 1 : 0;
+	let nhe = 0;
+	for (let i = 0; i < N; i++) {
+		const x = finalCw[i]! ^ hdecOrig[i]!;
+		nhe += x;
+		dminOrig += x * Math.abs(llr[i]!);
+	}
+
+	return {
+		message91: bits91,
+		cw: Array.from(finalCw),
+		nharderrors: nhe,
+		dmin: dminOrig,
+		ntype: 2,
+	};
+}
+
+let _generator: Uint8Array | null = null;
+
+function getGenerator(): Uint8Array {
+	if (_generator) return _generator;
+
+	const K = KK;
+	const N = N_LDPC;
+	const M = M_LDPC;
+
+	// Build full generator matrix (K×N) where first K columns are identity
+	const gen = new Uint8Array(K * N);
+
+	for (let i = 0; i < K; i++) gen[i * N + i] = 1;
+
+	// gHex encodes the M×K generator parity matrix
+	// gen_parity[m][k] = 1 means info bit k contributes to parity bit m
+	for (let m = 0; m < M; m++) {
+		const hexStr = gHex[m]!;
+		for (let j = 0; j < 23; j++) {
+			const val = parseInt(hexStr[j]!, 16);
+			const limit = j === 22 ? 3 : 4;
+			for (let jj = 1; jj <= limit; jj++) {
+				const col = j * 4 + jj - 1;
+				if (col < K && (val & (1 << (4 - jj))) !== 0) {
+					// For info bit `col`, parity bit `m` is set
+					gen[col * N + K + m] = 1;
+				}
+			}
+		}
+	}
+
+	_generator = gen;
+	return gen;
+}