Source: encode.js

  1. import crc32 from "./crc32.js";
  2. import { ChunkType, ColorType, PNG_HEADER } from "./constants.js";
  3. import { encode_IHDR, encode_IDAT_raw } from "./chunks.js";
  5. /**
  6.  * @typedef {Object} EncodeOptions
  7.  * @property {Uint8Array} data the raw pixel data to encode
  8.  * @property {number} width the width of the image
  9.  * @property {number} height the height of the image
  10.  * @property {ColorType} [colorType=ColorType.RGBA] the color type of the pixel data
  11.  * @property {number} [depth=8] the bit depth of the image
  12.  * @property {number} [filterMethod=FilterMethod.Paeth] the filter method to use
  13.  * @property {number} [firstFilter=filter] the first scanline filter method to use
  14.  * @property {Chunk[]} [ancillary=[]] additional chunks to include in the PNG
  15.  */
  17. /**
  18.  * Encodes a PNG buffer from the given image and options, using the specified `deflate` algorithm and optional compression options.
  19.  * The deflate function should have the signature `(buf, [deflateOptions]) => Uint8Array`.
  20.  *
  21.  * @param {EncodeOptions} options the encoding options
  22.  * @param {Function} deflate the sync deflate function to use
  23.  * @param {Object} [deflateOptions] optional deflate options passed to the deflate() function
  24.  */
  25. export function encode(options = {}, deflate, deflateOptions) {
  26.   const { data, ancillary = [], colorType = ColorType.RGBA } = options;
  27.   if (!data) throw new Error(`must specify { data }`);
  28.   if (!deflate) throw new Error(`must specify a deflate function`);
  29.   if (colorType !== ColorType.RGB && colorType !== ColorType.RGBA) {
  30.     throw new Error(
  31.       "only RGB or RGBA colorType encoding is currently supported"
  32.     );
  33.   }
  34.   return writeChunks([
  35.     { type: ChunkType.IHDR, data: encode_IHDR(options) },
  36.     ...ancillary,
  37.     {
  38.       type: ChunkType.IDAT,
  39.       data: deflate(encode_IDAT_raw(data, options), deflateOptions),
  40.     },
  41.     { type: ChunkType.IEND },
  42.   ]);
  43. }
  45. /**
  46.  * Encodes just the raw PNG header into a Uint8Array buffer.
  47.  * @returns {Uint8Array} the PNG header
  48.  */
  49. export function encodeHeader() {
  50.   return PNG_HEADER.slice();
  51. }
  53. /**
  54.  * Encodes a single PNG chunk into a Uint8Array buffer, by writing the chunk length, type, data, and CRC value.
  55.  * @param {Chunk} chunk the chunk to encode
  56.  * @returns {Uint8Array} the encoded chunk buffer
  57.  */
  58. export function encodeChunk(chunk) {
  59.   const length = chunk.data ? chunk.data.length : 0;
  60.   const output = new Uint8Array(4 + length + 4 + 4);
  61.   const dv = new DataView(output.buffer, output.byteOffset, output.byteLength);
  62.   // Write chunk length
  63.   let idx = 0;
  64.   encodeChunkRaw(output, dv, chunk, idx);
  65.   return output;
  66. }
  68. /**
  69.  * Writes and formats an array of PNG chunks into a complete PNG buffer, including the PNG header.
  70.  *
  71.  * @param {Chunk[]} chunks the array of chunks to encode
  72.  * @returns {Uint8Array} the encoded PNG buffer
  73.  */
  74. export function writeChunks(chunks) {
  75.   let totalSize = PNG_HEADER.length; // start with header
  76.   let idx = totalSize;
  77.   for (let chunk of chunks) {
  78.     totalSize += chunk.data ? chunk.data.length : 0;
  79.     totalSize += 12; // length, code, CRC value (4 bytes each)
  80.   }
  82.   const output = new Uint8Array(totalSize);
  83.   const dv = new DataView(output.buffer);
  85.   // write header
  86.   output.set(PNG_HEADER, 0);
  88.   for (let chunk of chunks) {
  89.     idx = encodeChunkRaw(output, dv, chunk, idx);
  90.   }
  92.   return output;
  93. }
  95. function encodeChunkRaw(output, dv, chunk, idx = 0) {
  96.   // Write chunk length
  97.   const length = chunk.data ? chunk.data.length : 0;
  98.   dv.setUint32(idx, length);
  99.   idx += 4;
  101.   // Where the chunk index starts (before type code)
  102.   const chunkStartIdx = idx;
  103.   const chunkDataStartIdx = idx + 4;
  104.   const chunkDataEndIdx = chunkDataStartIdx + length;
  106.   // Write chunk type code
  107.   const type = chunk.type;
  108.   dv.setUint32(chunkStartIdx, type);
  110.   // Write chunk data
  111.   if (chunk.data) output.set(chunk.data, chunkDataStartIdx);
  113.   // get the whole chunk buffer including type
  114.   const chunkBuf = output.subarray(chunkStartIdx, chunkDataEndIdx);
  116.   // compute CRC and write it
  117.   const crcValue = crc32(chunkBuf);
  118.   dv.setInt32(chunkDataEndIdx, crcValue);
  120.   // return next index for reading
  121.   return chunkDataEndIdx + 4;
  122. }