@huh-david/bmp-js 0.4.0 → 0.5.0

package/README.md

@@ -2,12 +2,19 @@
 
 A pure TypeScript BMP encoder/decoder for Node.js.
 
+## Maintenance
+
+This fork is actively maintained and tracks unresolved upstream `shaozilee/bmp-js` issues and PRs.
+
+- Repository: https://github.com/Huh-David/bmp-js
+- Latest release: https://github.com/Huh-David/bmp-js/releases/tag/v0.4.0
+
 ## Features
 
 - Decoding for BMP bit depths: 1, 4, 8, 15, 16, 24, 32
 - Decoding support for RLE-4 and RLE-8 compressed BMPs
 - Robust DIB handling for CORE/INFO/V4/V5 headers
-- Encoding output as 24-bit BMP with configurable orientation
+- Encoding output bit depths: 1, 4, 8, 16, 24, 32
 - Dual package output: ESM + CommonJS
 - First-class TypeScript types
 
@@ -50,7 +57,9 @@ const encoded = encode(
   },
   {
     orientation: "bottom-up", // default: "top-down"
-    bitPP: 24, // only 24 is currently supported
+    bitPP: 32, // supported: 1, 4, 8, 16, 24, 32
+    // palette is required for 4/8-bit and optional for 1-bit
+    // palette: [{ red: 0, green: 0, blue: 0, quad: 0 }, ...],
   },
 );
 ```
@@ -67,9 +76,20 @@ const encoded = bmp.encode(decoded);
 fs.writeFileSync("./roundtrip.bmp", encoded.data);
 ```
 
+### Decode options
+
+```ts
+import { decode } from "@huh-david/bmp-js";
+
+const decoded = decode(inputBytes, {
+  toRGBA: true, // return RGBA instead of default ABGR
+});
+```
+
 ## Data layout
 
-Decoded pixel data is a byte buffer in `ABGR` order.
+Decoded pixel data is a byte buffer in `ABGR` order by default.
+If `toRGBA: true` is provided to `decode`, output is returned in `RGBA`.
 
 - `A`: alpha
 - `B`: blue

package/dist/index.cjs

@@ -81,13 +81,15 @@ var BmpDecoder = class {
     this.bytes = toUint8Array(input);
     this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
     this.options = {
-      treat16BitAs15BitAlpha: options.treat16BitAs15BitAlpha ?? false
+      treat16BitAs15BitAlpha: options.treat16BitAs15BitAlpha ?? false,
+      toRGBA: options.toRGBA ?? false
     };
     this.parseFileHeader();
     this.parseDibHeader();
     this.parsePalette();
     this.pos = this.offset;
     this.parseRGBA();
+    this.transformToRgbaIfNeeded();
   }
   ensureReadable(offset, size, context) {
     if (offset < 0 || size < 0 || offset + size > this.bytes.length) {
@@ -269,6 +271,21 @@ var BmpDecoder = class {
         throw new Error(`Unsupported BMP bit depth: ${this.bitPP}`);
     }
   }
+  transformToRgbaIfNeeded() {
+    if (!this.options.toRGBA) {
+      return;
+    }
+    for (let i = 0; i < this.data.length; i += 4) {
+      const alpha = this.data[i] ?? 0;
+      const blue = this.data[i + 1] ?? 0;
+      const green = this.data[i + 2] ?? 0;
+      const red = this.data[i + 3] ?? 0;
+      this.data[i] = red;
+      this.data[i + 1] = green;
+      this.data[i + 2] = blue;
+      this.data[i + 3] = alpha;
+    }
+  }
   getPaletteColor(index) {
     const color = this.palette?.[index];
     if (color) {
@@ -294,7 +311,7 @@ var BmpDecoder = class {
         const packed = this.readUInt8(rowStart + Math.floor(x / 8));
         const bit = packed >> 7 - x % 8 & 1;
         const rgb = this.getPaletteColor(bit);
-        this.setPixel(destY, x, 0, rgb.blue, rgb.green, rgb.red);
+        this.setPixel(destY, x, 255, rgb.blue, rgb.green, rgb.red);
       }
     }
   }
@@ -313,7 +330,7 @@ var BmpDecoder = class {
         const packed = this.readUInt8(rowStart + Math.floor(x / 2));
         const idx = x % 2 === 0 ? (packed & 240) >> 4 : packed & 15;
         const rgb = this.getPaletteColor(idx);
-        this.setPixel(destY, x, 0, rgb.blue, rgb.green, rgb.red);
+        this.setPixel(destY, x, 255, rgb.blue, rgb.green, rgb.red);
       }
     }
   }
