PDF.js 从 demo 深入浅出 12: 字体翻译, 从 FontFile3 到 FontFace

handler.send("commonobj", ["g_d0_f1", "Font", fontData], transfers);

<< /ExtGState << /GS0 13 0 R >>
   /Font << /T1_0 14 0 R /T1_1 15 0 R >>
   /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >>

let fontRef;
if (font) {
  if (font instanceof Ref) {
    fontRef = font;
  }
} else {
  // 按名字加载: 从资源字典取原始引用
  const fontRes = resources.get("Font");
  if (fontRes) {
    fontRef = fontRes.getRaw(fontName); // T1_0 → Ref "14 0 R"
  }
}
if (fontRef) {
  if (this.type3FontRefs?.has(fontRef)) {
    return errorFont();
  }
  if (this.fontCache.has(fontRef)) {
    return this.fontCache.get(fontRef); // 同一引用直接复用 promise
  }
  try {
    font = this.xref.fetchIfRef(fontRef);
  } catch (ex) {
    warn(`loadFont - lookup failed: "${ex}".`);
  }
}
 
if (!(font instanceof Dict)) {
  if (!this.options.ignoreErrors && !this.parsingType3Font) {
    return errorFont(); // 生成 loadedName = "g_font_error" 的错误字体
  }
  // 忽略错误模式下, 退回内置的 fallback 字体字典
  font = fallbackFontDict || PartialEvaluator.fallbackFontDict;
}

{
  descriptor,   // FontDescriptor 字典 (452 0 R)
  dict,         // 字体字典本体 (Type0 时换成 DescendantFonts)
  baseDict,
  composite,    // Type0 复合字体? demo 为 false
  type: "Type1",
  firstChar: 32,
  lastChar: 169,
  toUnicode,    // demo 为 undefined
  hash,         // MurmurHash3_64 指纹
}

hash.update(encoding);            // "WinAnsiEncoding"
hash.update(`${firstChar}-${lastChar}`); // "32-169" — 宽度表的范围
hash.update(toUnicode 字节);      // demo 无, 跳过
hash.update(widthsBuf.join());    // "278,0,0,..." 宽度数组
// composite 字体还会混入 W 数组与 CIDToGIDMap
// Type3 字体额外混入 CharProcs 键值

const fontAliases = (descriptor.fontAliases ||= Object.create(null));
if (fontAliases[hash]) {
  // 已翻译过同内容字体: 建立别名, 直接返回缓存
  ...
} else {
  fontAliases[hash] = { fontID: this.idFactory.createFontId() };
}
fontID = fontAliases[hash].fontID; // "f1" / "f2"

font.loadedName = `${this.idFactory.getDocId()}_${fontID}`;
// g_d0_f1 / g_d0_f2

if (fontRefIsRef) {
  this.fontCache.put(fontRef, promise);
} else {
  font.cacheKey = `cacheKey_${fontID}`;
  this.fontCache.put(font.cacheKey, promise);
}
 
this.translateFont(preEvaluatedFont)
  .then(async translatedFont => {
    const translated = new TranslatedFont({
      loadedName: font.loadedName,
      font: translatedFont,
      dict: font,
    });
    if (translatedFont.isType3Font) {
      await translated.loadType3Data(this, resources, task, seenRefs);
    }
    resolve(translated);
  })
  .catch(reason => {
    // 翻译失败不抛错, resolve 一个 ErrorFont, 渲染继续
    resolve(new TranslatedFont({ loadedName, font: new ErrorFont(...), dict }));
  });
return promise;

for (const n of ["FontFile", "FontFile2", "FontFile3"]) {
  fontFile = descriptor.get(n);
  if (fontFile) {
    fontFileN = n;
    break;
  }
}

const properties = {
  type: "Type1",
  name: "DDPEFM+Helvetica", // FontName 与 BaseFont 一致
  subtype: "Type1C",        // 来自字体流字典
  file: fontFile,           // 解压后 4323 字节的 CFF 程序
  fontFileN: "FontFile3",
  fontMatrix,               // 字典无 FontMatrix, 用默认 FONT_IDENTITY_MATRIX
  firstChar: 32, lastChar: 169,
  toUnicode: undefined,
  bbox: [-166, -225, 1000, 931],
  ascent: 718, descent: -207,
  xHeight: 523, capHeight: 718,
  flags: 32, italicAngle: 0,
  ...
};

const font = new Font(fontName.name, fontFile, newProperties, this.options);

