@meebs/meeb 1.0.0

package/gif.js

@@ -0,0 +1,435 @@
+const fs = require('fs')
+const { stripAnsi } = require('./util')
+
+// Parse ANSI art into a grid of {char, fg, bg} cells
+function parseAnsi(art) {
+  const lines = art.split('\n')
+  const grid = []
+  for (const line of lines) {
+    const row = []
+    let fg = [200, 200, 200]
+    let bg = [0, 0, 0]
+    let i = 0
+    while (i < line.length) {
+      if (line[i] === '\x1b' && line[i + 1] === '[') {
+        // parse escape sequence
+        let j = i + 2
+        while (j < line.length && line[j] !== 'm') j++
+        const codes = line.slice(i + 2, j).split(';').map(Number)
+        let k = 0
+        while (k < codes.length) {
+          if (codes[k] === 0) {
+            fg = [200, 200, 200]
+            bg = [0, 0, 0]
+          } else if (codes[k] === 38 && codes[k + 1] === 2) {
+            fg = [codes[k + 2], codes[k + 3], codes[k + 4]]
+            k += 4
+          } else if (codes[k] === 48 && codes[k + 1] === 2) {
+            bg = [codes[k + 2], codes[k + 3], codes[k + 4]]
+            k += 4
+          }
+          k++
+        }
+        i = j + 1
+      } else {
+        row.push({ char: line[i], fg: [...fg], bg: [...bg] })
+        i++
+      }
+    }
+    grid.push(row)
+  }
+  return grid
+}
+
+// Block characters and how they fill a 2x2 sub-pixel cell (top-left, top-right, bottom-left, bottom-right)
+// Each char maps to which sub-pixels are "foreground" vs "background"
+// We render each character cell as cellW x cellH pixels
+const CELL_W = 8
+const CELL_H = 14
+
+function renderCell(char, fg, bg) {
+  // Returns a cellW x cellH pixel grid
+  const pixels = []
+  for (let y = 0; y < CELL_H; y++) pixels.push(new Array(CELL_W))
+
+  const topHalf = y => y < CELL_H / 2
+  const botHalf = y => y >= CELL_H / 2
+  const leftHalf = x => x < CELL_W / 2
+  const rightHalf = x => x >= CELL_W / 2
+
+  for (let y = 0; y < CELL_H; y++) {
+    for (let x = 0; x < CELL_W; x++) {
+      let color = bg
+      switch (char) {
+        case '█': case '▓': color = fg; break
+        case '░': color = (x + y) % 3 === 0 ? fg : bg; break
+        case '▄': color = botHalf(y) ? fg : bg; break
+        case '▀': color = topHalf(y) ? fg : bg; break
+        case '▐': color = rightHalf(x) ? fg : bg; break
+        case '▌': color = leftHalf(x) ? fg : bg; break
+        case '▛': color = (topHalf(y) || leftHalf(x)) ? fg : bg; break
+        case '▜': color = (topHalf(y) || rightHalf(x)) ? fg : bg; break
+        case '▙': color = (botHalf(y) || leftHalf(x)) ? fg : bg; break
+        case '▟': color = (botHalf(y) || rightHalf(x)) ? fg : bg; break
+        case '▗': color = (botHalf(y) && rightHalf(x)) ? fg : bg; break
+        case '▖': color = (botHalf(y) && leftHalf(x)) ? fg : bg; break
+        case '▝': color = (topHalf(y) && rightHalf(x)) ? fg : bg; break
+        case '▘': color = (topHalf(y) && leftHalf(x)) ? fg : bg; break
+        case '●': case '◉': {
+          const cx = CELL_W / 2, cy = CELL_H / 2
+          const dx = x - cx + 0.5, dy = (y - cy + 0.5) * (CELL_W / CELL_H)
+          color = Math.sqrt(dx * dx + dy * dy) < CELL_W / 2.5 ? fg : bg
+          break
+        }
+        case '▼': case '▽': {
+          const progress = y / CELL_H
+          const halfW = (1 - progress) * CELL_W / 2
+          color = (x >= CELL_W / 2 - halfW && x < CELL_W / 2 + halfW) ? fg : bg
+          break
+        }
+        case '✦': case '·': case '★': {
+          const cx = CELL_W / 2, cy = CELL_H / 2
+          const dx = Math.abs(x - cx + 0.5), dy = Math.abs((y - cy + 0.5) * (CELL_W / CELL_H))
+          color = (dx + dy < CELL_W / 2.5) ? fg : bg
+          break
+        }
+        default:
+          // most text chars: just fill with fg if not space
+          if (char !== ' ' && char !== '') color = fg
+          break
+      }
+      pixels[y][x] = color
+    }
+  }
+  return pixels
+}
+
+function artToPixels(art, bgColor = [25, 25, 30]) {
+  const grid = parseAnsi(art)
+  if (grid.length === 0) return { pixels: [], w: 0, h: 0 }
+
+  const maxCols = Math.max(...grid.map(r => r.length))
+  const padding = 2 // cells of padding
+  const totalCols = maxCols + padding * 2
+  const totalRows = grid.length + padding * 2
+
+  const w = totalCols * CELL_W
+  const h = totalRows * CELL_H
+  const pixels = []
+  for (let y = 0; y < h; y++) pixels.push(new Array(w))
+
+  // fill with background
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++)
+      pixels[y][x] = bgColor
+
+  for (let row = 0; row < grid.length; row++) {
+    for (let col = 0; col < grid[row].length; col++) {
+      const cell = grid[row][col]
+      const cellPixels = renderCell(cell.char, cell.fg, cell.bg)
+      const ox = (col + padding) * CELL_W
+      const oy = (row + padding) * CELL_H
+      for (let cy = 0; cy < CELL_H; cy++) {
+        for (let cx = 0; cx < CELL_W; cx++) {
+          pixels[oy + cy][ox + cx] = cellPixels[cy][cx]
+        }
+      }
+    }
+  }
+  return { pixels, w, h }
+}
+
+// --- GIF89a encoder ---
+
+// Build a color table from pixel data (max 256 colors via median cut)
+function buildPalette(pixels, maxColors = 256) {
+  // Collect unique colors (quantized to reduce)
+  const colorCounts = new Map()
+  for (const row of pixels) {
+    for (const [r, g, b] of row) {
+      // quantize to 6-bit per channel for grouping
+      const qr = r >> 2, qg = g >> 2, qb = b >> 2
+      const key = (qr << 12) | (qg << 6) | qb
+      colorCounts.set(key, (colorCounts.get(key) || 0) + 1)
+    }
+  }
+
+  // Get top N colors by frequency
+  const sorted = [...colorCounts.entries()].sort((a, b) => b[1] - a[1])
+  const palette = []
+  for (let i = 0; i < Math.min(maxColors, sorted.length); i++) {
+    const key = sorted[i][0]
+    const r = ((key >> 12) & 0x3f) << 2
+    const g = ((key >> 6) & 0x3f) << 2
+    const b = (key & 0x3f) << 2
+    palette.push([r, g, b])
+  }
+
+  // pad to power of 2
+  while (palette.length < 2) palette.push([0, 0, 0])
+  let bits = 1
+  while ((1 << bits) < palette.length) bits++
+  while (palette.length < (1 << bits)) palette.push([0, 0, 0])
+
+  return { palette, bits }
+}
+
+function findClosest(palette, r, g, b) {
+  let best = 0, bestD = Infinity
+  const qr = r >> 2 << 2, qg = g >> 2 << 2, qb = b >> 2 << 2
+  for (let i = 0; i < palette.length; i++) {
+    const dr = palette[i][0] - qr
+    const dg = palette[i][1] - qg
+    const db = palette[i][2] - qb
+    const d = dr * dr + dg * dg + db * db
+    if (d === 0) return i
+    if (d < bestD) { bestD = d; best = i }
+  }
+  return best
+}
+
+function indexPixels(pixels, palette) {
+  const h = pixels.length, w = pixels[0].length
+  const indices = new Uint8Array(w * h)
+  // build lookup cache
+  const cache = new Map()
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const [r, g, b] = pixels[y][x]
+      const key = (r << 16) | (g << 8) | b
+      if (cache.has(key)) {
+        indices[y * w + x] = cache.get(key)
+      } else {
+        const idx = findClosest(palette, r, g, b)
+        cache.set(key, idx)
+        indices[y * w + x] = idx
+      }
+    }
+  }
+  return indices
+}
+
+// LZW compression for GIF
+function lzwEncode(indices, minCodeSize) {
+  const clearCode = 1 << minCodeSize
+  const eoiCode = clearCode + 1
+
+  const output = []
+  let codeSize = minCodeSize + 1
+  let nextCode = eoiCode + 1
+  const maxTableSize = 4096
+
+  // init table
+  let table = new Map()
+  for (let i = 0; i < clearCode; i++) table.set(String(i), i)
+
+  let buffer = 0
+  let bitsInBuf = 0
+
+  function emit(code) {
+    buffer |= (code << bitsInBuf)
+    bitsInBuf += codeSize
+    while (bitsInBuf >= 8) {
+      output.push(buffer & 0xff)
+      buffer >>= 8
+      bitsInBuf -= 8
+    }
+  }
+
+  emit(clearCode)
+
+  let prev = String(indices[0])
+  for (let i = 1; i < indices.length; i++) {
+    const curr = String(indices[i])
+    const combined = prev + ',' + curr
+    if (table.has(combined)) {
+      prev = combined
+    } else {
+      emit(table.get(prev))
+      if (nextCode < maxTableSize) {
+        table.set(combined, nextCode++)
+        if (nextCode > (1 << codeSize) && codeSize < 12) codeSize++
+      } else {
+        // reset
+        emit(clearCode)
+        table = new Map()
+        for (let j = 0; j < clearCode; j++) table.set(String(j), j)
+        nextCode = eoiCode + 1
+        codeSize = minCodeSize + 1
+      }
+      prev = curr
+    }
+  }
+  emit(table.get(prev))
+  emit(eoiCode)
+
+  // flush remaining bits
+  if (bitsInBuf > 0) output.push(buffer & 0xff)
+
+  return Buffer.from(output)
+}
+
+function subBlock(data) {
+  // split into 255-byte sub-blocks
+  const chunks = []
+  let i = 0
+  while (i < data.length) {
+    const size = Math.min(255, data.length - i)
+    chunks.push(size)
+    for (let j = 0; j < size; j++) chunks.push(data[i + j])
+    i += size
+  }
+  chunks.push(0) // block terminator
+  return Buffer.from(chunks)
+}
+
+function encodeGif(frames, delays, w, h) {
+  const bufs = []
+
+  // use first frame for palette
+  const { palette, bits } = buildPalette(frames[0])
+
+  // Header
+  bufs.push(Buffer.from('GIF89a'))
+
+  // Logical Screen Descriptor
+  const lsd = Buffer.alloc(7)
+  lsd.writeUInt16LE(w, 0)
+  lsd.writeUInt16LE(h, 2)
+  lsd.writeUInt8(0x80 | ((bits - 1) << 4) | (bits - 1), 4) // GCT flag + color resolution + GCT size
+  lsd.writeUInt8(0, 5) // bg color index
+  lsd.writeUInt8(0, 6) // pixel aspect ratio
+  bufs.push(lsd)
+
+  // Global Color Table
+  const gct = Buffer.alloc(3 * (1 << bits))
+  for (let i = 0; i < palette.length; i++) {
+    gct[i * 3] = palette[i][0]
+    gct[i * 3 + 1] = palette[i][1]
+    gct[i * 3 + 2] = palette[i][2]
+  }
+  bufs.push(gct)
+
+  // Netscape loop extension
+  bufs.push(Buffer.from([
+    0x21, 0xff, 0x0b,
+    ...Buffer.from('NETSCAPE2.0'),
+    0x03, 0x01, 0x00, 0x00, // loop forever
+    0x00
+  ]))
+
+  for (let f = 0; f < frames.length; f++) {
+    // Graphic Control Extension
+    const gce = Buffer.alloc(8)
+    gce[0] = 0x21 // extension
+    gce[1] = 0xf9 // graphic control
+    gce[2] = 0x04 // block size
+    gce[3] = 0x00 // no transparency, no disposal
+    gce.writeUInt16LE(delays[f], 4) // delay in 1/100s
+    gce[6] = 0x00 // transparent color index
+    gce[7] = 0x00 // block terminator
+    bufs.push(gce)
+
+    // Image Descriptor
+    const imgDesc = Buffer.alloc(10)
+    imgDesc[0] = 0x2c // image separator
+    imgDesc.writeUInt16LE(0, 1) // left
+    imgDesc.writeUInt16LE(0, 3) // top
+    imgDesc.writeUInt16LE(w, 5) // width
+    imgDesc.writeUInt16LE(h, 7) // height
+    imgDesc[9] = 0x00 // no local color table
+    bufs.push(imgDesc)
+
+    // Image Data
+    const indices = indexPixels(frames[f], palette)
+    const minCodeSize = Math.max(2, bits)
+    bufs.push(Buffer.from([minCodeSize]))
+    const compressed = lzwEncode(indices, minCodeSize)
+    bufs.push(subBlock(compressed))
+  }
+
+  // Trailer
+  bufs.push(Buffer.from([0x3b]))
+
+  return Buffer.concat(bufs)
+}
+
+function scalePixels(pixels, w, h, scaleX, scaleY) {
+  if (scaleY === undefined) scaleY = scaleX
+  const nw = Math.round(w * scaleX), nh = Math.round(h * scaleY)
+  const out = []
+  for (let y = 0; y < nh; y++) {
+    const row = new Array(nw)
+    const sy = Math.min(Math.floor(y / scaleY), h - 1)
+    for (let x = 0; x < nw; x++) {
+      row[x] = pixels[sy][Math.min(Math.floor(x / scaleX), w - 1)]
+    }
+    out.push(row)
+  }
+  return { pixels: out, w: nw, h: nh }
+}
+
+function applyWhiteBg(pixels, w, h, bgColor) {
+  if (bgColor[0] !== 255 || bgColor[1] !== 255 || bgColor[2] !== 255) return
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++) {
+      const [r, g, b] = pixels[y][x]
+      if (r === 0 && g === 0 && b === 0) pixels[y][x] = bgColor
+    }
+}
+
+function correctAspect(pixels, w, h) {
+  return scalePixels(pixels, w, h, 1, CELL_W / CELL_H)
+}
+
+function generateGif(art, outPath, bgColor) {
+  const bg = bgColor || [25, 25, 30]
+  let { pixels, w, h } = artToPixels(art, bg)
+  applyWhiteBg(pixels, w, h, bg)
+  const corrected = correctAspect(pixels, w, h)
+  if (corrected.w === 0 || corrected.h === 0) {
+    console.error('  empty art, cannot generate gif')
+    process.exit(1)
+  }
+
+  const gif = encodeGif([corrected.pixels], [100], corrected.w, corrected.h)
+  fs.writeFileSync(outPath, gif)
+  return outPath
+}
+
+function generateAnimatedGif(arts, outPath, delay = 80, bgColor) {
+  const bg = bgColor || [25, 25, 30]
+  const frames = []
+  let maxW = 0, maxH = 0
+
+  const parsed = arts.map(art => {
+    let { pixels, w, h } = artToPixels(art, bg)
+    applyWhiteBg(pixels, w, h, bg)
+    const corrected = correctAspect(pixels, w, h)
+    return corrected
+  })
+  for (const { w, h } of parsed) {
+    maxW = Math.max(maxW, w)
+    maxH = Math.max(maxH, h)
+  }
+
+  for (const { pixels, w, h } of parsed) {
+    const frame = []
+    for (let y = 0; y < maxH; y++) {
+      const row = []
+      for (let x = 0; x < maxW; x++) {
+        if (y < h && x < w) row.push(pixels[y][x])
+        else row.push(bg)
+      }
+      frame.push(row)
+    }
+    frames.push(frame)
+  }
+
+  const delays = frames.map(() => delay)
+  const gif = encodeGif(frames, delays, maxW, maxH)
+  fs.writeFileSync(outPath, gif)
+  return outPath
+}
+
+module.exports = { generateGif, generateAnimatedGif, artToPixels, parseAnsi, renderCell, scalePixels, applyWhiteBg, correctAspect, CELL_W, CELL_H }