@@ -331,7 +348,7 @@ var BmpDecoder = class {
       for (let x = 0; x < this.width; x += 1) {
         const idx = this.readUInt8(rowStart + x);
         const rgb = this.getPaletteColor(idx);
-        this.setPixel(destY, x, 0, rgb.blue, rgb.green, rgb.red);
+        this.setPixel(destY, x, 255, rgb.blue, rgb.green, rgb.red);
       }
     }
   }
@@ -387,7 +404,7 @@ var BmpDecoder = class {
         const blue = this.scaleMasked(value, this.maskBlue);
         const green = this.scaleMasked(value, this.maskGreen);
         const red = this.scaleMasked(value, this.maskRed);
-        const alpha = this.maskAlpha !== 0 ? this.scaleMasked(value, this.maskAlpha) : 0;
+        const alpha = this.maskAlpha !== 0 ? this.scaleMasked(value, this.maskAlpha) : 255;
         this.setPixel(destY, x, alpha, blue, green, red);
       }
     }
@@ -403,7 +420,7 @@ var BmpDecoder = class {
         const blue = this.readUInt8(base);
         const green = this.readUInt8(base + 1);
         const red = this.readUInt8(base + 2);
-        this.setPixel(destY, x, 0, blue, green, red);
+        this.setPixel(destY, x, 255, blue, green, red);
       }
     }
   }