[type, subtype] = getFontFileType(file, properties);
// isTrueTypeFile / isOpenTypeFile / isType1File / isCFFFile 依次看魔数
// demo: CFF 魔数 (0x01 0x00) 命中 → type "Type1", subtype "Type1C"

case "Type1":
  this.mimetype = "font/opentype";
 
  const cff =
    subtype === "Type1C" || subtype === "CIDFontType0C"
      ? new CFFFont(file, properties)   // demo 走这里
      : new Type1Font(name, file, properties);
 
  adjustWidths(properties);
 
  // 把 CFF 数据包进一个 OTF 字体文件
  data = this.convert(name, cff, properties);
  break;

const builder = new OpenTypeFileBuilder(...);
builder.addTable("cmap", ...);  // 平台 3/1 的字符到字形映射
builder.addTable("CFF ", cff.data); // 重新编译后的 CFF
builder.addTable("OS/2", createOS2Table(..., properties)); // 含 fsSelection 粗斜体位
builder.addTable("head", ...);
builder.addTable("hhea", ...);  // caretSlopeRun = tan(italicAngle) * xHeight
builder.addTable("hmtx", ...);  // 逐字形宽度, 来自 charstrings 的 width
builder.addTable("maxp", ...);  // numGlyphs
builder.addTable("name", createNameTable(fontName));
builder.addTable("post", createPostTable(properties));
return builder.toArray(); // Uint8Array, 一个完整可加载的 OTF

exportData() {
  return {
    buffer: compileFontInfo(this.#getExportData(EXPORT_DATA_PROPERTIES)),
    charProcOperatorList: this.charProcOperatorList, // Type3 才有
    extra: this.fontExtraProperties ? ... : undefined,
  };
}

[
  "ascent", "bbox", "black", "bold", "cssFontInfo", "data",
  "defaultVMetrics", "defaultWidth", "descent", "disableFontFace",
  "fallbackName", "fontExtraProperties", "fontMatrix", "isInvalidPDFjsFont",
  "isType3Font", "italic", "loadedName", "mimetype", "missingFile",
  "name", "remeasure", "systemFontInfo", "vertical",
]

send(handler) {
  if (this.#sent) {
    return;
  }
  this.#sent = true;
 
  const fontData = this.font.exportData(),
    transfers = fontData.buffer ? [fontData.buffer] : null;
 
  handler.send("commonobj", [this.loadedName, "Font", fontData], transfers);
}

messageHandler.on("commonobj", ([id, type, exportedData]) => {
  if (this.commonObjs.has(id)) {
    return null;
  }
  switch (type) {
    case "Font":
      const fontData = new FontInfo(exportedData);
      const font = new FontFaceObject(
        fontData,
        inspectFont,
        exportedData.charProcOperatorList,
        exportedData.extra
      );
      this.fontLoader
        .bind(font)
        .catch(() => messageHandler.sendWithPromise("FontFallback", { id }))
        .finally(() => {
          if (!font.fontExtraProperties) {
            font.clearData(); // 挂载完成后立即释放字体二进制
          }
          this.commonObjs.resolve(id, font);
        });
      break;

async bind(font) {
  if (font.attached || (font.missingFile && !font.systemFontInfo)) {
    return; // 同一字体只挂一次
  }
  font.attached = true;
 
  if (font.systemFontInfo) {
    await this.loadSystemFont(font); // 系统字体替换路径, demo 不涉及
    return;
  }
 
  if (this.isFontLoadingAPISupported) {
    const nativeFontFace = font.createNativeFontFace();
    if (nativeFontFace) {
      this.addNativeFontFace(nativeFontFace); // document.fonts.add(...)
      try {
        await nativeFontFace.loaded;          // 等浏览器真正加载完
      } catch (ex) {
        font.disableFontFace = true;
        throw ex;
      }
    }
  }
  ...
}

nativeFontFace = new FontFace(this.loadedName, this.data, {});
// new FontFace("g_d0_f1", <OpenType buffer>, {})

fallback(handler, evaluatorOptions) {
  if (!this.font.data) {
    return;
  }
  // 字体加载失败, 退回内置渲染器
  this.font.disableFontFace = true;
  // 把之前解析过的所有字形的路径数据全部补发到主线程
  PartialEvaluator.buildFontPaths(
    this.font,
    this.font.glyphCacheValues,
    handler,
    evaluatorOptions
  );
}