PDF.js 源码解读: obj_bin_transform_display

class CSS_FONT_INFO {
  static strings = ['fontFamily', 'fontWeight', 'italicAngle'];
}
 
class SYSTEM_FONT_INFO {
  static strings = ['css', 'loadedName', 'baseFontName', 'src'];
}
 
class FONT_INFO {
  static bools = [
    'black',
    'bold',
    'disableFontFace',
    'fontExtraProperties',
    'isInvalidPDFjsFont',
    'isType3Font',
    'italic',
    'missingFile',
    'remeasure',
    'vertical',
  ];
 
  static numbers = ['ascent', 'defaultWidth', 'descent'];
  static strings = ['fallbackName', 'loadedName', 'mimetype', 'name'];
 
  static OFFSET_NUMBERS = Math.ceil((this.bools.length * 2) / 8);
  static OFFSET_BBOX = this.OFFSET_NUMBERS + this.numbers.length * 8;
  static OFFSET_FONT_MATRIX = this.OFFSET_BBOX + 1 + 2 * 4;
  static OFFSET_DEFAULT_VMETRICS = this.OFFSET_FONT_MATRIX + 1 + 8 * 6;
  static OFFSET_STRINGS = this.OFFSET_DEFAULT_VMETRICS + 1 + 2 * 3;
}

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;
case "FontPath":
  this.commonObjs.resolve(id, new FontPathInfo(exportedData));
  break;
case "Pattern":
  const pattern = new PatternInfo(exportedData);
  this.commonObjs.resolve(id, pattern.getIR());
  break;

createNativeFontFace() {
  if (!this.data || this.disableFontFace) {
    return null;
  }
  let nativeFontFace;
  if (!this.cssFontInfo) {
    nativeFontFace = new FontFace(this.loadedName, this.data, {});
  } else {
    const css = {
      weight: this.cssFontInfo.fontWeight,
    };
    if (this.cssFontInfo.italicAngle) {
      css.style = `oblique ${this.cssFontInfo.italicAngle}deg`;
    }
    nativeFontFace = new FontFace(
      serializeFontFamily(this.cssFontInfo.fontFamily),
      this.data,
      css
    );
  }
  this._inspectFont?.(this);
  return nativeFontFace;
}

class CssFontInfo {
  #buffer;
  #view;
 
  constructor(buffer) {
    this.#buffer = buffer;
    this.#view = new DataView(buffer);
  }
 
