@e04/ft8ts 0.0.8 → 0.0.10

package/src/ft8/encode.ts

@@ -1,6 +1,7 @@
-import { gHex, graymap, icos7 } from "../util/constants.js";
+import { gHex } from "../util/constants.js";
 import { pack77 } from "../util/pack_jt77.js";
 import { generateFT8Waveform, type WaveformOptions } from "../util/waveform.js";
+import { COSTAS, GRAY_MAP } from "./constants.js";
 
 function generateLdpcGMatrix(): number[][] {
 	const K = 91;
@@ -59,16 +60,16 @@ export function encode174_91(msg77: number[]): number[] {
 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]!;
+	for (let i = 0; i < 7; i++) tones[i] = COSTAS[i]!;
+	for (let i = 0; i < 7; i++) tones[36 + i] = COSTAS[i]!;
+	for (let i = 0; i < 7; i++) tones[72 + i] = COSTAS[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]!;
+		tones[k] = GRAY_MAP[indx]!;
 		k++;
 	}
 	return tones;

package/src/index.ts

@@ -1,3 +1,9 @@
+export {
+	type DecodedMessage as DecodedFT4Message,
+	type DecodeOptions as DecodeFT4Options,
+	decode as decodeFT4,
+} from "./ft4/decode.js";
+export { encode as encodeFT4 } from "./ft4/encode.js";
 export { type DecodedMessage, type DecodeOptions, decode as decodeFT8 } from "./ft8/decode.js";
 export { encode as encodeFT8 } from "./ft8/encode.js";
 export { HashCallBook } from "./util/hashcall.js";

package/src/util/constants.ts

@@ -1,20 +1,9 @@
+/** Shared constants used by FT8, FT4, pack77, etc. */
+
 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;
+/** LDPC(174,91) code (shared by FT8 and FT4). */
+export const N_LDPC = 174;
 
 export const gHex = [
 	"8329ce11bf31eaf509f27fc",
@@ -102,8 +91,6 @@ export const gHex = [
 	"608cc857594bfbb55d69600",
 ];
 
-export const CRC_POLY = 0x2757;
-
 export const FTALPH = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?";
 
 export const A1 = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

package/src/util/decode174_91.ts

@@ -3,10 +3,13 @@
  * Port of bpdecode174_91.f90 and decode174_91.f90.
  */
 
-import { gHex, KK, M_LDPC, N_LDPC } from "./constants.js";
+import { gHex, N_LDPC } from "./constants.js";
 import { checkCRC14 } from "./crc.js";
 import { Mn, Nm, ncw, nrw } from "./ldpc_tables.js";
 
+const KK = 91;
+const M_LDPC = N_LDPC - KK; // 83
+
 export interface DecodeResult {
 	message91: number[];
 	cw: number[];
@@ -183,39 +186,48 @@ function osdDecode174_91(
 	const K = KK;
 
 	const gen = getGenerator();
+	const absllr = new Float64Array(N);
+	for (let i = 0; i < N; i++) absllr[i] = Math.abs(llr[i]!);
 
 	// Sort by reliability (descending)
-	const indices = Array.from({ length: N }, (_, i) => i);
-	indices.sort((a, b) => Math.abs(llr[b]!) - Math.abs(llr[a]!));
+	const indices = new Array<number>(N);
+	for (let i = 0; i < N; i++) indices[i] = i;
+	indices.sort((a, b) => absllr[b]! - absllr[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]!]!;
+	for (let k = 0; k < K; k++) {
+		const row = k * N;
+		for (let i = 0; i < N; i++) {
+			genmrb[row + i] = gen[row + indices[i]!]!;
 		}
 	}
 
 	// Gaussian elimination to get systematic form on the K most-reliable bits
+	const maxPivotCol = Math.min(K + 20, N);
 	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) {
+		const idRow = id * N;
+		for (let icol = id; icol < maxPivotCol; icol++) {
+			if (genmrb[idRow + 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 row = k * N;
+						const tmp = genmrb[row + id]!;
+						genmrb[row + id] = genmrb[row + icol]!;
+						genmrb[row + 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) {
+					if (ii === id) continue;
+					const iiRow = ii * N;
+					if (genmrb[iiRow + id] === 1) {
 						for (let c = 0; c < N; c++) {
-							genmrb[ii * N + c]! ^= genmrb[id * N + c]!;
+							genmrb[iiRow + c]! ^= genmrb[idRow + c]!;
 						}
 					}
 				}
@@ -229,87 +241,82 @@ function osdDecode174_91(
 	// 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 idx = indices[i]!;
+		hdec[i] = llr[idx]! >= 0 ? 1 : 0;
 	}
 	const absrx = new Float64Array(N);
 	for (let i = 0; i < N; i++) {
-		absrx[i] = Math.abs(llr[indices[i]!]!);
+		absrx[i] = absllr[indices[i]!]!;
 	}
 
-	// Transpose of reordered gen matrix
-	const g2 = new Uint8Array(N * K);
+	// Encode hard decision on MRB (c0): xor selected rows of genmrb.
+	const c0 = new Int8Array(N);
 	for (let i = 0; i < K; i++) {
+		if (hdec[i] !== 1) continue;
+		const row = i * N;
 		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]!;
-				}
-			}
+			c0[j]! ^= genmrb[row + j]!;
 		}
-		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]!;
 	}
+	let bestFlip1 = -1;
+	let bestFlip2 = -1;
 
 	// 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;
+		const row1 = i1 * N;
 		let dd = 0;
 		for (let j = 0; j < N; j++) {
-			const x = ce[j]! ^ hdec[j]!;
-			_nh += x;
+			const x = c0[j]! ^ genmrb[row1 + j]! ^ hdec[j]!;
 			dd += x * absrx[j]!;
 		}
 		if (dd < dmin) {
 			dmin = dd;
-			bestCw.set(ce);
+			bestFlip1 = i1;
+			bestFlip2 = -1;
 		}
 	}
 
 	// 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--) {