@@ -420,7 +437,7 @@ var BmpDecoder = class {
           const red = this.scaleMasked(pixel, this.maskRed || 16711680);
           const green = this.scaleMasked(pixel, this.maskGreen || 65280);
           const blue = this.scaleMasked(pixel, this.maskBlue || 255);
-          const alpha = this.maskAlpha === 0 ? 0 : this.scaleMasked(pixel, this.maskAlpha);
+          const alpha = this.maskAlpha === 0 ? 255 : this.scaleMasked(pixel, this.maskAlpha);
           this.setPixel(destY, x, alpha, blue, green, red);
         } else {
           const blue = this.readUInt8(base);
@@ -458,7 +475,7 @@ var BmpDecoder = class {
           const idx = this.readUInt8();
           const rgb2 = this.getPaletteColor(idx);
           if (x < this.width && y >= 0 && y < this.height) {
-            this.setPixel(y, x, 0, rgb2.blue, rgb2.green, rgb2.red);
+            this.setPixel(y, x, 255, rgb2.blue, rgb2.green, rgb2.red);
           }
           x += 1;
         }
@@ -470,7 +487,7 @@ var BmpDecoder = class {
       const rgb = this.getPaletteColor(value);
       for (let i = 0; i < count; i += 1) {
         if (x < this.width && y >= 0 && y < this.height) {
-          this.setPixel(y, x, 0, rgb.blue, rgb.green, rgb.red);
+          this.setPixel(y, x, 255, rgb.blue, rgb.green, rgb.red);
         }
         x += 1;
       }
@@ -503,7 +520,7 @@ var BmpDecoder = class {
           const nibble = i % 2 === 0 ? (current & 240) >> 4 : current & 15;
           const rgb = this.getPaletteColor(nibble);
           if (x < this.width && y >= 0 && y < this.height) {
-            this.setPixel(y, x, 0, rgb.blue, rgb.green, rgb.red);
+            this.setPixel(y, x, 255, rgb.blue, rgb.green, rgb.red);
           }
           x += 1;
           if (i % 2 === 1 && i + 1 < value) {
@@ -519,7 +536,7 @@ var BmpDecoder = class {
         const nibble = i % 2 === 0 ? (value & 240) >> 4 : value & 15;
         const rgb = this.getPaletteColor(nibble);
         if (x < this.width && y >= 0 && y < this.height) {
-          this.setPixel(y, x, 0, rgb.blue, rgb.green, rgb.red);
+          this.setPixel(y, x, 255, rgb.blue, rgb.green, rgb.red);
         }
         x += 1;
       }
@@ -536,22 +553,23 @@ function decode(bmpData, options) {
 // src/encoder.ts
 var FILE_HEADER_SIZE2 = 14;
 var INFO_HEADER_SIZE = 40;
-var RGB_TRIPLE_SIZE = 3;
 var BYTES_PER_PIXEL_ABGR = 4;
-function rowStride24(width) {
-  const raw = width * RGB_TRIPLE_SIZE;
-  return raw + 3 & ~3;
+var SUPPORTED_BIT_DEPTHS = [1, 4, 8, 16, 24, 32];
+function isSupportedBitDepth(value) {
+  return SUPPORTED_BIT_DEPTHS.includes(value);
 }
 function normalizeEncodeOptions(qualityOrOptions) {
   if (typeof qualityOrOptions === "number" || typeof qualityOrOptions === "undefined") {
     return {
       orientation: "top-down",
-      bitPP: 24
+      bitPP: 24,
+      palette: []
     };
   }
   return {
     orientation: qualityOrOptions.orientation ?? "top-down",
-    bitPP: qualityOrOptions.bitPP ?? 24
+    bitPP: qualityOrOptions.bitPP ?? 24,
+    palette: qualityOrOptions.palette ?? []
   };
 }
 var BmpEncoder = class {
@@ -559,16 +577,19 @@ var BmpEncoder = class {
   width;
   height;
   options;
+  palette;
+  exactPaletteIndex = /* @__PURE__ */ new Map();
   constructor(imgData, options) {
     this.pixelData = imgData.data;
     this.width = imgData.width;
     this.height = imgData.height;
     this.options = options;
+    this.palette = this.normalizePalette(options);
     assertInteger("width", this.width);
     assertInteger("height", this.height);
-    if (this.options.bitPP !== 24) {
+    if (!isSupportedBitDepth(this.options.bitPP)) {
       throw new Error(
-        `Unsupported encode bit depth: ${this.options.bitPP}. Only 24-bit output is supported.`
+        `Unsupported encode bit depth: ${this.options.bitPP}. Supported: 1, 4, 8, 16, 24, 32.`
       );
     }
     const minLength = this.width * this.height * BYTES_PER_PIXEL_ABGR;
@@ -577,11 +598,204 @@ var BmpEncoder = class {
         `Image data is too short: expected at least ${minLength} bytes for ${this.width}x${this.height} ABGR data.`
       );
     }
+    for (let i = 0; i < this.palette.length; i += 1) {
+      const color = this.palette[i];
+      const key = this.paletteKey(color.quad, color.blue, color.green, color.red);
+      if (!this.exactPaletteIndex.has(key)) {
+        this.exactPaletteIndex.set(key, i);
+      }
+    }
+  }
+  normalizePalette(options) {
+    if (options.bitPP === 1) {
+      const palette = options.palette.length ? options.palette : [
+        { red: 255, green: 255, blue: 255, quad: 0 },
+        { red: 0, green: 0, blue: 0, quad: 0 }
+      ];
+      this.validatePalette(options.bitPP, palette);
+      return palette;
+    }
+    if (options.bitPP === 4 || options.bitPP === 8) {
+      if (options.palette.length === 0) {
+        throw new Error(`Encoding ${options.bitPP}-bit BMP requires a non-empty palette.`);
+      }
+      this.validatePalette(options.bitPP, options.palette);
+      return options.palette;
+    }
+    return [];
+  }
+  validatePalette(bitPP, palette) {
+    const maxSize = 1 << bitPP;
+    if (palette.length === 0 || palette.length > maxSize) {
+      throw new Error(
+        `Palette size ${palette.length} is invalid for ${bitPP}-bit BMP. Expected 1..${maxSize}.`
+      );
+    }
+    for (const color of palette) {
+      this.validateChannel("palette.red", color.red);
+      this.validateChannel("palette.green", color.green);
+      this.validateChannel("palette.blue", color.blue);
+      this.validateChannel("palette.quad", color.quad);
+    }
+  }
+  validateChannel(name, value) {
+    if (!Number.isInteger(value) || value < 0 || value > 255) {
+      throw new Error(`${name} must be an integer between 0 and 255.`);
+    }
+  }
+  rowStride() {
+    return Math.floor((this.options.bitPP * this.width + 31) / 32) * 4;
+  }
+  sourceY(fileRow) {
+    return this.options.orientation === "top-down" ? fileRow : this.height - 1 - fileRow;
+  }
+  sourceOffset(x, y) {
+    return (y * this.width + x) * BYTES_PER_PIXEL_ABGR;
+  }
+  paletteKey(alpha, blue, green, red) {
+    return ((alpha & 255) << 24 | (blue & 255) << 16 | (green & 255) << 8 | red & 255) >>> 0;
+  }
+  findPaletteIndex(a, b, g, r) {
+    const exact = this.exactPaletteIndex.get(this.paletteKey(a, b, g, r));
+    if (exact !== void 0) {
+      return exact;
+    }
+    let bestIndex = 0;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < this.palette.length; i += 1) {
+      const color = this.palette[i];
+      const dr = color.red - r;
+      const dg = color.green - g;
+      const db = color.blue - b;
+      const da = color.quad - a;
+      const distance = dr * dr + dg * dg + db * db + da * da;
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestIndex = i;
+      }
+    }
+    return bestIndex;
+  }
+  writePalette(output, paletteOffset) {
+    for (let i = 0; i < this.palette.length; i += 1) {
+      const color = this.palette[i];
+      const base = paletteOffset + i * 4;
+      output[base] = color.blue;
+      output[base + 1] = color.green;
+      output[base + 2] = color.red;
+      output[base + 3] = color.quad;
+    }
+  }
+  encode1Bit(output, pixelOffset, stride) {
+    for (let fileRow = 0; fileRow < this.height; fileRow += 1) {
+      const srcY = this.sourceY(fileRow);
+      const rowStart = pixelOffset + fileRow * stride;
+      for (let x = 0; x < this.width; x += 8) {
+        let packed = 0;
+        for (let bit = 0; bit < 8; bit += 1) {
+          const px = x + bit;
+          if (px >= this.width) {
+            break;
+          }
+          const source = this.sourceOffset(px, srcY);
+          const a = this.pixelData[source] ?? 255;
+          const b = this.pixelData[source + 1] ?? 0;
+          const g = this.pixelData[source + 2] ?? 0;
+          const r = this.pixelData[source + 3] ?? 0;
+          const idx = this.findPaletteIndex(a, b, g, r) & 1;
+          packed |= idx << 7 - bit;
+        }
+        output[rowStart + Math.floor(x / 8)] = packed;
+      }
+    }
+  }
+  encode4Bit(output, pixelOffset, stride) {
+    for (let fileRow = 0; fileRow < this.height; fileRow += 1) {
+      const srcY = this.sourceY(fileRow);
+      const rowStart = pixelOffset + fileRow * stride;
+      for (let x = 0; x < this.width; x += 2) {
+        const sourceA = this.sourceOffset(x, srcY);
+        const idxA = this.findPaletteIndex(
+          this.pixelData[sourceA] ?? 255,
+          this.pixelData[sourceA + 1] ?? 0,
+          this.pixelData[sourceA + 2] ?? 0,
+          this.pixelData[sourceA + 3] ?? 0
+        );
+        let idxB = 0;
+        if (x + 1 < this.width) {
+          const sourceB = this.sourceOffset(x + 1, srcY);
+          idxB = this.findPaletteIndex(
+            this.pixelData[sourceB] ?? 255,
+            this.pixelData[sourceB + 1] ?? 0,
+            this.pixelData[sourceB + 2] ?? 0,
+            this.pixelData[sourceB + 3] ?? 0
+          );
+        }
+        output[rowStart + Math.floor(x / 2)] = (idxA & 15) << 4 | idxB & 15;
+      }
+    }
+  }
+  encode8Bit(output, pixelOffset, stride) {
+    for (let fileRow = 0; fileRow < this.height; fileRow += 1) {
+      const srcY = this.sourceY(fileRow);
+      const rowStart = pixelOffset + fileRow * stride;
+      for (let x = 0; x < this.width; x += 1) {
+        const source = this.sourceOffset(x, srcY);
+        output[rowStart + x] = this.findPaletteIndex(
+          this.pixelData[source] ?? 255,
+          this.pixelData[source + 1] ?? 0,
+          this.pixelData[source + 2] ?? 0,
+          this.pixelData[source + 3] ?? 0
+        );
+      }
+    }
+  }
+  encode16Bit(output, view, pixelOffset, stride) {
+    for (let fileRow = 0; fileRow < this.height; fileRow += 1) {
+      const srcY = this.sourceY(fileRow);
+      const rowStart = pixelOffset + fileRow * stride;
+      for (let x = 0; x < this.width; x += 1) {
+        const source = this.sourceOffset(x, srcY);
+        const b = this.pixelData[source + 1] ?? 0;
+        const g = this.pixelData[source + 2] ?? 0;
+        const r = this.pixelData[source + 3] ?? 0;
+        const value = (r >> 3 & 31) << 10 | (g >> 3 & 31) << 5 | b >> 3 & 31;
+        view.setUint16(rowStart + x * 2, value, true);
+      }
+    }
+  }
+  encode24Bit(output, pixelOffset, stride) {
+    for (let fileRow = 0; fileRow < this.height; fileRow += 1) {
+      const srcY = this.sourceY(fileRow);
+      const rowStart = pixelOffset + fileRow * stride;
+      for (let x = 0; x < this.width; x += 1) {
+        const source = this.sourceOffset(x, srcY);
+        const target = rowStart + x * 3;
+        output[target] = this.pixelData[source + 1] ?? 0;
+        output[target + 1] = this.pixelData[source + 2] ?? 0;
+        output[target + 2] = this.pixelData[source + 3] ?? 0;
+      }
+    }
+  }
+  encode32Bit(output, pixelOffset, stride) {
+    for (let fileRow = 0; fileRow < this.height; fileRow += 1) {
+      const srcY = this.sourceY(fileRow);
+      const rowStart = pixelOffset + fileRow * stride;
+      for (let x = 0; x < this.width; x += 1) {
+        const source = this.sourceOffset(x, srcY);
+        const target = rowStart + x * 4;
+        output[target] = this.pixelData[source + 1] ?? 0;
+        output[target + 1] = this.pixelData[source + 2] ?? 0;
+        output[target + 2] = this.pixelData[source + 3] ?? 0;
+        output[target + 3] = this.pixelData[source] ?? 255;
+      }
+    }
   }
   encode() {
-    const stride = rowStride24(this.width);
+    const stride = this.rowStride();
     const imageSize = stride * this.height;
-    const offset = FILE_HEADER_SIZE2 + INFO_HEADER_SIZE;
+    const paletteSize = this.palette.length * 4;
+    const offset = FILE_HEADER_SIZE2 + INFO_HEADER_SIZE + paletteSize;
     const totalSize = offset + imageSize;
     const output = new Uint8Array(totalSize);
     const view = new DataView(output.buffer, output.byteOffset, output.byteLength);
@@ -595,23 +809,35 @@ var BmpEncoder = class {
     const signedHeight = this.options.orientation === "top-down" ? -this.height : this.height;
     view.setInt32(22, signedHeight, true);
     view.setUint16(26, 1, true);
-    view.setUint16(28, 24, true);
+    view.setUint16(28, this.options.bitPP, true);
     view.setUint32(30, 0, true);
     view.setUint32(34, imageSize, true);
     view.setUint32(38, 0, true);
     view.setUint32(42, 0, true);
-    view.setUint32(46, 0, true);
+    view.setUint32(46, this.palette.length, true);
     view.setUint32(50, 0, true);
-    for (let fileRow = 0; fileRow < this.height; fileRow += 1) {
-      const srcY = this.options.orientation === "top-down" ? fileRow : this.height - 1 - fileRow;
-      const rowStart = offset + fileRow * stride;
-      for (let x = 0; x < this.width; x += 1) {
-        const source = (srcY * this.width + x) * BYTES_PER_PIXEL_ABGR;
-        const target = rowStart + x * RGB_TRIPLE_SIZE;
-        output[target] = this.pixelData[source + 1] ?? 0;
-        output[target + 1] = this.pixelData[source + 2] ?? 0;
-        output[target + 2] = this.pixelData[source + 3] ?? 0;
-      }
+    if (this.palette.length > 0) {
+      this.writePalette(output, FILE_HEADER_SIZE2 + INFO_HEADER_SIZE);
+    }
+    switch (this.options.bitPP) {
+      case 1:
+        this.encode1Bit(output, offset, stride);
+        break;
+      case 4:
+        this.encode4Bit(output, offset, stride);
+        break;
+      case 8:
+        this.encode8Bit(output, offset, stride);
+        break;
+      case 16:
+        this.encode16Bit(output, view, offset, stride);
+        break;
+      case 24:
+        this.encode24Bit(output, offset, stride);
+        break;
+      case 32:
+        this.encode32Bit(output, offset, stride);
+        break;
     }
     return output;
   }