  #readString(index) {
    assert(index < CSS_FONT_INFO.strings.length, 'Invalid string index');
    const { decoder } = InfoUtils;
    let offset = 0;
    for (let i = 0; i < index; i++) {
      offset += this.#view.getUint32(offset) + 4;
    }
    const length = this.#view.getUint32(offset);
    return decoder.decode(new Uint8Array(this.#buffer, offset + 4, length));
  }
}

get guessFallback() {
  return this.#view.getUint8(0) !== 0;
}
 
#readString(index) {
  assert(index < SYSTEM_FONT_INFO.strings.length, "Invalid string index");
  const { decoder } = InfoUtils;
  let offset = 5;
  for (let i = 0; i < index; i++) {
    offset += this.#view.getUint32(offset) + 4;
  }
  const length = this.#view.getUint32(offset);
  return decoder.decode(new Uint8Array(this.#buffer, offset + 4, length));
}

get style() {
  const { decoder } = InfoUtils;
  let offset = 1;
  offset += 4 + this.#view.getUint32(offset);
  const styleLength = this.#view.getUint32(offset);
  const style = decoder.decode(
    new Uint8Array(this.#buffer, offset + 4, styleLength)
  );
  offset += 4 + styleLength;
  const weightLength = this.#view.getUint32(offset);
  const weight = decoder.decode(
    new Uint8Array(this.#buffer, offset + 4, weightLength)
  );
  return { style, weight };
}

constructor({ buffer, extra }) {
  this.#buffer = buffer;
  this.#view = new DataView(buffer);
  if (extra) {
    Object.assign(this, extra);
  }
}

#readBoolean(index) {
  assert(index < FONT_INFO.bools.length, "Invalid boolean index");
  const byteOffset = Math.floor(index / 4);
  const bitOffset = (index * 2) % 8;
  const value = (this.#view.getUint8(byteOffset) >> bitOffset) & 0x03;
  return value === 0x00 ? undefined : value === 0x02;
}

#readNumber(index) {
  assert(index < FONT_INFO.numbers.length, "Invalid number index");
  return this.#view.getFloat64(FONT_INFO.OFFSET_NUMBERS + index * 8);
}

#readArray(offset, arrLen, lookupName, increment) {
  const len = this.#view.getUint8(offset);
  if (len === 0) {
    return undefined;
  }
  assert(len === arrLen, "Invalid array length.");
  offset += 1;
  const arr = new Array(len);
  for (let i = 0; i < len; i++) {
    arr[i] = this.#view[lookupName](offset, true);
    offset += increment;
  }
  return arr;
}

#readString(index) {
  assert(index < FONT_INFO.strings.length, "Invalid string index");
  const { decoder } = InfoUtils;
  let offset = FONT_INFO.OFFSET_STRINGS + 4;
  for (let i = 0; i < index; i++) {
    offset += this.#view.getUint32(offset) + 4;
  }
  const length = this.#view.getUint32(offset);
  return decoder.decode(new Uint8Array(this.#buffer, offset + 4, length));
}

#getDataOffsets() {
  let offset = FONT_INFO.OFFSET_STRINGS;
  const stringsLength = this.#view.getUint32(offset);
  offset += 4 + stringsLength;
  const systemFontInfoLength = this.#view.getUint32(offset);
  offset += 4 + systemFontInfoLength;
  const cssFontInfoLength = this.#view.getUint32(offset);
  offset += 4 + cssFontInfoLength;
  const length = this.#view.getUint32(offset);
 
  return { offset, length };
}
 
get data() {
  const { offset, length } = this.#getDataOffsets();
  return length === 0
    ? undefined
    : new Uint8Array(this.#buffer, offset + 4, length);
}

clearData() {
  const { offset, length } = this.#getDataOffsets();
  if (length === 0) {
    return;
  }
  this.#view.setUint32(offset, 0);
 
  this.#buffer = new Uint8Array(this.#buffer, 0, offset + 4).slice().buffer;
  this.#view = new DataView(this.#buffer);
}

get cssFontInfo() {
  let offset = FONT_INFO.OFFSET_STRINGS;
  const stringsLength = this.#view.getUint32(offset);
  offset += 4 + stringsLength;
  const systemFontInfoLength = this.#view.getUint32(offset);
  offset += 4 + systemFontInfoLength;
  const cssFontInfoLength = this.#view.getUint32(offset);
  if (cssFontInfoLength === 0) {
    return null;
  }
  const cssFontInfoData = new Uint8Array(cssFontInfoLength);
  cssFontInfoData.set(
    new Uint8Array(this.#buffer, offset + 4, cssFontInfoLength)
  );
  return new CssFontInfo(cssFontInfoData.buffer);
}
 
get systemFontInfo() {
  let offset = FONT_INFO.OFFSET_STRINGS;
  const stringsLength = this.#view.getUint32(offset);
  offset += 4 + stringsLength;
  const systemFontInfoLength = this.#view.getUint32(offset);
  if (systemFontInfoLength === 0) {
    return null;
  }
  const systemFontInfoData = new Uint8Array(systemFontInfoLength);
  systemFontInfoData.set(
    new Uint8Array(this.#buffer, offset + 4, systemFontInfoLength)
  );
  return new SystemFontInfo(systemFontInfoData.buffer);
}

getIR() {
  const dataView = this.view;
  const kind = this.data[PATTERN_INFO.KIND];
  const hasBBox = !!this.data[PATTERN_INFO.HAS_BBOX];
  const hasBackground = !!this.data[PATTERN_INFO.HAS_BACKGROUND];
  const nCoord = dataView.getUint32(PATTERN_INFO.N_COORD, true);
  const nColor = dataView.getUint32(PATTERN_INFO.N_COLOR, true);
  const nStop = dataView.getUint32(PATTERN_INFO.N_STOP, true);
 
  let offset = 20;
  const coords = new Float32Array(this.buffer, offset, nCoord * 2);
  offset += nCoord * 8;
  const colors = new Uint8Array(this.buffer, offset, nColor * 4);
  offset += nColor * 4;
  const stops = [];
  for (let i = 0; i < nStop; ++i) {
    const p = dataView.getFloat32(offset, true);
    offset += 4;
    const rgb = dataView.getUint32(offset, true);
    offset += 4;
    stops.push([p, `#${rgb.toString(16).padStart(6, "0")}`]);
  }
  let bbox = null;
  if (hasBBox) {
    bbox = [];
    for (let i = 0; i < 4; ++i) {
      bbox.push(dataView.getFloat32(offset, true));
      offset += 4;
    }
  }
 
  let background = null;
  if (hasBackground) {
    background = new Uint8Array(this.buffer, offset, 3);
    offset += 3;
  }
  // The kind-specific return value follows.
}

if (kind === 1) {
  return [
    'RadialAxial',
    'axial',
    bbox,
    stops,
    Array.from(coords.slice(0, 2)),
    Array.from(coords.slice(2, 4)),
    null,
    null,
  ];
}
if (kind === 2) {
  return [
    'RadialAxial',
    'radial',
    bbox,
    stops,
    [coords[0], coords[1]],
    [coords[3], coords[4]],
    coords[2],
    coords[5],
  ];
}
if (kind === 3) {
  const shadingType = this.data[PATTERN_INFO.SHADING_TYPE];
  let bounds = null;
  if (coords.length > 0) {
    bounds = BBOX_INIT.slice();
    for (let i = 0, ii = coords.length; i < ii; i += 2) {
      Util.pointBoundingBox(coords[i], coords[i + 1], bounds);
    }
  }
  return ['Mesh', shadingType, coords, colors, nCoord, bounds, bbox, background];
}
throw new Error(`Unsupported pattern kind: ${kind}`);

class FontPathInfo {
  #buffer;
 
  constructor(buffer) {
    this.#buffer = buffer;
  }
 
  get path() {
    if (
      (typeof PDFJSDev !== 'undefined' && PDFJSDev.test('MOZCENTRAL')) ||
      FeatureTest.isFloat16ArraySupported
    ) {
      return new Float16Array(this.#buffer);
    }
    return new Float32Array(this.#buffer);
  }
}