@huh-david/bmp-js 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 @丝刀口
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,78 @@
+# @huh-david/bmp-js
+
+A pure TypeScript BMP encoder/decoder for Node.js.
+
+## Features
+
+- Decoding for BMP bit depths: 1, 4, 8, 15, 16, 24, 32
+- Decoding support for RLE-4 and RLE-8 compressed BMPs
+- Encoding output as 24-bit BMP
+- Dual package output: ESM + CommonJS
+- First-class TypeScript types
+
+## Install
+
+```bash
+pnpm add @huh-david/bmp-js
+```
+
+## Usage
+
+### ESM
+
+```ts
+import { decode, encode } from "@huh-david/bmp-js";
+import { readFileSync, writeFileSync } from "node:fs";
+
+const input = readFileSync("./image.bmp");
+const decoded = decode(input);
+
+const encoded = encode({
+  data: decoded.data,
+  width: decoded.width,
+  height: decoded.height,
+});
+
+writeFileSync("./roundtrip.bmp", encoded.data);
+```
+
+### CommonJS
+
+```js
+const bmp = require("@huh-david/bmp-js");
+const fs = require("node:fs");
+
+const decoded = bmp.decode(fs.readFileSync("./image.bmp"));
+const encoded = bmp.encode(decoded);
+
+fs.writeFileSync("./roundtrip.bmp", encoded.data);
+```
+
+## Data layout
+
+Decoded pixel data is a byte buffer in `ABGR` order.
+
+- `A`: alpha
+- `B`: blue
+- `G`: green
+- `R`: red
+
+## Development
+
+```bash
+pnpm install
+pnpm check
+```
+
+Useful scripts:
+
+- `pnpm build`
+- `pnpm test`
+- `pnpm test:watch`
+- `pnpm lint`
+- `pnpm format`
+- `pnpm typecheck`
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,569 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BmpDecoder: () => BmpDecoder,
+  BmpEncoder: () => BmpEncoder,
+  decode: () => decode,
+  default: () => index_default,
+  encode: () => encode
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/decoder.ts
+var BmpDecoder = class {
+  pos = 0;
+  buffer;
+  isWithAlpha;
+  bottomUp = true;
+  maskRed = 0;
+  maskGreen = 0;
+  maskBlue = 0;
+  mask0 = 0;
+  fileSize;
+  reserved;
+  offset;
+  headerSize;
+  width;
+  height;
+  planes;
+  bitPP;
+  compress;
+  rawSize;
+  hr;
+  vr;
+  colors;
+  importantColors;
+  palette;
+  data;
+  constructor(buffer, isWithAlpha = false) {
+    this.buffer = buffer;
+    this.isWithAlpha = isWithAlpha;
+    const flag = this.buffer.toString("utf-8", 0, this.pos += 2);
+    if (flag !== "BM") {
+      throw new Error("Invalid BMP File");
+    }
+    this.parseHeader();
+    this.parseRGBA();
+  }
+  parseHeader() {
+    this.fileSize = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.reserved = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.offset = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.headerSize = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.width = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.height = this.buffer.readInt32LE(this.pos);
+    this.pos += 4;
+    this.planes = this.buffer.readUInt16LE(this.pos);
+    this.pos += 2;
+    this.bitPP = this.buffer.readUInt16LE(this.pos);
+    this.pos += 2;
+    this.compress = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.rawSize = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.hr = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.vr = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.colors = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    this.importantColors = this.buffer.readUInt32LE(this.pos);
+    this.pos += 4;
+    if (this.bitPP === 16 && this.isWithAlpha) {
+      this.bitPP = 15;
+    }
+    if (this.bitPP < 15) {
+      const len = this.colors === 0 ? 1 << this.bitPP : this.colors;
+      this.palette = new Array(len);
+      for (let i = 0; i < len; i += 1) {
+        const blue = this.buffer.readUInt8(this.pos++);
+        const green = this.buffer.readUInt8(this.pos++);
+        const red = this.buffer.readUInt8(this.pos++);
+        const quad = this.buffer.readUInt8(this.pos++);
+        this.palette[i] = { red, green, blue, quad };
+      }
+    }
+    if (this.height < 0) {
+      this.height *= -1;
+      this.bottomUp = false;
+    }
+  }
+  parseRGBA() {
+    const len = this.width * this.height * 4;
+    this.data = Buffer.alloc(len);
+    switch (this.bitPP) {
+      case 1:
+        this.bit1();
+        return;
+      case 4:
+        this.bit4();
+        return;
+      case 8:
+        this.bit8();
+        return;
+      case 15:
+        this.bit15();
+        return;
+      case 16:
+        this.bit16();
+        return;
+      case 24:
+        this.bit24();
+        return;
+      case 32:
+        this.bit32();
+        return;
+      default:
+        throw new Error(`Unsupported BMP bit depth: ${this.bitPP}`);
+    }
+  }
+  getPaletteColor(index) {
+    const color = this.palette?.[index];
+    if (color) {
+      return color;
+    }
+    return {
+      red: 255,
+      green: 255,
+      blue: 255,
+      quad: 0
+    };
+  }
+  bit1() {
+    const xLen = Math.ceil(this.width / 8);
+    const mode = xLen % 4;
+    for (let y = this.height - 1; y >= 0; y -= 1) {
+      const line = this.bottomUp ? y : this.height - 1 - y;
+      for (let x = 0; x < xLen; x += 1) {
+        const b = this.buffer.readUInt8(this.pos++);
+        const location = line * this.width * 4 + x * 8 * 4;
+        for (let i = 0; i < 8; i += 1) {
+          if (x * 8 + i >= this.width) {
+            break;
+          }
+          const rgb = this.getPaletteColor(b >> 7 - i & 1);
+          this.data[location + i * 4] = 0;
+          this.data[location + i * 4 + 1] = rgb.blue;
+          this.data[location + i * 4 + 2] = rgb.green;
+          this.data[location + i * 4 + 3] = rgb.red;
+        }
+      }
+      if (mode !== 0) {
+        this.pos += 4 - mode;
+      }
+    }
+  }
+  bit4() {
+    if (this.compress === 2) {
+      let setPixelData2 = function(rgbIndex) {
+        const rgb = this.getPaletteColor(rgbIndex);
+        this.data[location] = 0;
+        this.data[location + 1] = rgb.blue;
+        this.data[location + 2] = rgb.green;
+        this.data[location + 3] = rgb.red;
+        location += 4;
+      };
+      var setPixelData = setPixelData2;
+      this.data.fill(255);
+      let location = 0;
+      let lines = this.bottomUp ? this.height - 1 : 0;
+      let lowNibble = false;
+      while (location < this.data.length) {
+        const a = this.buffer.readUInt8(this.pos++);
+        const b = this.buffer.readUInt8(this.pos++);
+        if (a === 0) {
+          if (b === 0) {
+            lines += this.bottomUp ? -1 : 1;
+            location = lines * this.width * 4;
+            lowNibble = false;
+            continue;
+          }
+          if (b === 1) {
+            break;
+          }
+          if (b === 2) {
+            const x = this.buffer.readUInt8(this.pos++);
+            const y = this.buffer.readUInt8(this.pos++);
+            lines += this.bottomUp ? -y : y;
+            location += y * this.width * 4 + x * 4;
+            continue;
+          }
+          let c = this.buffer.readUInt8(this.pos++);
+          for (let i = 0; i < b; i += 1) {
+            if (lowNibble) {
+              setPixelData2.call(this, c & 15);
+            } else {
+              setPixelData2.call(this, (c & 240) >> 4);
+            }
+            if ((i & 1) === 1 && i + 1 < b) {
+              c = this.buffer.readUInt8(this.pos++);
+            }
+            lowNibble = !lowNibble;
+          }
+          if ((b + 1 >> 1 & 1) === 1) {
+            this.pos += 1;
+          }
+        } else {
+          for (let i = 0; i < a; i += 1) {
+            if (lowNibble) {
+              setPixelData2.call(this, b & 15);
+            } else {
+              setPixelData2.call(this, (b & 240) >> 4);
+            }
+            lowNibble = !lowNibble;
+          }
+        }
+      }
+      return;
+    }
+    const xLen = Math.ceil(this.width / 2);
+    const mode = xLen % 4;
+    for (let y = this.height - 1; y >= 0; y -= 1) {
+      const line = this.bottomUp ? y : this.height - 1 - y;
+      for (let x = 0; x < xLen; x += 1) {
+        const b = this.buffer.readUInt8(this.pos++);
+        const location = line * this.width * 4 + x * 2 * 4;
+        const before = b >> 4;
+        const after = b & 15;
+        let rgb = this.getPaletteColor(before);
+        this.data[location] = 0;
+        this.data[location + 1] = rgb.blue;
+        this.data[location + 2] = rgb.green;
+        this.data[location + 3] = rgb.red;
+        if (x * 2 + 1 >= this.width) {
+          break;
+        }
+        rgb = this.getPaletteColor(after);
+        this.data[location + 4] = 0;
+        this.data[location + 5] = rgb.blue;
+        this.data[location + 6] = rgb.green;
+        this.data[location + 7] = rgb.red;
+      }
+      if (mode !== 0) {
+        this.pos += 4 - mode;
+      }
+    }
+  }
+  bit8() {
+    if (this.compress === 1) {
+      let setPixelData2 = function(rgbIndex) {
+        const rgb = this.getPaletteColor(rgbIndex);
+        this.data[location] = 0;
+        this.data[location + 1] = rgb.blue;
+        this.data[location + 2] = rgb.green;
+        this.data[location + 3] = rgb.red;
+        location += 4;
+      };
+      var setPixelData = setPixelData2;
+      this.data.fill(255);
+      let location = 0;
+      let lines = this.bottomUp ? this.height - 1 : 0;
+      while (location < this.data.length) {
+        const a = this.buffer.readUInt8(this.pos++);
+        const b = this.buffer.readUInt8(this.pos++);
+        if (a === 0) {
+          if (b === 0) {
+            lines += this.bottomUp ? -1 : 1;
+            location = lines * this.width * 4;
+            continue;
+          }
+          if (b === 1) {
+            break;
+          }
+          if (b === 2) {
+            const x = this.buffer.readUInt8(this.pos++);
+            const y = this.buffer.readUInt8(this.pos++);
+            lines += this.bottomUp ? -y : y;
+            location += y * this.width * 4 + x * 4;
+            continue;
+          }
+          for (let i = 0; i < b; i += 1) {
+            const c = this.buffer.readUInt8(this.pos++);
+            setPixelData2.call(this, c);
+          }
+          if ((b & 1) === 1) {
+            this.pos += 1;
+          }
+        } else {
+          for (let i = 0; i < a; i += 1) {
+            setPixelData2.call(this, b);
+          }
+        }
+      }
+      return;
+    }
+    const mode = this.width % 4;
+    for (let y = this.height - 1; y >= 0; y -= 1) {
+      const line = this.bottomUp ? y : this.height - 1 - y;
+      for (let x = 0; x < this.width; x += 1) {
+        const b = this.buffer.readUInt8(this.pos++);
+        const location = line * this.width * 4 + x * 4;
+        const rgb = this.getPaletteColor(b);
+        this.data[location] = 0;
+        this.data[location + 1] = rgb.blue;
+        this.data[location + 2] = rgb.green;
+        this.data[location + 3] = rgb.red;
+      }
+      if (mode !== 0) {
+        this.pos += 4 - mode;
+      }
+    }
+  }
+  bit15() {
+    const difW = this.width % 3;
+    const m = 31;
+    for (let y = this.height - 1; y >= 0; y -= 1) {
+      const line = this.bottomUp ? y : this.height - 1 - y;
+      for (let x = 0; x < this.width; x += 1) {
+        const value = this.buffer.readUInt16LE(this.pos);
+        this.pos += 2;
+        const blue = (value & m) / m * 255;
+        const green = (value >> 5 & m) / m * 255;
+        const red = (value >> 10 & m) / m * 255;
+        const alpha = value >> 15 !== 0 ? 255 : 0;
+        const location = line * this.width * 4 + x * 4;
+        this.data[location] = alpha;
+        this.data[location + 1] = blue | 0;
+        this.data[location + 2] = green | 0;
+        this.data[location + 3] = red | 0;
+      }
+      this.pos += difW;
+    }
+  }
+  bit16() {
+    const difW = this.width % 2 * 2;
+    this.maskRed = 31744;
+    this.maskGreen = 992;
+    this.maskBlue = 31;
+    this.mask0 = 0;
+    if (this.compress === 3) {
+      this.maskRed = this.buffer.readUInt32LE(this.pos);
+      this.pos += 4;
+      this.maskGreen = this.buffer.readUInt32LE(this.pos);
+      this.pos += 4;
+      this.maskBlue = this.buffer.readUInt32LE(this.pos);
+      this.pos += 4;
+      this.mask0 = this.buffer.readUInt32LE(this.pos);
+      this.pos += 4;
+    }
+    const ns = [0, 0, 0];
+    for (let i = 0; i < 16; i += 1) {
+      if ((this.maskRed >> i & 1) !== 0) ns[0] += 1;
+      if ((this.maskGreen >> i & 1) !== 0) ns[1] += 1;
+      if ((this.maskBlue >> i & 1) !== 0) ns[2] += 1;
+    }
+    ns[1] += ns[0];
+    ns[2] += ns[1];
+    ns[0] = 8 - ns[0];
+    ns[1] -= 8;
+    ns[2] -= 8;
+    for (let y = this.height - 1; y >= 0; y -= 1) {
+      const line = this.bottomUp ? y : this.height - 1 - y;
+      for (let x = 0; x < this.width; x += 1) {
+        const value = this.buffer.readUInt16LE(this.pos);
+        this.pos += 2;
+        const blue = (value & this.maskBlue) << ns[0];
+        const green = (value & this.maskGreen) >> ns[1];
+        const red = (value & this.maskRed) >> ns[2];
+        const location = line * this.width * 4 + x * 4;
+        this.data[location] = 0;
+        this.data[location + 1] = blue;
+        this.data[location + 2] = green;
+        this.data[location + 3] = red;
+      }
+      this.pos += difW;
+    }
+  }
+  bit24() {
+    for (let y = this.height - 1; y >= 0; y -= 1) {
+      const line = this.bottomUp ? y : this.height - 1 - y;
+      for (let x = 0; x < this.width; x += 1) {
+        const blue = this.buffer.readUInt8(this.pos++);
+        const green = this.buffer.readUInt8(this.pos++);
+        const red = this.buffer.readUInt8(this.pos++);
+        const location = line * this.width * 4 + x * 4;
+        this.data[location] = 0;
+        this.data[location + 1] = blue;
+        this.data[location + 2] = green;
+        this.data[location + 3] = red;
+      }
+      this.pos += this.width % 4;
+    }
+  }
+  bit32() {
+    if (this.compress === 3) {
+      this.maskRed = this.buffer.readUInt32LE(this.pos);
+      this.pos += 4;
+      this.maskGreen = this.buffer.readUInt32LE(this.pos);
+      this.pos += 4;
+      this.maskBlue = this.buffer.readUInt32LE(this.pos);
+      this.pos += 4;
+      this.mask0 = this.buffer.readUInt32LE(this.pos);
+      this.pos += 4;
+      for (let y = this.height - 1; y >= 0; y -= 1) {
+        const line = this.bottomUp ? y : this.height - 1 - y;
+        for (let x = 0; x < this.width; x += 1) {
+          const alpha = this.buffer.readUInt8(this.pos++);
+          const blue = this.buffer.readUInt8(this.pos++);
+          const green = this.buffer.readUInt8(this.pos++);
+          const red = this.buffer.readUInt8(this.pos++);
+          const location = line * this.width * 4 + x * 4;
+          this.data[location] = alpha;
+          this.data[location + 1] = blue;
+          this.data[location + 2] = green;
+          this.data[location + 3] = red;
+        }
+      }
+      return;
+    }
+    for (let y = this.height - 1; y >= 0; y -= 1) {
+      const line = this.bottomUp ? y : this.height - 1 - y;
+      for (let x = 0; x < this.width; x += 1) {
+        const blue = this.buffer.readUInt8(this.pos++);
+        const green = this.buffer.readUInt8(this.pos++);
+        const red = this.buffer.readUInt8(this.pos++);
+        const alpha = this.buffer.readUInt8(this.pos++);
+        const location = line * this.width * 4 + x * 4;
+        this.data[location] = alpha;
+        this.data[location + 1] = blue;
+        this.data[location + 2] = green;
+        this.data[location + 3] = red;
+      }
+    }
+  }
+  getData() {
+    return this.data;
+  }
+};
+function decode(bmpData) {
+  return new BmpDecoder(bmpData);
+}
+
+// src/encoder.ts
+var BmpEncoder = class {
+  buffer;
+  width;
+  height;
+  extraBytes;
+  rgbSize;
+  headerInfoSize;
+  flag = "BM";
+  reserved = 0;
+  offset = 54;
+  fileSize;
+  planes = 1;
+  bitPP = 24;
+  compress = 0;
+  hr = 0;
+  vr = 0;
+  colors = 0;
+  importantColors = 0;
+  pos = 0;
+  constructor(imgData) {
+    this.buffer = imgData.data;
+    this.width = imgData.width;
+    this.height = imgData.height;
+    this.extraBytes = this.width % 4;
+    this.rgbSize = this.height * (3 * this.width + this.extraBytes);
+    this.headerInfoSize = 40;
+    this.fileSize = this.rgbSize + this.offset;
+  }
+  encode() {
+    const tempBuffer = Buffer.alloc(this.offset + this.rgbSize);
+    tempBuffer.write(this.flag, this.pos, 2);
+    this.pos += 2;
+    tempBuffer.writeUInt32LE(this.fileSize, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.reserved, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.offset, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.headerInfoSize, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.width, this.pos);
+    this.pos += 4;
+    tempBuffer.writeInt32LE(-this.height, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt16LE(this.planes, this.pos);
+    this.pos += 2;
+    tempBuffer.writeUInt16LE(this.bitPP, this.pos);
+    this.pos += 2;
+    tempBuffer.writeUInt32LE(this.compress, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.rgbSize, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.hr, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.vr, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.colors, this.pos);
+    this.pos += 4;
+    tempBuffer.writeUInt32LE(this.importantColors, this.pos);
+    this.pos += 4;
+    let i = 0;
+    const rowBytes = 3 * this.width + this.extraBytes;
+    for (let y = 0; y < this.height; y += 1) {
+      for (let x = 0; x < this.width; x += 1) {
+        const p = this.pos + y * rowBytes + x * 3;
+        i += 1;
+        tempBuffer[p] = this.buffer.readUInt8(i++);
+        tempBuffer[p + 1] = this.buffer.readUInt8(i++);
+        tempBuffer[p + 2] = this.buffer.readUInt8(i++);
+      }
+      if (this.extraBytes > 0) {
+        const fillOffset = this.pos + y * rowBytes + this.width * 3;
+        tempBuffer.fill(0, fillOffset, fillOffset + this.extraBytes);
+      }
+    }
+    return tempBuffer;
+  }
+};
+function encode(imgData, quality = 100) {
+  void quality;
+  const encoder = new BmpEncoder(imgData);
+  const data = encoder.encode();
+  return {
+    data,
+    width: imgData.width,
+    height: imgData.height
+  };
+}
+
+// src/index.ts
+var bmp = {
+  encode,
+  decode
+};
+var index_default = bmp;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BmpDecoder,
+  BmpEncoder,
+  decode,
+  encode
+});
+//# sourceMappingURL=index.cjs.map