+		const ntry = Math.min(64, K);
+		const iMin = Math.max(0, K - ntry);
+		for (let i1 = K - 1; i1 >= iMin; i1--) {
 			if (apmask[indices[i1]!] === 1) continue;
-			for (let i2 = i1 - 1; i2 >= K - ntry; i2--) {
+			const row1 = i1 * N;
+			for (let i2 = i1 - 1; i2 >= iMin; 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;
+				const row2 = i2 * N;
 				let dd = 0;
 				for (let j = 0; j < N; j++) {
-					const x = ce[j]! ^ hdec[j]!;
-					_nh += x;
+					const x = c0[j]! ^ genmrb[row1 + j]! ^ genmrb[row2 + j]! ^ hdec[j]!;
 					dd += x * absrx[j]!;
 				}
 				if (dd < dmin) {
 					dmin = dd;
-					bestCw.set(ce);
+					bestFlip1 = i1;
+					bestFlip2 = i2;
 				}
 			}
 		}
 	}
 
+	const bestCw = new Int8Array(c0);
+	if (bestFlip1 >= 0) {
+		const row1 = bestFlip1 * N;
+		for (let j = 0; j < N; j++) bestCw[j]! ^= genmrb[row1 + j]!;
+		if (bestFlip2 >= 0) {
+			const row2 = bestFlip2 * N;
+			for (let j = 0; j < N; j++) bestCw[j]! ^= genmrb[row2 + j]!;
+		}
+	}
+
 	// Reorder codeword back to original order
 	const finalCw = new Int8Array(N);
 	for (let i = 0; i < N; i++) {
@@ -321,13 +328,12 @@ function osdDecode174_91(
 
 	// 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]!;
+		const hard = llr[i]! >= 0 ? 1 : 0;
+		const x = finalCw[i]! ^ hard;
 		nhe += x;
-		dminOrig += x * Math.abs(llr[i]!);
+		dminOrig += x * absllr[i]!;
 	}
 
 	return {

package/src/util/fft.ts

@@ -3,6 +3,23 @@
  * Supports real-to-complex, complex-to-complex, and inverse transforms.
  */
 
+interface Radix2Plan {
+	bitReversed: Uint32Array;
+}
+
+interface BluesteinPlan {
+	m: number;
+	chirpRe: Float64Array;
+	chirpIm: Float64Array;
+	bFftRe: Float64Array;
+	bFftIm: Float64Array;
+	aRe: Float64Array;
+	aIm: Float64Array;
+}
+
+const RADIX2_PLAN_CACHE = new Map<number, Radix2Plan>();
+const BLUESTEIN_PLAN_CACHE = new Map<string, BluesteinPlan>();
+
 export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean): void {
 	const n = re.length;
 	if (n <= 1) return;
@@ -12,9 +29,11 @@ export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean)
 		return;
 	}
 
