Add mem free printing (I need it to verify a suspicion relating to a bug)

node_modules/lv_font_conv/lib/font/font.js

@@ -0,0 +1,131 @@
+// Font class to generate tables
+'use strict';
+
+const u = require('../utils');
+const debug = require('debug')('font');
+const Head = require('./table_head');
+const Cmap = require('./table_cmap');
+const Glyf = require('./table_glyf');
+const Loca = require('./table_loca');
+const Kern = require('./table_kern');
+
+class Font {
+  constructor(fontData, options) {
+    this.src = fontData;
+
+    this.opts = options;
+
+    // Map chars to IDs (zero is reserved)
+    this.glyph_id = { 0: 0 };
+
+    this.last_id = 1;
+    this.createIDs();
+    debug(`last_id: ${this.last_id}`);
+
+    this.init_tables();
+
+    this.minY = Math.min(...this.src.glyphs.map(g => g.bbox.y));
+    debug(`minY: ${this.minY}`);
+    this.maxY = Math.max(...this.src.glyphs.map(g => g.bbox.y + g.bbox.height));
+    debug(`maxY: ${this.maxY}`);
+
+    // 0 => 1 byte, 1 => 2 bytes
+    this.glyphIdFormat = Math.max(...Object.values(this.glyph_id)) > 255 ? 1 : 0;
+    debug(`glyphIdFormat: ${this.glyphIdFormat}`);
+
+    // 1.0 by default, will be stored in font as FP12.4
+    this.kerningScale = 1.0;
+    let kerningMax = Math.max(...this.src.glyphs.map(g => Object.values(g.kerning).map(Math.abs)).flat());
+    if (kerningMax >= 7.5) this.kerningScale = Math.ceil(kerningMax / 7.5 * 16) / 16;
+    debug(`kerningScale: ${this.kerningScale}`);
+
+    // 0 => int, 1 => FP4
+    this.advanceWidthFormat = this.hasKerning() ? 1 : 0;
+    debug(`advanceWidthFormat: ${this.advanceWidthFormat}`);
+
+    this.xy_bits = Math.max(...this.src.glyphs.map(g => Math.max(
+      u.signed_bits(g.bbox.x), u.signed_bits(g.bbox.y)
+    )));
+    debug(`xy_bits: ${this.xy_bits}`);
+
+    this.wh_bits = Math.max(...this.src.glyphs.map(g => Math.max(
+      u.unsigned_bits(g.bbox.width), u.unsigned_bits(g.bbox.height)
+    )));
+    debug(`wh_bits: ${this.wh_bits}`);
+
+    this.advanceWidthBits = Math.max(...this.src.glyphs.map(
+      g => u.signed_bits(this.widthToInt(g.advanceWidth))
+    ));
+    debug(`advanceWidthBits: ${this.advanceWidthBits}`);
+
+    let glyphs = this.src.glyphs;
+
+    this.monospaced = glyphs.every((v, i, arr) => v.advanceWidth === arr[0].advanceWidth);
+    debug(`monospaced: ${this.monospaced}`);
+
+    // This should stay in the end, because depends on previous variables
+    // 0 => 2 bytes, 1 => 4 bytes
+    this.indexToLocFormat = this.glyf.getSize() > 65535 ? 1 : 0;
+    debug(`indexToLocFormat: ${this.indexToLocFormat}`);
+
+    this.subpixels_mode = options.lcd ? 1 : (options.lcd_v ? 2 : 0);
+    debug(`subpixels_mode: ${this.subpixels_mode}`);
+  }
+
+  init_tables() {
+    this.head = new Head(this);
+    this.glyf = new Glyf(this);
+    this.cmap = new Cmap(this);
+    this.loca = new Loca(this);
+    this.kern = new Kern(this);
+  }
+
+  createIDs() {
+    // Simplified, don't check dupes
+    this.last_id = 1;
+
+    for (let i = 0; i < this.src.glyphs.length; i++) {
+      // reserve zero for special cases
+      this.glyph_id[this.src.glyphs[i].code] = this.last_id;
+      this.last_id++;
+    }
+  }
+
+  hasKerning() {
+    if (this.opts.no_kerning) return false;
+
+    for (let glyph of this.src.glyphs) {
+      if (glyph.kerning && Object.keys(glyph.kerning).length) return true;
+    }
+    return false;
+  }
+
+  // Returns integer width, depending on format
+  widthToInt(val) {
+    if (this.advanceWidthFormat === 0) return Math.round(val);
+
+    return Math.round(val * 16);
+  }
+
+  // Convert kerning to FP4.4, useable for writer. Apply `kerningScale`.
+  kernToFP(val) {
+    return Math.round(val / this.kerningScale * 16);
+  }
+
+  toBin() {
+    const result = Buffer.concat([
+      this.head.toBin(),
+      this.cmap.toBin(),
+      this.loca.toBin(),
+      this.glyf.toBin(),
+      this.kern.toBin()
+    ]);
+
+    debug(`font size: ${result.length}`);
+
+    return result;
+  }
+}
+
+
+module.exports = Font;