the ultimate vocal synthesizer - sing, speak, beatbox, and more
Rust
import { deflateSync } from "node:zlib";
import { writeFileSync, mkdirSync } from "node:fs";
import { dirname } from "node:path";
/** Minimal RGB raster with drawing primitives and a 5x7 bitmap font, encodable as PNG. */
export class Image {
readonly w: number;
readonly h: number;
readonly data: Uint8Array;
constructor(w: number, h: number, bg: [number, number, number] = [0, 0, 0]) {
this.w = w;
this.h = h;
this.data = new Uint8Array(w * h * 3);
for (let i = 0; i < w * h; i++) {
this.data[i * 3] = bg[0];
this.data[i * 3 + 1] = bg[1];
this.data[i * 3 + 2] = bg[2];
}
}
set(x: number, y: number, c: [number, number, number], alpha = 1): void {
x = Math.round(x);
y = Math.round(y);
if (x < 0 || y < 0 || x >= this.w || y >= this.h) return;
const i = (y * this.w + x) * 3;
if (alpha >= 1) {
this.data[i] = c[0];
this.data[i + 1] = c[1];
this.data[i + 2] = c[2];
} else {
this.data[i] = Math.round(this.data[i] * (1 - alpha) + c[0] * alpha);
this.data[i + 1] = Math.round(this.data[i + 1] * (1 - alpha) + c[1] * alpha);
this.data[i + 2] = Math.round(this.data[i + 2] * (1 - alpha) + c[2] * alpha);
}
}
rect(x0: number, y0: number, w: number, h: number, c: [number, number, number], alpha = 1): void {
for (let y = Math.round(y0); y < Math.round(y0 + h); y++)
for (let x = Math.round(x0); x < Math.round(x0 + w); x++) this.set(x, y, c, alpha);
}
line(x0: number, y0: number, x1: number, y1: number, c: [number, number, number], alpha = 1): void {
const dx = x1 - x0;
const dy = y1 - y0;
const steps = Math.max(1, Math.ceil(Math.max(Math.abs(dx), Math.abs(dy))));
for (let i = 0; i <= steps; i++) this.set(x0 + (dx * i) / steps, y0 + (dy * i) / steps, c, alpha);
}
text(x: number, y: number, s: string, c: [number, number, number], scale = 1): void {
let cx = x;
for (const ch of s.toUpperCase()) {
const glyph = FONT[ch] ?? FONT["?"];
for (let row = 0; row < 7; row++) {
const bits = glyph[row];
for (let col = 0; col < 5; col++) {
if (bits & (1 << (4 - col))) this.rect(cx + col * scale, y + row * scale, scale, scale, c);
}
}
cx += 6 * scale;
}
}
savePng(path: string): void {
const raw = Buffer.alloc((this.w * 3 + 1) * this.h);
for (let y = 0; y < this.h; y++) {
raw[y * (this.w * 3 + 1)] = 0;
Buffer.from(this.data.buffer, this.data.byteOffset + y * this.w * 3, this.w * 3).copy(raw, y * (this.w * 3 + 1) + 1);
}
const chunks: Buffer[] = [Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])];
const ihdr = Buffer.alloc(13);
ihdr.writeUInt32BE(this.w, 0);
ihdr.writeUInt32BE(this.h, 4);
ihdr[8] = 8; // bit depth
ihdr[9] = 2; // RGB
ihdr[10] = 0;
ihdr[11] = 0;
ihdr[12] = 0;
chunks.push(chunk("IHDR", ihdr));
chunks.push(chunk("IDAT", deflateSync(raw, { level: 6 })));
chunks.push(chunk("IEND", Buffer.alloc(0)));
mkdirSync(dirname(path), { recursive: true });
writeFileSync(path, Buffer.concat(chunks));
}
}
const CRC_TABLE = (() => {
const t = new Uint32Array(256);
for (let n = 0; n < 256; n++) {
let c = n;
for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
t[n] = c >>> 0;
}
return t;
})();
function crc32(buf: Buffer): number {
let c = 0xffffffff;
for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
return (c ^ 0xffffffff) >>> 0;
}
function chunk(type: string, body: Buffer): Buffer {
const len = Buffer.alloc(4);
len.writeUInt32BE(body.length, 0);
const tb = Buffer.from(type, "ascii");
const crc = Buffer.alloc(4);
crc.writeUInt32BE(crc32(Buffer.concat([tb, body])), 0);
return Buffer.concat([len, tb, body, crc]);
}
/** Perceptual-ish colormap (inferno-like) for t in [0,1]. */
export function inferno(t: number): [number, number, number] {
t = Math.max(0, Math.min(1, t));
const stops: [number, number, number, number][] = [
[0.0, 0, 0, 4],
[0.15, 31, 12, 72],
[0.3, 85, 15, 109],
[0.45, 136, 34, 106],
[0.6, 186, 54, 85],
[0.72, 227, 89, 51],
[0.85, 249, 140, 10],
[0.95, 245, 219, 76],
[1.0, 252, 255, 164],
];
for (let i = 1; i < stops.length; i++) {
if (t <= stops[i][0]) {
const a = stops[i - 1];
const b = stops[i];
const u = (t - a[0]) / (b[0] - a[0]);
return [a[1] + (b[1] - a[1]) * u, a[2] + (b[2] - a[2]) * u, a[3] + (b[3] - a[3]) * u].map(Math.round) as [number, number, number];
}
}
return [252, 255, 164];
}
// 5x7 font, rows top->bottom, 5 bits per row (MSB = leftmost column).
const FONT: Record<string, number[]> = {
"0": [0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e],
"1": [0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e],
"2": [0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f],
"3": [0x1f, 0x02, 0x04, 0x02, 0x01, 0x11, 0x0e],
"4": [0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02],
"5": [0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e],
"6": [0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e],
"7": [0x1f, 0x01, 0x02, 0x04, 0x08, 0x08, 0x08],
"8": [0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e],
"9": [0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c],
A: [0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11],
B: [0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e],
C: [0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e],
D: [0x1c, 0x12, 0x11, 0x11, 0x11, 0x12, 0x1c],
E: [0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f],
F: [0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10],
G: [0x0e, 0x11, 0x10, 0x17, 0x11, 0x11, 0x0f],
H: [0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11],
I: [0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e],
J: [0x07, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c],
K: [0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11],
L: [0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f],
M: [0x11, 0x1b, 0x15, 0x15, 0x11, 0x11, 0x11],
N: [0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11],
O: [0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e],
P: [0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10],
Q: [0x0e, 0x11, 0x11, 0x11, 0x15, 0x12, 0x0d],
R: [0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11],
S: [0x0f, 0x10, 0x10, 0x0e, 0x01, 0x01, 0x1e],
T: [0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04],
U: [0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e],
V: [0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04],
W: [0x11, 0x11, 0x11, 0x15, 0x15, 0x15, 0x0a],
X: [0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11],
Y: [0x11, 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04],
Z: [0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f],
" ": [0, 0, 0, 0, 0, 0, 0],
".": [0, 0, 0, 0, 0, 0x0c, 0x0c],
",": [0, 0, 0, 0, 0x0c, 0x04, 0x08],
"-": [0, 0, 0, 0x1f, 0, 0, 0],
"+": [0, 0x04, 0x04, 0x1f, 0x04, 0x04, 0],
":": [0, 0x0c, 0x0c, 0, 0x0c, 0x0c, 0],
"/": [0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x10],
"=": [0, 0, 0x1f, 0, 0x1f, 0, 0],
"(": [0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02],
")": [0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08],
"%": [0x18, 0x19, 0x02, 0x04, 0x08, 0x13, 0x03],
"_": [0, 0, 0, 0, 0, 0, 0x1f],
"?": [0x0e, 0x11, 0x01, 0x02, 0x04, 0, 0x04],
"#": [0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a],
"'": [0x04, 0x04, 0x08, 0, 0, 0, 0],
};