+	const { bitReversed } = getRadix2Plan(n);
+
 	// Bit-reversal permutation
-	let j = 0;
 	for (let i = 0; i < n; i++) {
+		const j = bitReversed[i]!;
 		if (j > i) {
 			let tmp = re[i]!;
 			re[i] = re[j]!;
@@ -23,12 +42,6 @@ export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean)
 			im[i] = im[j]!;
 			im[j] = tmp;
 		}
-		let m = n >> 1;
-		while (m >= 1 && j >= m) {
-			j -= m;
-			m >>= 1;
-		}
-		j += m;
 	}
 
 	const sign = inverse ? 1 : -1;
@@ -59,56 +72,46 @@ export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean)
 	}
 
 	if (inverse) {
+		const scale = 1 / n;
 		for (let i = 0; i < n; i++) {
-			re[i]! /= n;
-			im[i]! /= n;
+			re[i] = re[i]! * scale;
+			im[i] = im[i]! * scale;
 		}
 	}
 }
 
 function bluestein(re: Float64Array, im: Float64Array, inverse: boolean): void {
 	const n = re.length;
-	const m = nextPow2(n * 2 - 1);
-	const s = inverse ? 1 : -1;
-
-	const aRe = new Float64Array(m);
-	const aIm = new Float64Array(m);
-	const bRe = new Float64Array(m);
-	const bIm = new Float64Array(m);
+	const { m, chirpRe, chirpIm, bFftRe, bFftIm, aRe, aIm } = getBluesteinPlan(n, inverse);
 
+	aRe.fill(0);
+	aIm.fill(0);
 	for (let i = 0; i < n; i++) {
-		const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
-		const cosA = Math.cos(angle);
-		const sinA = Math.sin(angle);
-
-		aRe[i] = re[i]! * cosA - im[i]! * sinA;
-		aIm[i] = re[i]! * sinA + im[i]! * cosA;
-
-		bRe[i] = cosA;
-		bIm[i] = -sinA;
-	}
-	for (let i = 1; i < n; i++) {
-		bRe[m - i] = bRe[i]!;
-		bIm[m - i] = bIm[i]!;
+		const cosA = chirpRe[i]!;
+		const sinA = chirpIm[i]!;
+		const inRe = re[i]!;
+		const inIm = im[i]!;
+		aRe[i] = inRe * cosA - inIm * sinA;
+		aIm[i] = inRe * sinA + inIm * cosA;
 	}
 
 	fftComplex(aRe, aIm, false);
-	fftComplex(bRe, bIm, false);
 
 	for (let i = 0; i < m; i++) {
-		const r = aRe[i]! * bRe[i]! - aIm[i]! * bIm[i]!;
-		const iIm = aRe[i]! * bIm[i]! + aIm[i]! * bRe[i]!;
-		aRe[i] = r;
-		aIm[i] = iIm;
+		const ar = aRe[i]!;
+		const ai = aIm[i]!;
+		const br = bFftRe[i]!;
+		const bi = bFftIm[i]!;
+		aRe[i] = ar * br - ai * bi;
+		aIm[i] = ar * bi + ai * br;
 	}
 
 	fftComplex(aRe, aIm, true);
 
 	const scale = inverse ? 1 / n : 1;
 	for (let i = 0; i < n; i++) {
-		const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
-		const cosA = Math.cos(angle);
-		const sinA = Math.sin(angle);
+		const cosA = chirpRe[i]!;
+		const sinA = chirpIm[i]!;
 
 		const r = aRe[i]! * cosA - aIm[i]! * sinA;
 		const iIm = aRe[i]! * sinA + aIm[i]! * cosA;
@@ -117,6 +120,63 @@ function bluestein(re: Float64Array, im: Float64Array, inverse: boolean): void {
 	}
 }
 
+function getRadix2Plan(n: number): Radix2Plan {
+	let plan = RADIX2_PLAN_CACHE.get(n);
+	if (plan) return plan;
+
+	const bits = 31 - Math.clz32(n);
+	const bitReversed = new Uint32Array(n);
+	for (let i = 1; i < n; i++) {
+		bitReversed[i] = (bitReversed[i >> 1]! >> 1) | ((i & 1) << (bits - 1));
+	}
+
+	plan = { bitReversed };
+	RADIX2_PLAN_CACHE.set(n, plan);
+	return plan;
+}
+
+function getBluesteinPlan(n: number, inverse: boolean): BluesteinPlan {
+	const key = `${n}:${inverse ? 1 : 0}`;
+	const cached = BLUESTEIN_PLAN_CACHE.get(key);
+	if (cached) return cached;
+
+	const m = nextPow2(n * 2 - 1);
+	const s = inverse ? 1 : -1;
+	const chirpRe = new Float64Array(n);
+	const chirpIm = new Float64Array(n);
+	for (let i = 0; i < n; i++) {
+		const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
+		chirpRe[i] = Math.cos(angle);
+		chirpIm[i] = Math.sin(angle);
+	}
+
+	const bFftRe = new Float64Array(m);
+	const bFftIm = new Float64Array(m);
+	for (let i = 0; i < n; i++) {
+		const cosA = chirpRe[i]!;
+		const sinA = chirpIm[i]!;
+		bFftRe[i] = cosA;
+		bFftIm[i] = -sinA;
+	}
+	for (let i = 1; i < n; i++) {
+		bFftRe[m - i] = bFftRe[i]!;
+		bFftIm[m - i] = bFftIm[i]!;
+	}
+	fftComplex(bFftRe, bFftIm, false);
+
+	const plan: BluesteinPlan = {
+		m,
+		chirpRe,
+		chirpIm,
+		bFftRe,
+		bFftIm,
+		aRe: new Float64Array(m),
+		aIm: new Float64Array(m),
+	};
+	BLUESTEIN_PLAN_CACHE.set(key, plan);
+	return plan;
+}
+
 /**
  * Real-to-complex FFT. Input: n real values. Output: n/2+1 complex values
  * stored in re[0..n/2] and im[0..n/2].

package/src/util/waveform.ts

@@ -1,7 +1,11 @@
 const TWO_PI = 2 * Math.PI;
-const DEFAULT_SAMPLE_RATE = 12_000;
-const DEFAULT_SAMPLES_PER_SYMBOL = 1_920;
-const DEFAULT_BT = 2.0;
+const FT8_DEFAULT_SAMPLE_RATE = 12_000;
+const FT8_DEFAULT_SAMPLES_PER_SYMBOL = 1_920;
+const FT8_DEFAULT_BT = 2.0;
+
+const FT4_DEFAULT_SAMPLE_RATE = 12_000;
+const FT4_DEFAULT_SAMPLES_PER_SYMBOL = 576;
+const FT4_DEFAULT_BT = 1.0;
 const MODULATION_INDEX = 1.0;
 
 export interface WaveformOptions {
@@ -9,6 +13,18 @@ export interface WaveformOptions {
 	samplesPerSymbol?: number;
 	bt?: number;
 	baseFrequency?: number;
+	initialPhase?: number;
+}
+
+interface WaveformDefaults {
+	sampleRate: number;
+	samplesPerSymbol: number;
+	bt: number;
+}
+
+interface WaveformShape {
+	includeRampSymbols: boolean;
+	fullSymbolRamp: boolean;
 }
 
 function assertPositiveFinite(value: number, name: string): void {
@@ -36,20 +52,22 @@ function gfskPulse(bt: number, tt: number): number {
 	return 0.5 * (erfApprox(scale * (tt + 0.5)) - erfApprox(scale * (tt - 0.5)));
 }
 
-export function generateFT8Waveform(
+function generateGfskWaveform(
 	tones: readonly number[],
-	options: WaveformOptions = {},
+	options: WaveformOptions,
+	defaults: WaveformDefaults,
+	shape: WaveformShape,
 ): Float32Array {
-	// Mirrors the FT8 path in lib/ft8/gen_ft8wave.f90.
 	const nsym = tones.length;
 	if (nsym === 0) {
 		return new Float32Array(0);
 	}
 
-	const sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
-	const nsps = options.samplesPerSymbol ?? DEFAULT_SAMPLES_PER_SYMBOL;
-	const bt = options.bt ?? DEFAULT_BT;
+	const sampleRate = options.sampleRate ?? defaults.sampleRate;
+	const nsps = options.samplesPerSymbol ?? defaults.samplesPerSymbol;
+	const bt = options.bt ?? defaults.bt;
 	const f0 = options.baseFrequency ?? 0;
+	const initialPhase = options.initialPhase ?? 0;
 
 	assertPositiveFinite(sampleRate, "sampleRate");
 	assertPositiveFinite(nsps, "samplesPerSymbol");
@@ -57,11 +75,14 @@ export function generateFT8Waveform(
 	if (!Number.isFinite(f0)) {
 		throw new Error("baseFrequency must be finite");
 	}
+	if (!Number.isFinite(initialPhase)) {
+		throw new Error("initialPhase must be finite");
+	}
 	if (!Number.isInteger(nsps)) {
 		throw new Error("samplesPerSymbol must be an integer");
 	}
 
-	const nwave = nsym * nsps;
+	const nwave = (shape.includeRampSymbols ? nsym + 2 : nsym) * nsps;
 	const pulse = new Float64Array(3 * nsps);
 	for (let i = 0; i < pulse.length; i++) {
 		const tt = (i + 1 - 1.5 * nsps) / nsps;
@@ -93,9 +114,11 @@ export function generateFT8Waveform(
 	}
 
 	const wave = new Float32Array(nwave);
-	let phi = 0;
+	let phi = initialPhase % TWO_PI;
+	if (phi < 0) phi += TWO_PI;
+	const phaseStart = shape.includeRampSymbols ? 0 : nsps;
 	for (let k = 0; k < nwave; k++) {
-		const j = nsps + k; // skip the leading dummy symbol
+		const j = phaseStart + k;
 		wave[k] = Math.sin(phi);
 		phi += dphi[j]!;
 		phi %= TWO_PI;
@@ -104,17 +127,70 @@ export function generateFT8Waveform(
 		}
 	}
 
-	const nramp = Math.round(nsps / 8);
-	for (let i = 0; i < nramp; i++) {
-		const up = (1 - Math.cos((TWO_PI * i) / (2 * nramp))) / 2;
-		wave[i]! *= up;
-	}
+	if (shape.fullSymbolRamp) {
+		for (let i = 0; i < nsps; i++) {
+			const up = (1 - Math.cos((TWO_PI * i) / (2 * nsps))) / 2;
+			wave[i]! *= up;
+		}
+
+		const tailStart = (nsym + 1) * nsps;
+		for (let i = 0; i < nsps; i++) {
+			const down = (1 + Math.cos((TWO_PI * i) / (2 * nsps))) / 2;
+			wave[tailStart + i]! *= down;
+		}
+	} else {
+		const nramp = Math.round(nsps / 8);
+		for (let i = 0; i < nramp; i++) {
+			const up = (1 - Math.cos((TWO_PI * i) / (2 * nramp))) / 2;
+			wave[i]! *= up;
+		}
 
-	const tailStart = nwave - nramp;
-	for (let i = 0; i < nramp; i++) {
-		const down = (1 + Math.cos((TWO_PI * i) / (2 * nramp))) / 2;
-		wave[tailStart + i]! *= down;
+		const tailStart = nwave - nramp;
+		for (let i = 0; i < nramp; i++) {
+			const down = (1 + Math.cos((TWO_PI * i) / (2 * nramp))) / 2;
+			wave[tailStart + i]! *= down;
+		}
 	}
 
 	return wave;
 }
+
+export function generateFT8Waveform(
+	tones: readonly number[],
+	options: WaveformOptions = {},
+): Float32Array {
+	// Mirrors the FT8 path in lib/ft8/gen_ft8wave.f90.
+	return generateGfskWaveform(
+		tones,
+		options,
+		{
+			sampleRate: FT8_DEFAULT_SAMPLE_RATE,
+			samplesPerSymbol: FT8_DEFAULT_SAMPLES_PER_SYMBOL,
+			bt: FT8_DEFAULT_BT,
+		},
+		{
+			includeRampSymbols: false,
+			fullSymbolRamp: false,
+		},
+	);
+}
+
+export function generateFT4Waveform(
+	tones: readonly number[],
+	options: WaveformOptions = {},
+): Float32Array {
+	// Mirrors lib/ft4/gen_ft4wave.f90.
+	return generateGfskWaveform(
+		tones,
+		options,
+		{
+			sampleRate: FT4_DEFAULT_SAMPLE_RATE,
+			samplesPerSymbol: FT4_DEFAULT_SAMPLES_PER_SYMBOL,
+			bt: FT4_DEFAULT_BT,
+		},
+		{
+			includeRampSymbols: true,
+			fullSymbolRamp: true,
+		},
+	);
+}