gputex 0.1.2 → 0.3.0

package/dist/testing.js

@@ -0,0 +1,945 @@
+// src/bc1_ref.ts
+var WA = [1, 0, 2 / 3, 1 / 3];
+var WB = [0, 1, 1 / 3, 2 / 3];
+function clamp01(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function to565(r, g, b) {
+  const ri = Math.max(0, Math.min(31, Math.floor(r * 31 + 0.5)));
+  const gi = Math.max(0, Math.min(63, Math.floor(g * 63 + 0.5)));
+  const bi = Math.max(0, Math.min(31, Math.floor(b * 31 + 0.5)));
+  return ri << 11 | gi << 5 | bi;
+}
+function from565(c) {
+  const r = c >> 11 & 31;
+  const g = c >> 5 & 63;
+  const b = c & 31;
+  const r8 = Math.floor((r * 527 + 23) / 64);
+  const g8 = Math.floor((g * 259 + 33) / 64);
+  const b8 = Math.floor((b * 527 + 23) / 64);
+  return [r8 / 255, g8 / 255, b8 / 255];
+}
+function buildPalette4(c0, c1) {
+  const p0 = from565(c0);
+  const p1 = from565(c1);
+  const pal = new Float32Array(12);
+  for (let j = 0; j < 4; j++) {
+    pal[j * 3] = WA[j] * p0[0] + WB[j] * p1[0];
+    pal[j * 3 + 1] = WA[j] * p0[1] + WB[j] * p1[1];
+    pal[j * 3 + 2] = WA[j] * p0[2] + WB[j] * p1[2];
+  }
+  return pal;
+}
+function assignIndices(pixels, pal, outIdx) {
+  let err = 0;
+  for (let k = 0; k < 16; k++) {
+    const r = pixels[k * 3];
+    const g = pixels[k * 3 + 1];
+    const b = pixels[k * 3 + 2];
+    let bestJ = 0;
+    let bestD = Infinity;
+    for (let j = 0; j < 4; j++) {
+      const dr = pal[j * 3] - r;
+      const dg = pal[j * 3 + 1] - g;
+      const db = pal[j * 3 + 2] - b;
+      const d = dr * dr + dg * dg + db * db;
+      if (d < bestD) {
+        bestD = d;
+        bestJ = j;
+      }
+    }
+    outIdx[k] = bestJ;
+    err += bestD;
+  }
+  return err;
+}
+function refitEndpoints(pixels, indices) {
+  let sAA = 0, sBB = 0, sAB = 0;
+  const sAV = [0, 0, 0];
+  const sBV = [0, 0, 0];
+  for (let k = 0; k < 16; k++) {
+    const a = WA[indices[k]];
+    const b = WB[indices[k]];
+    sAA += a * a;
+    sBB += b * b;
+    sAB += a * b;
+    for (let c = 0; c < 3; c++) {
+      const v = pixels[k * 3 + c];
+      sAV[c] += a * v;
+      sBV[c] += b * v;
+    }
+  }
+  const det = sAA * sBB - sAB * sAB;
+  if (Math.abs(det) < 1e-9) return null;
+  const e0 = [0, 0, 0];
+  const e1 = [0, 0, 0];
+  for (let c = 0; c < 3; c++) {
+    e0[c] = clamp01((sBB * sAV[c] - sAB * sBV[c]) / det);
+    e1[c] = clamp01((sAA * sBV[c] - sAB * sAV[c]) / det);
+  }
+  return { e0, e1 };
+}
+function principalAxis(pixels, mean, seed) {
+  let rr = 0, rg = 0, rb = 0, gg = 0, gb = 0, bb = 0;
+  for (let k = 0; k < 16; k++) {
+    const dr = pixels[k * 3] - mean[0];
+    const dg = pixels[k * 3 + 1] - mean[1];
+    const db = pixels[k * 3 + 2] - mean[2];
+    rr += dr * dr;
+    rg += dr * dg;
+    rb += dr * db;
+    gg += dg * dg;
+    gb += dg * db;
+    bb += db * db;
+  }
+  let vx = seed[0], vy = seed[1], vz = seed[2];
+  let len = Math.sqrt(vx * vx + vy * vy + vz * vz);
+  if (len < 1e-9) return null;
+  vx /= len;
+  vy /= len;
+  vz /= len;
+  for (let iter = 0; iter < 8; iter++) {
+    const nx = rr * vx + rg * vy + rb * vz;
+    const ny = rg * vx + gg * vy + gb * vz;
+    const nz = rb * vx + gb * vy + bb * vz;
+    len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (len < 1e-12) return null;
+    vx = nx / len;
+    vy = ny / len;
+    vz = nz / len;
+  }
+  return [vx, vy, vz];
+}
+function packBlock(c0, c1, indices) {
+  const out = new Uint8Array(8);
+  out[0] = c0 & 255;
+  out[1] = c0 >> 8 & 255;
+  out[2] = c1 & 255;
+  out[3] = c1 >> 8 & 255;
+  let bits = 0;
+  for (let k = 0; k < 16; k++) bits |= (indices[k] & 3) << k * 2;
+  out[4] = bits & 255;
+  out[5] = bits >>> 8 & 255;
+  out[6] = bits >>> 16 & 255;
+  out[7] = bits >>> 24 & 255;
+  return out;
+}
+function fitFromEndpoints(pixels, hi, lo, maxRefits, best) {
+  let c0 = to565(hi[0], hi[1], hi[2]);
+  let c1 = to565(lo[0], lo[1], lo[2]);
+  if (c0 === c1) {
+    if (c1 > 0) c1 -= 1;
+    else c0 += 1;
+  } else if (c0 < c1) {
+    const t = c0;
+    c0 = c1;
+    c1 = t;
+  }
+  const idx = new Uint8Array(16);
+  let pal = buildPalette4(c0, c1);
+  let err = assignIndices(pixels, pal, idx);
+  if (err < best.err) {
+    best.c0 = c0;
+    best.c1 = c1;
+    best.indices.set(idx);
+    best.err = err;
+  }
+  for (let pass = 0; pass < maxRefits; pass++) {
+    const refit = refitEndpoints(pixels, idx);
+    if (!refit) break;
+    let nc0 = to565(refit.e0[0], refit.e0[1], refit.e0[2]);
+    let nc1 = to565(refit.e1[0], refit.e1[1], refit.e1[2]);
+    if (nc0 < nc1) {
+      const t = nc0;
+      nc0 = nc1;
+      nc1 = t;
+    }
+    if (nc0 === nc1) break;
+    if (nc0 === c0 && nc1 === c1) break;
+    pal = buildPalette4(nc0, nc1);
+    const nerr = assignIndices(pixels, pal, idx);
+    c0 = nc0;
+    c1 = nc1;
+    err = nerr;
+    if (nerr < best.err) {
+      best.c0 = nc0;
+      best.c1 = nc1;
+      best.indices.set(idx);
+      best.err = nerr;
+    }
+  }
+}
+function encodeBC1Block(pixels, { quality = "fast" } = {}) {
+  if (pixels.length !== 48) {
+    throw new Error(`encodeBC1Block: expected 48 values (16 RGB), got ${pixels.length}`);
+  }
+  const bbMin = [1, 1, 1];
+  const bbMax = [0, 0, 0];
+  const mean = [0, 0, 0];
+  for (let k = 0; k < 16; k++) {
+    for (let c = 0; c < 3; c++) {
+      const v = pixels[k * 3 + c];
+      if (v < bbMin[c]) bbMin[c] = v;
+      if (v > bbMax[c]) bbMax[c] = v;
+      mean[c] += v;
+    }
+  }
+  for (let c = 0; c < 3; c++) mean[c] /= 16;
+  const best = { c0: 0, c1: 0, indices: new Uint8Array(16), err: Infinity };
+  const inset = [(bbMax[0] - bbMin[0]) / 16, (bbMax[1] - bbMin[1]) / 16, (bbMax[2] - bbMin[2]) / 16];
+  const bboxHi = [clamp01(bbMax[0] - inset[0]), clamp01(bbMax[1] - inset[1]), clamp01(bbMax[2] - inset[2])];
+  const bboxLo = [clamp01(bbMin[0] + inset[0]), clamp01(bbMin[1] + inset[1]), clamp01(bbMin[2] + inset[2])];
+  if (quality === "high") {
+    const diag = [bbMax[0] - bbMin[0], bbMax[1] - bbMin[1], bbMax[2] - bbMin[2]];
+    const axis = principalAxis(pixels, mean, diag);
+    if (axis) {
+      let tMin = Infinity;
+      let tMax = -Infinity;
+      for (let k = 0; k < 16; k++) {
+        const t = (pixels[k * 3] - mean[0]) * axis[0] + (pixels[k * 3 + 1] - mean[1]) * axis[1] + (pixels[k * 3 + 2] - mean[2]) * axis[2];
+        if (t < tMin) tMin = t;
+        if (t > tMax) tMax = t;
+      }
+      const pad = (tMax - tMin) / 16;
+      const tHi = tMax - pad;
+      const tLo = tMin + pad;
+      const pcaHi = [
+        clamp01(mean[0] + tHi * axis[0]),
+        clamp01(mean[1] + tHi * axis[1]),
+        clamp01(mean[2] + tHi * axis[2])
+      ];
+      const pcaLo = [
+        clamp01(mean[0] + tLo * axis[0]),
+        clamp01(mean[1] + tLo * axis[1]),
+        clamp01(mean[2] + tLo * axis[2])
+      ];
+      fitFromEndpoints(pixels, pcaHi, pcaLo, 3, best);
+    }
+    fitFromEndpoints(pixels, bboxHi, bboxLo, 3, best);
+  } else {
+    fitFromEndpoints(pixels, bboxHi, bboxLo, 1, best);
+  }
+  return packBlock(best.c0, best.c1, best.indices);
+}
+function decodeBC1Block(block) {
+  if (block.length !== 8) {
+    throw new Error(`decodeBC1Block: expected 8 bytes, got ${block.length}`);
+  }
+  const c0 = block[0] | block[1] << 8;
+  const c1 = block[2] | block[3] << 8;
+  const p0 = from565(c0);
+  const p1 = from565(c1);
+  const pal = [p0, p1, [0, 0, 0], [0, 0, 0]];
+  if (c0 > c1) {
+    for (let c = 0; c < 3; c++) {
+      pal[2][c] = (2 * p0[c] + p1[c]) / 3;
+      pal[3][c] = (p0[c] + 2 * p1[c]) / 3;
+    }
+  } else {
+    for (let c = 0; c < 3; c++) {
+      pal[2][c] = (p0[c] + p1[c]) / 2;
+      pal[3][c] = 0;
+    }
+  }
+  const bits = (block[4] | block[5] << 8 | block[6] << 16 | block[7] << 24) >>> 0;
+  const out = new Float32Array(48);
+  for (let k = 0; k < 16; k++) {
+    const idx = bits >>> k * 2 & 3;
+    out[k * 3] = pal[idx][0];
+    out[k * 3 + 1] = pal[idx][1];
+    out[k * 3 + 2] = pal[idx][2];
+  }
+  return out;
+}
+
+// src/bc4_ref.ts
+var PALETTE_SIZE = 8;
+var W0_6 = [1, 0, 6 / 7, 5 / 7, 4 / 7, 3 / 7, 2 / 7, 1 / 7];
+var W1_6 = [0, 1, 1 / 7, 2 / 7, 3 / 7, 4 / 7, 5 / 7, 6 / 7];
+var W0_4 = [1, 0, 4 / 5, 3 / 5, 2 / 5, 1 / 5, 0, 0];
+var W1_4 = [0, 1, 1 / 5, 2 / 5, 3 / 5, 4 / 5, 0, 0];
+var PAL4_CONST = [0, 0, 0, 0, 0, 0, 0, 1];
+function clamp012(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function quantize8(v) {
+  return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+function buildPalette6(r0, r1) {
+  const p = new Float32Array(PALETTE_SIZE);
+  for (let j = 0; j < PALETTE_SIZE; j++) p[j] = W0_6[j] * r0 + W1_6[j] * r1;
+  return p;
+}
+function buildPalette42(r0, r1) {
+  const p = new Float32Array(PALETTE_SIZE);
+  for (let j = 0; j < PALETTE_SIZE; j++) {
+    p[j] = W0_4[j] * r0 + W1_4[j] * r1 + PAL4_CONST[j];
+  }
+  return p;
+}
+function assignIndex(value, palette) {
+  let bestIdx = 0;
+  let bestD = Infinity;
+  for (let j = 0; j < PALETTE_SIZE; j++) {
+    const d = palette[j] - value;
+    const d2 = d * d;
+    if (d2 < bestD) {
+      bestD = d2;
+      bestIdx = j;
+    }
+  }
+  return { idx: bestIdx, err: bestD };
+}
+function sumSquaredError(values, palette, indices) {
+  let e = 0;
+  for (let k = 0; k < 16; k++) {
+    const d = palette[indices[k]] - values[k];
+    e += d * d;
+  }
+  return e;
+}
+function refitEndpoints6Interp(values, indices) {
+  let sumAA = 0, sumBB = 0, sumAB = 0, sumAV = 0, sumBV = 0;
+  for (let k = 0; k < 16; k++) {
+    const a = W0_6[indices[k]];
+    const b = W1_6[indices[k]];
+    const v = values[k];
+    sumAA += a * a;
+    sumBB += b * b;
+    sumAB += a * b;
+    sumAV += a * v;
+    sumBV += b * v;
+  }
+  const det = sumAA * sumBB - sumAB * sumAB;
+  if (Math.abs(det) < 1e-9) return null;
+  const r0 = (sumBB * sumAV - sumAB * sumBV) / det;
+  const r1 = (sumAA * sumBV - sumAB * sumAV) / det;
+  return { r0: clamp012(r0), r1: clamp012(r1) };
+}
+function packBlock2(red0, red1, indices) {
+  const out = new Uint8Array(8);
+  out[0] = red0;
+  out[1] = red1;
+  let bits = 0n;
+  for (let k = 0; k < 16; k++) {
+    bits |= BigInt(indices[k] & 7) << BigInt(3 * k);
+  }
+  for (let i = 0; i < 6; i++) {
+    out[2 + i] = Number(bits >> BigInt(i * 8) & 0xffn);
+  }
+  return out;
+}
+function encodeBC4Block(values) {
+  if (values.length !== 16) {
+    throw new Error(`encodeBC4Block: expected 16 values, got ${values.length}`);
+  }
+  let vmin = Infinity, vmax = -Infinity;
+  for (let k = 0; k < 16; k++) {
+    const v = values[k];
+    if (v < vmin) vmin = v;
+    if (v > vmax) vmax = v;
+  }
+  vmin = clamp012(vmin);
+  vmax = clamp012(vmax);
+  let r0b = quantize8(vmax);
+  let r1b = quantize8(vmin);
+  if (r0b === r1b) {
+    if (r1b > 0) r1b -= 1;
+    else r0b += 1;
+  }
+  const pal = buildPalette6(r0b / 255, r1b / 255);
+  const indices = new Uint8Array(16);
+  for (let k = 0; k < 16; k++) {
+    indices[k] = assignIndex(values[k], pal).idx;
+  }
+  let bestErr = sumSquaredError(values, pal, indices);
+  let bestR0 = r0b, bestR1 = r1b;
+  let bestIndices = indices.slice();
+  const refit = refitEndpoints6Interp(values, indices);
+  if (refit) {
+    const qR0 = quantize8(refit.r0);
+    const qR1 = quantize8(refit.r1);
+    if (qR0 > qR1) {
+      const pal2 = buildPalette6(qR0 / 255, qR1 / 255);
+      const idx2 = new Uint8Array(16);
+      for (let k = 0; k < 16; k++) idx2[k] = assignIndex(values[k], pal2).idx;
+      const err2 = sumSquaredError(values, pal2, idx2);
+      if (err2 < bestErr) {
+        bestErr = err2;
+        bestR0 = qR0;
+        bestR1 = qR1;
+        bestIndices = idx2;
+      }
+    }
+  }
+  return packBlock2(bestR0, bestR1, bestIndices);
+}
+function decodeBC4Block(block) {
+  if (block.length !== 8) {
+    throw new Error(`decodeBC4Block: expected 8 bytes, got ${block.length}`);
+  }
+  const r0b = block[0];
+  const r1b = block[1];
+  const palette = r0b > r1b ? buildPalette6(r0b / 255, r1b / 255) : buildPalette42(r0b / 255, r1b / 255);
+  let bits = 0n;
+  for (let i = 0; i < 6; i++) bits |= BigInt(block[2 + i]) << BigInt(i * 8);
+  const out = new Float32Array(16);
+  for (let k = 0; k < 16; k++) {
+    const idx = Number(bits >> BigInt(3 * k) & 7n);
+    out[k] = palette[idx];
+  }
+  return out;
+}
+
+// src/bc5_ref.ts
+function encodeBC5Block(r, g) {
+  if (r.length !== 16 || g.length !== 16) {
+    throw new Error(`encodeBC5Block: expected two arrays of 16, got ${r.length} / ${g.length}`);
+  }
+  const out = new Uint8Array(16);
+  out.set(encodeBC4Block(r), 0);
+  out.set(encodeBC4Block(g), 8);
+  return out;
+}
+function decodeBC5Block(block) {
+  if (block.length !== 16) {
+    throw new Error(`decodeBC5Block: expected 16 bytes, got ${block.length}`);
+  }
+  return {
+    r: decodeBC4Block(block.subarray(0, 8)),
+    g: decodeBC4Block(block.subarray(8, 16))
+  };
+}
+
+// src/bc7_ref.ts
+var W4 = [0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64];
+function clamp(v, lo, hi) {
+  return v < lo ? lo : v > hi ? hi : v;
+}
+function to8(v) {
+  return clamp(Math.round(v * 255), 0, 255);
+}
+function interp8(e0, e1, w) {
+  return (64 - w) * e0 + w * e1 + 32 >> 6;
+}
+var BitWriter128 = class {
+  bits = 0n;
+  pos = 0;
+  write(value, nBits) {
+    if (this.pos + nBits > 128) throw new Error("BitWriter128 overflow");
+    const v = BigInt(value) & (1n << BigInt(nBits)) - 1n;
+    this.bits |= v << BigInt(this.pos);
+    this.pos += nBits;
+  }
+  toBytes() {
+    const out = new Uint8Array(16);
+    for (let i = 0; i < 16; i++) {
+      out[i] = Number(this.bits >> BigInt(i * 8) & 0xffn);
+    }
+    return out;
+  }
+};
+var BitReader128 = class {
+  bits;
+  pos = 0;
+  constructor(block) {
+    let b = 0n;
+    for (let i = 0; i < 16; i++) b |= BigInt(block[i]) << BigInt(i * 8);
+    this.bits = b;
+  }
+  read(nBits) {
+    const v = Number(this.bits >> BigInt(this.pos) & (1n << BigInt(nBits)) - 1n);
+    this.pos += nBits;
+    return v;
+  }
+};
+function readBC7Mode(block) {
+  const br = new BitReader128(block);
+  for (let m = 0; m < 8; m++) {
+    if (br.read(1) === 1) return m;
+  }
+  throw new Error("BC7: no mode bit found in first 8 bits");
+}
+function quantizeChannelWithPbit(ideal8, p) {
+  const q = clamp(Math.round((ideal8 - p) / 2), 0, 127);
+  const effective = q << 1 | p;
+  const d = effective - ideal8;
+  return { q, err: d * d };
+}
+function quantizeEndpoint(ideal8, p) {
+  const out = [0, 0, 0, 0];
+  let err = 0;
+  for (let c = 0; c < 4; c++) {
+    const r = quantizeChannelWithPbit(ideal8[c], p);
+    out[c] = r.q;
+    err += r.err;
+  }
+  return { rgba: out, err };
+}
+function buildPalette62(e0, e1) {
+  const pal = new Uint8Array(16 * 4);
+  for (let i = 0; i < 16; i++) {
+    const w = W4[i];
+    const base = i * 4;
+    for (let c = 0; c < 4; c++) {
+      pal[base + c] = interp8(e0[c], e1[c], w);
+    }
+  }
+  return pal;
+}
+function assignIndex6(pixel, palette) {
+  let bestIdx = 0;
+  let bestD = Infinity;
+  for (let i = 0; i < 16; i++) {
+    const base = i * 4;
+    const dr = palette[base] - pixel[0];
+    const dg = palette[base + 1] - pixel[1];
+    const db = palette[base + 2] - pixel[2];
+    const da = palette[base + 3] - pixel[3];
+    const d = dr * dr + dg * dg + db * db + da * da;
+    if (d < bestD) {
+      bestD = d;
+      bestIdx = i;
+    }
+  }
+  return { idx: bestIdx, err: bestD };
+}
+function refitEndpointsMode6(pixels8, indices) {
+  let sAA = 0, sBB = 0, sAB = 0;
+  const sAV = [0, 0, 0, 0];
+  const sBV = [0, 0, 0, 0];
+  for (let k = 0; k < 16; k++) {
+    const i = indices[k];
+    const a = (64 - W4[i]) / 64;
+    const b = W4[i] / 64;
+    sAA += a * a;
+    sBB += b * b;
+    sAB += a * b;
+    const base = k * 4;
+    for (let c = 0; c < 4; c++) {
+      sAV[c] += a * pixels8[base + c];
+      sBV[c] += b * pixels8[base + c];
+    }
+  }
+  const det = sAA * sBB - sAB * sAB;
+  if (Math.abs(det) < 1e-9) return null;
+  const e0 = [0, 0, 0, 0];
+  const e1 = [0, 0, 0, 0];
+  for (let c = 0; c < 4; c++) {
+    const r0 = (sBB * sAV[c] - sAB * sBV[c]) / det;
+    const r1 = (sAA * sBV[c] - sAB * sAV[c]) / det;
+    e0[c] = clamp(Math.round(r0), 0, 255);
+    e1[c] = clamp(Math.round(r1), 0, 255);
+  }
+  return { e0, e1 };
+}
+function totalSqErrorForEndpoints(pixels8, e0_8, e1_8) {
+  const pal = buildPalette62(e0_8, e1_8);
+  const indices = new Uint8Array(16);
+  let err = 0;
+  for (let k = 0; k < 16; k++) {
+    const base = k * 4;
+    const sel = assignIndex6([pixels8[base], pixels8[base + 1], pixels8[base + 2], pixels8[base + 3]], pal);
+    indices[k] = sel.idx;
+    err += sel.err;
+  }
+  return { indices, err };
+}
+function packMode6Block(e0_7, e1_7, p0, p1, indices) {
+  if ((indices[0] & 8) !== 0) {
+    throw new Error("packMode6Block: pixel 0 index MSB must be 0 (anchor rule)");
+  }
+  const bw = new BitWriter128();
+  bw.write(0, 6);
+  bw.write(1, 1);
+  for (let c = 0; c < 4; c++) {
+    bw.write(e0_7[c], 7);
+    bw.write(e1_7[c], 7);
+  }
+  bw.write(p0, 1);
+  bw.write(p1, 1);
+  bw.write(indices[0] & 7, 3);
+  for (let k = 1; k < 16; k++) bw.write(indices[k] & 15, 4);
+  return bw.toBytes();
+}
+function farthestPair(pixels8) {
+  let best = -1;
+  let bi0 = 0, bi1 = 1;
+  for (let i = 0; i < 16; i++) {
+    const bi = i * 4;
+    for (let j = i + 1; j < 16; j++) {
+      const bj = j * 4;
+      const dr = pixels8[bi] - pixels8[bj];
+      const dg = pixels8[bi + 1] - pixels8[bj + 1];
+      const db = pixels8[bi + 2] - pixels8[bj + 2];
+      const da = pixels8[bi + 3] - pixels8[bj + 3];
+      const d = dr * dr + dg * dg + db * db + da * da;
+      if (d > best) {
+        best = d;
+        bi0 = i;
+        bi1 = j;
+      }
+    }
+  }
+  return { i0: bi0, i1: bi1 };
+}
+function encodeBC7Mode6Block(pixels) {
+  if (pixels.length !== 64) {
+    throw new Error(`encodeBC7Mode6Block: expected 64 values (16 RGBA), got ${pixels.length}`);
+  }
+  const pixels8 = new Uint8Array(64);
+  for (let k = 0; k < 64; k++) pixels8[k] = to8(pixels[k]);
+  const farthest = farthestPair(pixels8);
+  const ideal0 = [
+    pixels8[farthest.i0 * 4],
+    pixels8[farthest.i0 * 4 + 1],
+    pixels8[farthest.i0 * 4 + 2],
+    pixels8[farthest.i0 * 4 + 3]
+  ];
+  const ideal1 = [
+    pixels8[farthest.i1 * 4],
+    pixels8[farthest.i1 * 4 + 1],
+    pixels8[farthest.i1 * 4 + 2],
+    pixels8[farthest.i1 * 4 + 3]
+  ];
+  function quantPair(ideal, p) {
+    const r = quantizeEndpoint(ideal, p);
+    const eight = [
+      r.rgba[0] << 1 | p,
+      r.rgba[1] << 1 | p,
+      r.rgba[2] << 1 | p,
+      r.rgba[3] << 1 | p
+    ];
+    return { seven: r.rgba, eight, err: r.err };
+  }
+  let best = tryPbitCombos(pixels8, ideal0, ideal1, quantPair);
+  const refit = refitEndpointsMode6(pixels8, best.indices);
+  if (refit) {
+    const candidate = tryPbitCombos(pixels8, refit.e0, refit.e1, quantPair);
+    if (candidate.err < best.err) best = candidate;
+  }
+  let e0_7 = best.e0_7;
+  let e1_7 = best.e1_7;
+  let p0 = best.p0;
+  let p1 = best.p1;
+  let indices = best.indices;
+  if ((indices[0] & 8) !== 0) {
+    const tmp7 = e0_7;
+    e0_7 = e1_7;
+    e1_7 = tmp7;
+    const tmpP = p0;
+    p0 = p1;
+    p1 = tmpP;
+    const inv = new Uint8Array(16);
+    for (let k = 0; k < 16; k++) inv[k] = 15 - indices[k];
+    indices = inv;
+  }
+  return packMode6Block(e0_7, e1_7, p0, p1, indices);
+}
+function tryPbitCombos(pixels8, ideal0, ideal1, quantPair) {
+  let best = null;
+  for (const p0 of [0, 1]) {
+    const q0 = quantPair(ideal0, p0);
+    for (const p1 of [0, 1]) {
+      const q1 = quantPair(ideal1, p1);
+      const { indices, err } = totalSqErrorForEndpoints(pixels8, q0.eight, q1.eight);
+      if (best == null || err < best.err) {
+        best = { e0_7: q0.seven, e1_7: q1.seven, p0, p1, indices, err };
+      }
+    }
+  }
+  if (best == null) throw new Error("unreachable: tryPbitCombos no-op");
+  return best;
+}
+function decodeBC7Mode6Block(block) {
+  if (block.length !== 16) {
+    throw new Error(`decodeBC7Mode6Block: expected 16 bytes, got ${block.length}`);
+  }
+  const mode = readBC7Mode(block);
+  if (mode !== 6) {
+    throw new Error(`decodeBC7Mode6Block: expected mode 6, got mode ${mode}`);
+  }
+  const br = new BitReader128(block);
+  br.read(7);
+  const r0 = br.read(7), r1 = br.read(7);
+  const g0 = br.read(7), g1 = br.read(7);
+  const b0 = br.read(7), b1 = br.read(7);
+  const a0 = br.read(7), a1 = br.read(7);
+  const p0 = br.read(1), p1 = br.read(1);
+  const e0 = [r0 << 1 | p0, g0 << 1 | p0, b0 << 1 | p0, a0 << 1 | p0];
+  const e1 = [r1 << 1 | p1, g1 << 1 | p1, b1 << 1 | p1, a1 << 1 | p1];
+  const pal = buildPalette62(e0, e1);
+  const out = new Float32Array(64);
+  const idx0 = br.read(3);
+  for (let c = 0; c < 4; c++) out[c] = pal[idx0 * 4 + c] / 255;
+  for (let k = 1; k < 16; k++) {
+    const idx = br.read(4);
+    const base = k * 4;
+    for (let c = 0; c < 4; c++) out[base + c] = pal[idx * 4 + c] / 255;
+  }
+  return out;
+}
+function encodeBC7Block(pixels) {
+  return encodeBC7Mode6Block(pixels);
+}
+function decodeBC7Block(block) {
+  const mode = readBC7Mode(block);
+  switch (mode) {
+    case 6:
+      return decodeBC7Mode6Block(block);
+    default:
+      throw new Error(`decodeBC7Block: mode ${mode} not supported by this reference decoder`);
+  }
+}
+
+// src/astc4x4_ref.ts
+var BLOCK_MODE_4x4_2BIT = 66;
+var CEM_RGBA_DIRECT = 12;
+var WEIGHT_UNQ_4 = [0, 21, 43, 64];
+function clamp2(v, lo, hi) {
+  return v < lo ? lo : v > hi ? hi : v;
+}
+function to82(v) {
+  return clamp2(Math.round(v * 255), 0, 255);
+}
+function interp82(e0, e1, w) {
+  return (64 - w) * e0 + w * e1 + 32 >> 6;
+}
+var BitWriter1282 = class {
+  bits = 0n;
+  write(pos, nBits, value) {
+    if (pos < 0 || nBits < 0 || pos + nBits > 128) {
+      throw new Error(`BitWriter128: out-of-range write pos=${pos}, n=${nBits}`);
+    }
+    const mask = (1n << BigInt(nBits)) - 1n;
+    this.bits &= ~(mask << BigInt(pos));
+    this.bits |= (BigInt(value) & mask) << BigInt(pos);
+  }
+  toBytes() {
+    const out = new Uint8Array(16);
+    let b = this.bits;
+    for (let i = 0; i < 16; i++) {
+      out[i] = Number(b & 0xffn);
+      b >>= 8n;
+    }
+    return out;
+  }
+};
+var BitReader1282 = class {
+  bits;
+  constructor(block) {
+    let b = 0n;
+    for (let i = 0; i < 16; i++) b |= BigInt(block[i]) << BigInt(i * 8);
+    this.bits = b;
+  }
+  read(pos, nBits) {
+    const mask = (1n << BigInt(nBits)) - 1n;
+    return Number(this.bits >> BigInt(pos) & mask);
+  }
+};
+function farthestPair2(pixels8) {
+  let best = -1;
+  let bi0 = 0, bi1 = 1;
+  for (let i = 0; i < 16; i++) {
+    const bi = i * 4;
+    for (let j = i + 1; j < 16; j++) {
+      const bj = j * 4;
+      const dr = pixels8[bi] - pixels8[bj];
+      const dg = pixels8[bi + 1] - pixels8[bj + 1];
+      const db = pixels8[bi + 2] - pixels8[bj + 2];
+      const da = pixels8[bi + 3] - pixels8[bj + 3];
+      const d = dr * dr + dg * dg + db * db + da * da;
+      if (d > best) {
+        best = d;
+        bi0 = i;
+        bi1 = j;
+      }
+    }
+  }
+  return { i0: bi0, i1: bi1 };
+}
+function buildPalette(e0, e1) {
+  const pal = new Uint8Array(4 * 4);
+  for (let i = 0; i < 4; i++) {
+    const w = WEIGHT_UNQ_4[i];
+    const base = i * 4;
+    for (let c = 0; c < 4; c++) {
+      pal[base + c] = interp82(e0[c], e1[c], w);
+    }
+  }
+  return pal;
+}
+function assignIndex2(pixel, palette) {
+  let bestIdx = 0;
+  let bestD = Infinity;
+  for (let i = 0; i < 4; i++) {
+    const base = i * 4;
+    const dr = palette[base] - pixel[0];
+    const dg = palette[base + 1] - pixel[1];
+    const db = palette[base + 2] - pixel[2];
+    const da = palette[base + 3] - pixel[3];
+    const d = dr * dr + dg * dg + db * db + da * da;
+    if (d < bestD) {
+      bestD = d;
+      bestIdx = i;
+    }
+  }
+  return { idx: bestIdx, err: bestD };
+}
+function totalSqError(pixels8, e0, e1) {
+  const pal = buildPalette(e0, e1);
+  const indices = new Uint8Array(16);
+  let err = 0;
+  for (let k = 0; k < 16; k++) {
+    const base = k * 4;
+    const sel = assignIndex2([pixels8[base], pixels8[base + 1], pixels8[base + 2], pixels8[base + 3]], pal);
+    indices[k] = sel.idx;
+    err += sel.err;
+  }
+  return { indices, err };
+}
+function refitEndpoints2(pixels8, indices) {
+  let sAA = 0, sBB = 0, sAB = 0;
+  const sAV = [0, 0, 0, 0];
+  const sBV = [0, 0, 0, 0];
+  for (let k = 0; k < 16; k++) {
+    const unq = WEIGHT_UNQ_4[indices[k]];
+    const a = (64 - unq) / 64;
+    const b = unq / 64;
+    sAA += a * a;
+    sBB += b * b;
+    sAB += a * b;
+    const base = k * 4;
+    for (let c = 0; c < 4; c++) {
+      sAV[c] += a * pixels8[base + c];
+      sBV[c] += b * pixels8[base + c];
+    }
+  }
+  const det = sAA * sBB - sAB * sAB;
+  if (Math.abs(det) < 1e-9) return null;
+  const e0 = [0, 0, 0, 0];
+  const e1 = [0, 0, 0, 0];
+  for (let c = 0; c < 4; c++) {
+    e0[c] = clamp2(Math.round((sBB * sAV[c] - sAB * sBV[c]) / det), 0, 255);
+    e1[c] = clamp2(Math.round((sAA * sBV[c] - sAB * sAV[c]) / det), 0, 255);
+  }
+  return { e0, e1 };
+}
+function encodeASTC4x4Block(pixels) {
+  if (pixels.length !== 64) {
+    throw new Error(`encodeASTC4x4Block: expected 64 values (16 RGBA), got ${pixels.length}`);
+  }
+  const pixels8 = new Uint8Array(64);
+  for (let k = 0; k < 64; k++) pixels8[k] = to82(pixels[k]);
+  const fp = farthestPair2(pixels8);
+  let e0 = [
+    pixels8[fp.i0 * 4],
+    pixels8[fp.i0 * 4 + 1],
+    pixels8[fp.i0 * 4 + 2],
+    pixels8[fp.i0 * 4 + 3]
+  ];
+  let e1 = [
+    pixels8[fp.i1 * 4],
+    pixels8[fp.i1 * 4 + 1],
+    pixels8[fp.i1 * 4 + 2],
+    pixels8[fp.i1 * 4 + 3]
+  ];
+  let { indices, err } = totalSqError(pixels8, e0, e1);
+  const refit = refitEndpoints2(pixels8, indices);
+  if (refit) {
+    const { indices: idx2, err: err2 } = totalSqError(pixels8, refit.e0, refit.e1);
+    if (err2 < err) {
+      e0 = refit.e0;
+      e1 = refit.e1;
+      indices = idx2;
+      err = err2;
+    }
+  }
+  const s0 = e0[0] + e0[1] + e0[2];
+  const s1 = e1[0] + e1[1] + e1[2];
+  if (s0 > s1) {
+    const tmp = e0;
+    e0 = e1;
+    e1 = tmp;
+    const inv = new Uint8Array(16);
+    for (let k = 0; k < 16; k++) inv[k] = 3 - indices[k];
+    indices = inv;
+  }
+  return packBlock3(e0, e1, indices);
+}
+function packBlock3(e0, e1, indices) {
+  const bw = new BitWriter1282();
+  bw.write(0, 11, BLOCK_MODE_4x4_2BIT);
+  bw.write(11, 2, 0);
+  bw.write(13, 4, CEM_RGBA_DIRECT);
+  const ep = [e0[0], e1[0], e0[1], e1[1], e0[2], e1[2], e0[3], e1[3]];
+  for (let i = 0; i < 8; i++) bw.write(17 + i * 8, 8, ep[i]);
+  for (let k = 0; k < 16; k++) {
+    const w = indices[k] & 3;
+    bw.write(127 - 2 * k, 1, w & 1);
+    bw.write(126 - 2 * k, 1, w >> 1 & 1);
+  }
+  return bw.toBytes();
+}
+function decodeASTC4x4Block(block) {
+  if (block.length !== 16) {
+    throw new Error(`decodeASTC4x4Block: expected 16 bytes, got ${block.length}`);
+  }
+  const br = new BitReader1282(block);
+  const mode = br.read(0, 11);
+  if (mode !== BLOCK_MODE_4x4_2BIT) {
+    throw new Error(
+      `decodeASTC4x4Block: expected block mode 0x${BLOCK_MODE_4x4_2BIT.toString(16)}, got 0x${mode.toString(16)}`
+    );
+  }
+  const partCount = br.read(11, 2);
+  if (partCount !== 0) {
+    throw new Error(`decodeASTC4x4Block: multi-partition blocks not supported (count=${partCount + 1})`);
+  }
+  const cem = br.read(13, 4);
+  if (cem !== CEM_RGBA_DIRECT) {
+    throw new Error(`decodeASTC4x4Block: only CEM 12 supported, got ${cem}`);
+  }
+  const v = [];
+  for (let i = 0; i < 8; i++) v.push(br.read(17 + i * 8, 8));
+  const [v0, v1, v2, v3, v4, v5, v6, v7] = v;
+  let e0;
+  let e1;
+  if (v0 + v2 + v4 <= v1 + v3 + v5) {
+    e0 = [v0, v2, v4, v6];
+    e1 = [v1, v3, v5, v7];
+  } else {
+    e0 = [v1 + v5 >> 1, v3 + v5 >> 1, v5, v7];
+    e1 = [v0 + v4 >> 1, v2 + v4 >> 1, v4, v6];
+  }
+  const weights = new Uint8Array(16);
+  for (let k = 0; k < 16; k++) {
+    const lsb = br.read(127 - 2 * k, 1);
+    const msb = br.read(126 - 2 * k, 1);
+    weights[k] = lsb | msb << 1;
+  }
+  const out = new Float32Array(64);
+  for (let k = 0; k < 16; k++) {
+    const w = WEIGHT_UNQ_4[weights[k]];
+    const base = k * 4;
+    for (let c = 0; c < 4; c++) {
+      out[base + c] = interp82(e0[c], e1[c], w) / 255;
+    }
+  }
+  return out;
+}
+export {
+  decodeASTC4x4Block,
+  decodeBC1Block,
+  decodeBC4Block,
+  decodeBC5Block,
+  decodeBC7Block,
+  decodeBC7Mode6Block,
+  encodeASTC4x4Block,
+  encodeBC1Block,
+  encodeBC4Block,
+  encodeBC5Block,
+  encodeBC7Block,
+  encodeBC7Mode6Block,
+  readBC7Mode
+};