import { writeFileSync } from 'fs'; import Jimp from 'Jimp'; function repeat(val, n) { let arr = []; for (let i = 0; i < n; i++) { arr.push(val); } return arr; } function zeroes(n) { return repeat(0, n); } function toLinear(val) { // use a 2.4 gamma approximation // this is BT.1886 compatible // and simpler than sRGB let unit = val / 255; unit **= 2.4; return unit * 255; } function fromLinear(val) { let unit = val / 255; unit **= (1 / 2.4); return unit * 255; } function fromSRGB(val) { val /= 255; if (val <= 0.04045) { val /= 12.92; } else { val = ((val + 0.055) / 1.055) ** 2.4; } val *= 255; return val; } function toSRGB(val) { val /= 255; if (val <= 0.0031308) { val *= 12.92; } else { val = (val * 1.055) ** (1.0 / 2.4) - 0.055; } val *= 255; return val; } class RGB { constructor(r, g, b) { this.r = r; this.g = g; this.b = b; } clone() { return new RGB(this.r, this.g, this.b); } static fromHex(val) { let r = (val >>> 16) & 0xff; let g = (val >>> 8) & 0xff; let b = val & 0xff; return new RGB(r,g,b); } static fromGTIA(val) { // This seems off from what Atari800 does // https://forums.atariage.com/topic/107853-need-the-256-colors/page/2/#comment-1312467 let cr = (val >> 4) & 15; let lm = val & 15; let crlv = cr ? 50 : 0; /* let phase = ((cr - 1) * 25 - 58) * (2 * Math.PI / 360); let y = 255 * (lm + 1) / 16; let i = crlv * Math.cos(phase); let q = crlv * Math.sin(phase); let r = y + 0.956 * i + 0.621 * q; let g = y - 0.272 * i - 0.647 * q; let b = y - 1.107 * i + 1.704 * q; */ // PAL let phase = ((cr - 1) * 25.7 - 15) * (2 * Math.PI / 360); let y = 255 * (lm + 1) / 16; let i = crlv * Math.cos(phase); let q = crlv * Math.sin(phase); let r = y + 0.956 * i + 0.621 * q; let g = y - 0.272 * i - 0.647 * q; let b = y - 1.107 * i + 1.704 * q; return new RGB(r, g, b).clamp().fromSRGB(); } map(callback) { return new RGB( callback(this.r), callback(this.g), callback(this.b) ); } fromNTSC() { return this.map(toLinear); } toNTSC() { return this.map(fromLinear); } fromSRGB() { return this.map(fromSRGB); } toSRGB() { return this.map(toSRGB); } clamp() { return this.map((val) => { if (val < 0) return 0; if (val > 255) return 255; return val; }); } inc(other) { this.r += other.r; this.g += other.g; this.b += other.b; return this; } add(other) { return new RGB( this.r + other.r, this.g + other.g, this.b + other.b ); } difference(other) { return new RGB( this.r - other.r, this.g - other.g, this.b - other.b ); } multiply(scalar) { return new RGB( this.r * scalar, this.g * scalar, this.b * scalar, ); } divide(scalar) { return new RGB( this.r / scalar, this.g / scalar, this.b / scalar, ); } magnitude() { return Math.sqrt(this.magnitude2()); } magnitude2() { return this.r * this.r + this.g * this.g + this.b * this.b; } sum() { return this.r + this.g + this.b; } lumaScale() { return new RGB( this.r * 0.299, this.g * 0.586, this.b * 0.114 ); } luma() { return this.lumaScale().sum(); } } /* // snarfed from https://lospec.com/palette-list/atari-8-bit-family-gtia // which was calculated with Retrospecs App's Atari 800 emulator let atariRGB = [ 0x000000, 0x111111, 0x222222, 0x333333, 0x444444, 0x555555, 0x666666, 0x777777, 0x888888, 0x999999, 0xaaaaaa, 0xbbbbbb, 0xcccccc, 0xdddddd, 0xeeeeee, 0xffffff, 0x190700, 0x2a1800, 0x3b2900, 0x4c3a00, 0x5d4b00, 0x6e5c00, 0x7f6d00, 0x907e09, 0xa18f1a, 0xb3a02b, 0xc3b13c, 0xd4c24d, 0xe5d35e, 0xf7e46f, 0xfff582, 0xffff96, 0x310000, 0x3f0000, 0x531700, 0x642800, 0x753900, 0x864a00, 0x975b0a, 0xa86c1b, 0xb97d2c, 0xca8e3d, 0xdb9f4e, 0xecb05f, 0xfdc170, 0xffd285, 0xffe39c, 0xfff4b2, 0x420404, 0x4f0000, 0x600800, 0x711900, 0x822a0d, 0x933b1e, 0xa44c2f, 0xb55d40, 0xc66e51, 0xd77f62, 0xe89073, 0xf9a183, 0xffb298, 0xffc3ae, 0xffd4c4, 0xffe5da, 0x410103, 0x50000f, 0x61001b, 0x720f2b, 0x83203c, 0x94314d, 0xa5425e, 0xb6536f, 0xc76480, 0xd87591, 0xe986a2, 0xfa97b3, 0xffa8c8, 0xffb9de, 0xffcaef, 0xfbdcf6, 0x330035, 0x440041, 0x55004c, 0x660c5c, 0x771d6d, 0x882e7e, 0x993f8f, 0xaa50a0, 0xbb61b1, 0xcc72c2, 0xdd83d3, 0xee94e4, 0xffa5e4, 0xffb6e9, 0xffc7ee, 0xffd8f3, 0x1d005c, 0x2e0068, 0x400074, 0x511084, 0x622195, 0x7332a6, 0x8443b7, 0x9554c8, 0xa665d9, 0xb776ea, 0xc887eb, 0xd998eb, 0xe9a9ec, 0xfbbaeb, 0xffcbef, 0xffdff9, 0x020071, 0x13007d, 0x240b8c, 0x351c9d, 0x462dae, 0x573ebf, 0x684fd0, 0x7960e1, 0x8a71f2, 0x9b82f7, 0xac93f7, 0xbda4f7, 0xceb5f7, 0xdfc6f7, 0xf0d7f7, 0xffe8f8, 0x000068, 0x000a7c, 0x081b90, 0x192ca1, 0x2a3db2, 0x3b4ec3, 0x4c5fd4, 0x5d70e5, 0x6e81f6, 0x7f92ff, 0x90a3ff, 0xa1b4ff, 0xb2c5ff, 0xc3d6ff, 0xd4e7ff, 0xe5f8ff, 0x000a4d, 0x001b63, 0x002c79, 0x023d8f, 0x134ea0, 0x245fb1, 0x3570c2, 0x4681d3, 0x5792e4, 0x68a3f5, 0x79b4ff, 0x8ac5ff, 0x9bd6ff, 0xace7ff, 0xbdf8ff, 0xceffff, 0x001a26, 0x002b3c, 0x003c52, 0x004d68, 0x065e7c, 0x176f8d, 0x28809e, 0x3991af, 0x4aa2c0, 0x5bb3d1, 0x6cc4e2, 0x7dd5f3, 0x8ee6ff, 0x9ff7ff, 0xb0ffff, 0xc1ffff, 0x01250a, 0x023610, 0x004622, 0x005738, 0x05684d, 0x16795e, 0x278a6f, 0x389b80, 0x49ac91, 0x5abda2, 0x6bceb3, 0x7cdfc4, 0x8df0d5, 0x9effe5, 0xaffff1, 0xc0fffd, 0x04260d, 0x043811, 0x054713, 0x005a1b, 0x106b1b, 0x217c2c, 0x328d3d, 0x439e4e, 0x54af5f, 0x65c070, 0x76d181, 0x87e292, 0x98f3a3, 0xa9ffb3, 0xbaffbf, 0xcbffcb, 0x00230a, 0x003510, 0x044613, 0x155613, 0x266713, 0x377813, 0x488914, 0x599a25, 0x6aab36, 0x7bbc47, 0x8ccd58, 0x9dde69, 0xaeef7a, 0xbfff8b, 0xd0ff97, 0xe1ffa3, 0x001707, 0x0e2808, 0x1f3908, 0x304a08, 0x415b08, 0x526c08, 0x637d08, 0x748e0d, 0x859f1e, 0x96b02f, 0xa7c140, 0xb8d251, 0xc9e362, 0xdaf473, 0xebff82, 0xfcff8e, 0x1b0701, 0x2c1801, 0x3c2900, 0x4d3b00, 0x5f4c00, 0x705e00, 0x816f00, 0x938009, 0xa4921a, 0xb2a02b, 0xc7b43d, 0xd8c64e, 0xead760, 0xf6e46f, 0xfffa84, 0xffff99, ].map((hex) => RGB.fromHex(hex).fromNTSC()); //].map((hex) => RGB.fromHex(hex)); */ let atariRGB = []; for (let i = 0; i < 256; i++) { atariRGB[i] = RGB.fromGTIA(i); } /** * Dither RGB input data with a target palette size. * If the number of used colors exceeds `n`, the * palette will be reduced until it fits. * @param {RGB[]} input source scanline data, in linear RGB * @param {number[]} palette - current working palette, as Atari 8-bit color values (low nybble luminance, high nybble hue) * @param {number} n - target color count * @param {number} y * @returns {{output: number[], palette: number[], error: RGB[]}} */ function decimate(input, palette, n) { let width = input.length; let inputPixel = (x, error) => { let rgb = input[x].clone(); if (error) { rgb = rgb.add(error.cur[x]); } return rgb.clamp(); }; // Apply dithering with given palette and collect color usage stats let dither = (palette) => { let error = { cur: [], next: [], }; for (let i = 0; i < width; i++) { error.cur[i] = new RGB(0, 0, 0); error.next[i] = new RGB(0, 0, 0); } let output = zeroes(width); let popularity = zeroes(palette.length); let distance2 = 0; let nextError = new RGB(0, 0, 0); // Try dithering with this palette. for (let x = 0; x < width; x++) { let rgb = inputPixel(x, error); // find the closest possible color // @todo consider doing the difference scoring in luminance and hue spaces let shortest = Infinity; let pick = 1; for (let i = 0; i < palette.length; i++) { let diff = rgb.difference(atariRGB[palette[i]]); let dist = diff.magnitude(); if (dist < shortest) { nextError = diff; shortest = dist; pick = i; } } output[x] = pick; popularity[pick]++; let share = (n) => nextError.multiply(n / 16); error.cur[x + 1]?.inc(share(7)); error.next[x - 1]?.inc(share(3)); error.next[x ]?.inc(share(5)); error.next[x + 1]?.inc(share(1)); } return { output, palette, distance2, popularity, error: error.next }; }; let decimated = palette.slice(); // force to grayscale //decimated = [0, 5, 10, 15]; // force to rgb //decimated = [0, 0x36, 0xb6, 0x86]; // force to rWb //decimated = [0, 0x36, 0x0f, 0x86]; let reserved = [0]; // black //reserved = [0, 15]; // black, white //reserved = [0, 5, 10, 15]; // grayscale //reserved = [0, 0x48, 0x78, 15]; // vaporwave //reserved = [0, 0x3c, 0x78, 15]; // red/blue/white /* if (( y & 1 ) === 0) { reserved = [0, 0x3c, 0x1e, 15]; // red/yellow/white } else { reserved = [0, 0x76, 0x9e, 0xb8]; // blue/cyan/green } */ let keepers = zeroes(256); for (let i of reserved) { keepers[i & 0xfe] = 1; // drop that 0 luminance bit! } // Median cut! // https://en.wikipedia.org/wiki/Median_cut //let buckets = [input.slice()]; // preface the reserved bits let buckets = reserved.slice().map((c) => [atariRGB[c]]).concat([input.slice()]); if (input.length != 160) { throw new Error('xxx bad input size'); } /* let buckets = [input.slice()]; if (reserved.length > 0) { let pxPerReserved = input.length; for (let c of reserved) { for (let i = 0; i < pxPerReserved; i++) { buckets[0].unshift(atariRGB[c]); } } console.log(buckets[0].length, 'xxx'); } */ let magicSort = (picker) => (a, b) => { let bychannel = picker(b) - picker(a); if (bychannel) return bychannel; let byluma = b.luma() - a.luma(); return byluma; }; let medianCut = (bucket, range) => { if (bucket.length < 2) { throw new Error('short bucket'); } //console.log('medianCut', bucket, range); // Sort by the channel with the greatest range, // then cut the bucket in two at the median. if (range.g >= range.r && range.g >= range.b) { //bucket.sort((a, b) => b.g - a.g); bucket.sort(magicSort((rgb) => rgb.g)); } else if (range.r >= range.g && range.r >= range.b) { //bucket.sort((a, b) => b.r - a.r); bucket.sort(magicSort((rgb) => rgb.r)); } else if (range.b >= range.g && range.b >= range.r) { //bucket.sort((a, b) => b.b - a.b); bucket.sort(magicSort((rgb) => rgb.b)); } let half = bucket.length >> 1; //console.log('cutting', half, bucket.length); let [bottom, top] = [bucket.slice(0, half), bucket.slice(half)]; //console.log({bottom, top}); return [bottom, top]; //return [bucket.slice(0, half), bucket.slice(half)]; }; while (buckets.length < n) { // Find the bucket with the greatest range in any channel let ranges = buckets.map((bucket) => { if (bucket.length == 0) { throw new Error('xxx empty bucket'); } let red = bucket.map((rgb) => rgb.r); let green = bucket.map((rgb) => rgb.g); let blue = bucket.map((rgb) => rgb.b); return new RGB( Math.max(...red) - Math.min(...red), Math.max(...green) - Math.min(...green), Math.max(...blue) - Math.min(...blue) ); }); let topRanges = ranges.map((rgb) => Math.max(rgb.r, rgb.g, rgb.b)); //let greatest = Math.max(...topRanges); //let index = topRanges.indexOf(greatest); let greatest = 0; let index = -1; for (let i = 0; i < topRanges.length; i++) { //if (topRanges[i] >= greatest) { if (topRanges[i] > greatest) { greatest = topRanges[i]; index = i; } } if (index == -1) { // We just ran out of colors! Pad the buckets. //while (buckets.length < n) { // buckets.push([new RGB(0, 0, 0)]); //} break; } let [lo, hi] = medianCut(buckets[index], ranges[index]); buckets.splice(index, 1, lo, hi); } if (buckets.length > n) { throw new Error('xxx too many colors assigned'); } decimated = buckets.map((bucket) => { // Average the RGB colors in this chunk let rgb = bucket .reduce((acc, rgb) => acc.inc(rgb), new RGB(0, 0, 0)) .divide(bucket.length); // Scale the average to the brightest let avg_luma = rgb.luma(); let lumas = bucket.map((rgb) => rgb.luma()); let brightest = Math.max(...lumas); if (avg_luma > 0) { rgb = rgb.multiply(brightest / avg_luma).clamp(); } // this also works pretty ok // but i think keeping luma is better // /* // 1) take the brightest luma // 2) take the most saturated chroma // 3) profit! let lumas = bucket.map((rgb) => rgb.luma()); let brightest = Math.max(...lumas); let saturations = bucket.map((rgb) => Math.max(rgb.r, rgb.g, rgb.b) - Math.min(rgb.r, rgb.g, rgb.b)); let saturation = Math.max(...saturations); let saturatedIndex = saturations.indexOf(saturation); let rgb = bucket[saturatedIndex]; let luma = rgb.luma(); if (luma > 0) { rgb = rgb.multiply(brightest / luma).clamp(); } */ // pick the luma-brightest color in the bucket // kinda nice but really aggressive with the colors /* let lumas = bucket.map((rgb) => rgb.luma()); let luma = Math.max(...lumas); let rgb = bucket[lumas.indexOf(luma)]; */ // Take the channel-brightest color in the bucket // bad //let rgb = bucket[bucket.length - 1]; // Take the luma-brightest color in the bucket // wrong? bad //let rgb = bucket.slice().sort((a, b) => b.luma() - a.luma())[bucket.length - 1]; // Take the median color in the bucket // bad //let rgb = bucket[bucket.length >> 1]; // Combine the brightest of each channel // this is kinda good /* let rgb = new RGB( Math.max(...bucket.map((rgb) => rgb.r)), Math.max(...bucket.map((rgb) => rgb.g)), Math.max(...bucket.map((rgb) => rgb.b)) ); */ // combine the median of each channel // sux /* let rgb = new RGB( bucket.map((rgb) => rgb.r).sort((a, b) => b - a)[bucket.length >> 1], bucket.map((rgb) => rgb.g).sort((a, b) => b - a)[bucket.length >> 1], bucket.map((rgb) => rgb.b).sort((a, b) => b - a)[bucket.length >> 1] ); */ // Take the luma-median color in the bucket //let rgb = bucket.slice().sort((a, b) => b.luma() - a.luma())[bucket.length >> 1]; // Take the brightest-channel median //let rgb = bucket.slice() // .sort((a, b) => Math.max(b.r, b.g, b.b) - Math.max(a.r, b.g, b.b))[bucket.length >> 1]; // And map into the Atari palette let dists = palette.map((i) => rgb.difference(atariRGB[i]).magnitude()); let closest = Math.min(...dists); let index = dists.indexOf(closest); return palette[index]; }); decimated.sort((a, b) => a - b); // Palette fits return dither(decimated); } /** * Read an image file into a buffer * @param {string} src * @returns {{width: number, height: number, rgba: Uint8Array}} */ async function loadImage(src) { let image = await Jimp.read(src); let width = image.bitmap.width; let height = image.bitmap.height; let aspect = width / height; let dar = 2 / 1.2; if (aspect > ((320 / 1.2) / 192)) { // wide width = 160; height = Math.round((width * image.bitmap.height / image.bitmap.width) * dar); if (height & 1) { height++; } } else { // tall height = 192; width = Math.round((height * image.bitmap.width / image.bitmap.height) / dar); if (width & 1) { width++; } } image = image.resize(width, height); let rgba = image.bitmap.data.slice(); return { width, height, rgba, }; } function imageToLinearRGB(rgba) { let input = []; for (let i = 0; i < rgba.length; i += 4) { input.push(new RGB( rgba[i + 0], rgba[i + 1], rgba[i + 2] ).fromSRGB()); } return input; } /** * Read an image file, squish to 160px if necessary, * and dither to 4 colors per scan line. * * @param {string} source path to source image file * @returns {{width: number, height: number, lines: {palette: Array, output: Uint8Array}[]}} */ async function convert(source) { let { width, height, rgba } = await loadImage(source); if (width > 160) { throw new Error(`expected <160px width, got ${width} pixels`); } if (height > 192) { throw new Error(`expected <192px height, got ${height} pixels`); } if (rgba.length != width * 4 * height) { console.log(` width: ${width} height: ${height} rgba.length: ${rgba.length}`) throw new Error('inconsistent data size'); } let input = imageToLinearRGB(rgba); if (input.length != width * height) { console.log(` width: ${width} height: ${height} rgba.length: ${input.length}`) throw new Error('inconsistent data size on input'); } // Start with all colors usable with regular CTIA modes // (not the 16-luminance special mode on GTIA) let allColors = []; for (let i = 0; i < 256; i += 2) { allColors.push(i); } let left = [], right = []; let padding = 0; if (width < 160) { padding = 160 - width; let black = new RGB(0, 0, 0); left = repeat(black, padding >> 1); right = repeat(black, padding + 1 >> 1); } let lines = []; for (let y = 0; y < height; y++) { let inputLine = input .slice(y * width, (y + 1) * width); if (padding) { inputLine = left.concat(inputLine, right); } if (y > 0) { let error = lines[y - 1].error; inputLine = inputLine.map((rgb, x) => rgb.add(error[x]).clamp()); } let line = decimate(inputLine, allColors, 4, y); lines.push(line); } return { width: width + padding, height, lines }; } function indexedToBitmap(width, nbits, src, dest) { let nbytes = width * nbits / 8; let x = 0; for (let i = 0; i < nbytes; i++) { let a = 0; for (let b = 0; b < 8; b += nbits) { a <<= nbits; a |= src[x++]; } dest[i] = a; } } function byte2byte(arr) { let lines = []; for (let i=0; i < arr.length; i++) { lines.push(`.byte ${arr[i]}`); } return lines.join('\n'); } //let [even, odd] = [0, 1].map((bit) => (arr) => arr.filter((_item, index) => (index & 1) === bit)); function even(arr) { return arr.filter((_item, index) => !(index & 1)); } function odd(arr) { return arr.filter((_item, index) => (index & 1)); } function genAssembly(width, height, nbits, lines) { let stride = width * nbits / 8; let half = stride * height / 2; let frame = { palette1: new Uint8Array(height), palette2: new Uint8Array(height), palette3: new Uint8Array(height), bitmap: new Uint8Array(stride * height), }; for (let y = 0; y < height; y++) { let base = 0; frame.palette1[y] = lines[y + base].palette[1]; frame.palette2[y] = lines[y + base].palette[2]; frame.palette3[y] = lines[y + base].palette[3]; indexedToBitmap( width, nbits, lines[y + base].output, frame.bitmap.subarray(y * stride, (y + 1) * stride) ); } return `.data .export frame1_top .export frame1_bottom .export frame1_palette1_even .export frame1_palette1_odd .export frame1_palette2_even .export frame1_palette2_odd .export frame1_palette3_even .export frame1_palette3_odd .export displaylist .segment "BUFFERS" .align 4096 frame1_top: ${byte2byte(frame.bitmap.slice(0, half))} .align 4096 frame1_bottom: ${byte2byte(frame.bitmap.slice(half))} .align 128 frame1_palette1_even: ${byte2byte(even(frame.palette1))} .align 128 frame1_palette1_odd: ${byte2byte(odd(frame.palette1))} .align 128 frame1_palette2_even: ${byte2byte(even(frame.palette2))} .align 128 frame1_palette2_odd: ${byte2byte(odd(frame.palette2))} .align 128 frame1_palette3_even: ${byte2byte(even(frame.palette3))} .align 128 frame1_palette3_odd: ${byte2byte(odd(frame.palette3))} .align 1024 displaylist: ; 24 lines overscan .repeat 2 .byte $70 ; 8 blank lines .endrep ; include a DLI to mark us as frame 0 .byte $f0 ; 8 blank lines ; ${height} lines graphics ; ANTIC mode e (160px 2bpp, 1 scan line per line) .byte $4e .addr frame1_top .repeat ${height / 2 - 1} .byte $0e .endrep .byte $4e .addr frame1_bottom .repeat ${height / 2 - 1} .byte $0e .endrep .byte $41 ; jump and blank .addr displaylist `; } /** * Double width and save as an image file * @param {number} width * @param {number} height * @param {{output: number[], palette: number[]}} lines * @param {string} dest */ async function saveImage(width, height, lines, dest) { let width2 = width * 2; let stride = width2 * 4; let rgba = new Uint8Array(stride * height); for (let y = 0; y < height; y++) { let {output, palette} = lines[y]; for (let x = 0; x < width2; x++) { let i = x >> 1; if (i >= width) { throw new Error('i >= width'); } //let rgb = atariRGB[palette[output[i]]].fromLinear(); let rgb = atariRGB[palette[output[i]]].toSRGB(); rgba[y * stride + x * 4 + 0] = rgb.r; rgba[y * stride + x * 4 + 1] = rgb.g; rgba[y * stride + x * 4 + 2] = rgb.b; rgba[y * stride + x * 4 + 3] = 255; } } let image = await new Promise((resolve, reject) => { new Jimp({ data: rgba, width: width2, height, }, (err, image) => { if (err) reject(err); resolve(image); }); }); await image.resize(Math.round(width2 * 2), height * 2); await image.writeAsync(dest); } async function main() { if (process.argv.length < 3) { console.error("Usage: node dither-image.js source-image.jpg dest-asm.s"); process.exit(1); } let nbits = 2; let {width, height, lines} = await convert(process.argv[2], nbits); let asm = genAssembly(width, height, nbits, lines); writeFileSync(process.argv[3], asm, "utf-8"); await saveImage(width, height, lines, `${process.argv[3]}.png`); process.exit(0); } main();