{

use Strict;

private $fontCache;

private $fontDescriptor;

var $GPOSFeatures;

var $GPOSLookups;

var $GPOSScriptLang;

var $MarkAttachmentType;

var $MarkGlyphSets;

var $GlyphClassMarks;

var $GlyphClassLigatures;

var $GlyphClassBases;

var $GlyphClassComponents;

var $GSUBScriptLang;

var $rtlPUAstr;

var $fontkey;

var $useOTL;

var $maxUni;

var $sFamilyClass;

var $sFamilySubClass;

var $sipset;

var $smpset;

var $_pos;

var $numTables;

var $searchRange;

var $entrySelector;

var $rangeShift;

var $tables;

var $otables;

var $filename;

var $fh;

var $glyphPos;

var $charToGlyph;

var $ascent;

var $descent;

var $lineGap;

var $hheaascent;

var $hheadescent;

var $hhealineGap;

var $advanceWidthMax;

var $typoAscender;

var $typoDescender;

var $typoLineGap;

var $usWinAscent;

var $usWinDescent;

var $strikeoutSize;

var $strikeoutPosition;

var $name;

var $familyName;

var $styleName;

var $fullName;

var $uniqueFontID;

var $unitsPerEm;

var $bbox;

var $capHeight;

var $xHeight;

var $stemV;

var $italicAngle;

var $flags;

var $underlinePosition;

var $underlineThickness;

var $charWidths;

var $defaultWidth;

var $maxStrLenRead;

var $numTTCFonts;

var $TTCFonts;

var $maxUniChar;

var $kerninfo;

var $haskernGPOS;

var $hassmallcapsGSUB;

var $codeToGlyph;

var $glyphdata;

var $LuCoverage;

public $panose;

public $version;

public $fontRevision;

public $restrictedUse;

public $glyphIDtoUni;

public $glyphToChar;

public $GSUBFeatures;

public $GSUBLookups;

public $GSLuCoverage;

public function __construct(FontCache $fontCache, $fontDescriptor)

{

$this->fontCache = $fontCache;

$this->fontDescriptor = $fontDescriptor;

// Maximum size of glyf table to read in as string (otherwise reads each glyph from file)

$this->maxStrLenRead = 200000;

}

public function getMetrics($file, $fontkey, $TTCfontID = 0, $debug = false, $BMPonly = false, $useOTL = 0)

{

$this->useOTL = $useOTL;

$this->fontkey = $fontkey;

$this->filename = $file;

$this->fh = fopen($file, 'rb');

if (!$this->fh) {

throw new \Mpdf\Exception\FontException(sprintf('Unable to open font file "%s"', $file));

}

$this->_pos = 0;

$this->charWidths = '';

$this->glyphPos = [];

$this->charToGlyph = [];

$this->tables = [];

$this->otables = [];

$this->kerninfo = [];

$this->haskernGPOS = [];

$this->hassmallcapsGSUB = [];

$this->ascent = 0;

$this->descent = 0;

$this->lineGap = 0;

$this->hheaascent = 0;

$this->hheadescent = 0;

$this->hhealineGap = 0;

$this->xHeight = 0;

$this->capHeight = 0;

$this->panose = [];

$this->sFamilyClass = 0;

$this->sFamilySubClass = 0;

$this->typoAscender = 0;

$this->typoDescender = 0;

$this->typoLineGap = 0;

$this->usWinAscent = 0;

$this->usWinDescent = 0;

$this->advanceWidthMax = 0;

$this->strikeoutSize = 0;

$this->strikeoutPosition = 0;

$this->numTTCFonts = 0;

$this->TTCFonts = [];

$this->version = $version = $this->read_ulong();

$this->panose = [];

if ($version === 0x4F54544F) {

throw new \Mpdf\Exception\FontException(sprintf('Fonts with postscript outlines are not supported (%s)', $file));

}

if ($version === 0x74746366 && !$TTCfontID) {

throw new \Mpdf\Exception\FontException(sprintf('TTCfontID for a TrueType Collection is not defined in mPDF "fontdata" configuration (%s)', $file));

}

if (!in_array($version, [0x00010000, 0x74727565], true) && !$TTCfontID) {

throw new \Mpdf\Exception\FontException(sprintf('Not a TrueType font: version=%s)', $version));

}

if ($TTCfontID > 0) {

$this->version = $version = $this->read_ulong(); // TTC Header version now

if (!in_array($version, [0x00010000, 0x00020000], true)) {

throw new \Mpdf\Exception\FontException(sprintf('Error parsing TrueType Collection: version=%s - (%s)', $version, $file));

}

$this->numTTCFonts = $this->read_ulong();

for ($i = 1; $i <= $this->numTTCFonts; $i++) {

$this->TTCFonts[$i]['offset'] = $this->read_ulong();

}

$this->seek($this->TTCFonts[$TTCfontID]['offset']);

$this->version = $version = $this->read_ulong(); // TTFont version again now

}

$this->readTableDirectory($debug);

$this->extractInfo($debug, $BMPonly, $useOTL);

fclose($this->fh);

}

function readTableDirectory($debug = false)

{

$this->numTables = $this->read_ushort();

$this->searchRange = $this->read_ushort();

$this->entrySelector = $this->read_ushort();

$this->rangeShift = $this->read_ushort();

$this->tables = [];

for ($i = 0; $i < $this->numTables; $i++) {

$record = [];

$record['tag'] = $this->read_tag();

$record['checksum'] = [$this->read_ushort(), $this->read_ushort()];

$record['offset'] = $this->read_ulong();

$record['length'] = $this->read_ulong();

$this->tables[$record['tag']] = $record;

}

if ($debug) {

$this->checksumTables();

}

}

function checksumTables()

{

// Check the checksums for all tables

foreach ($this->tables as $t) {

if ($t['length'] > 0 && $t['length'] < $this->maxStrLenRead) { // 1.02

$table = $this->get_chunk($t['offset'], $t['length']);

$checksum = $this->calcChecksum($table);

if ($t['tag'] === 'head') {

$up = unpack('n*', substr($table, 8, 4));

$adjustment[0] = $up[1];

$adjustment[1] = $up[2];

$checksum = $this->sub32($checksum, $adjustment);

}

$xchecksum = $t['checksum'];

if ($xchecksum != $checksum) {

throw new \Mpdf\Exception\FontException(sprintf('TTF file "%s": invalid checksum %s table: %s (expected %s)', $this->filename, dechex($checksum[0]) . dechex($checksum[1]), $t['tag'], dechex($xchecksum[0]) . dechex($xchecksum[1])));

}

}

}

}

function sub32($x, $y)

{

$xlo = $x[1];

$xhi = $x[0];

$ylo = $y[1];

$yhi = $y[0];

if ($ylo > $xlo) {

$xlo += 1 << 16;

++$yhi;

}

$reslo = $xlo - $ylo;

if ($yhi > $xhi) {

$xhi += 1 << 16;

}

$reshi = $xhi - $yhi;

$reshi &= 0xFFFF;

return [$reshi, $reslo];

}

function calcChecksum($data)

{

if (strlen($data) % 4) {

$data .= str_repeat("\0", 4 - (strlen($data) % 4));

}

$len = strlen($data);

$hi = 0x0000;

$lo = 0x0000;

for ($i = 0; $i < $len; $i += 4) {

$hi += (ord($data[$i]) << 8) + ord($data[$i + 1]);

$lo += (ord($data[$i + 2]) << 8) + ord($data[$i + 3]);

$hi += ($lo >> 16) & 0xFFFF;

$lo &= 0xFFFF;

}

$hi &= 0xFFFF;

return [$hi, $lo];

}

function get_table_pos($tag)

{

if (!isset($this->tables[$tag])) {

return [0, 0];

}

$offset = $this->tables[$tag]['offset'];

$length = $this->tables[$tag]['length'];

return [$offset, $length];

}

function seek($pos)

{

$this->_pos = $pos;

fseek($this->fh, $this->_pos);

}

function skip($delta)

{

$this->_pos = $this->_pos + $delta;

fseek($this->fh, $delta, SEEK_CUR);

}

function seek_table($tag, $offset_in_table = 0)

{

$tpos = $this->get_table_pos($tag);

$this->_pos = $tpos[0] + $offset_in_table;

fseek($this->fh, $this->_pos);

return $this->_pos;

}

function read_tag()

{

$this->_pos += 4;

return fread($this->fh, 4);

}

function read_short()

{

$this->_pos += 2;

$s = fread($this->fh, 2);

$a = (ord($s[0]) << 8) + ord($s[1]);

if ($a & (1 << 15)) {

$a = ($a - (1 << 16));

}

return $a;

}

function unpack_short($s)

{

$a = (ord($s[0]) << 8) + ord($s[1]);

if ($a & (1 << 15)) {

$a = ($a - (1 << 16));

}

return $a;

}

function read_ushort()

{

$this->_pos += 2;

$s = fread($this->fh, 2);

return (ord($s[0]) << 8) + ord($s[1]);

}

function read_ulong()

{

$this->_pos += 4;

$s = fread($this->fh, 4);

// if large uInt32 as an integer, PHP converts it to -ve

return (ord($s[0]) * 16777216) + (ord($s[1]) << 16) + (ord($s[2]) << 8) + ord($s[3]); // 16777216 = 1<<24

}

function get_ushort($pos)

{

fseek($this->fh, $pos);

$s = fread($this->fh, 2);

return (ord($s[0]) << 8) + ord($s[1]);

}

function get_ulong($pos)

{

fseek($this->fh, $pos);

$s = fread($this->fh, 4);

// iF large uInt32 as an integer, PHP converts it to -ve

return (ord($s[0]) * 16777216) + (ord($s[1]) << 16) + (ord($s[2]) << 8) + ord($s[3]); // 16777216 = 1<<24

}

function pack_short($val)

{

if ($val < 0) {

$val = abs($val);

$val = ~$val;

++$val;

}

return pack('n', $val);

}

function splice($stream, $offset, $value)

{

return substr($stream, 0, $offset) . $value . substr($stream, $offset + strlen($value));

}

function _set_ushort($stream, $offset, $value)

{

$up = pack("n", $value);

return $this->splice($stream, $offset, $up);

}

function _set_short($stream, $offset, $val)

{

if ($val < 0) {

$val = abs($val);

$val = ~$val;

$val += 1;

}

$up = pack("n", $val);

return $this->splice($stream, $offset, $up);

}

function get_chunk($pos, $length)

{

fseek($this->fh, $pos);

if ($length < 1) {

return '';

}

$data = (fread($this->fh, $length));

// fix for #1504

// if fread is used to read from a compressed / buffered stream (e.g. phar://...)

// the $length parameter will be ignored - fread is limited in size (usually 8192 bytes)

// to fix this, the data length must be checked after reading. If the read was incomplete,

// try to read the rest of the data

$dataLen = strlen($data);

while ($dataLen < $length && !feof($this->fh)) {

$data .= fread($this->fh, $length - $dataLen);

$dataLen = strlen($data);

}

return $data;

}

function get_table($tag)

{

list($pos, $length) = $this->get_table_pos($tag);

if ($length == 0) {

return '';

}

fseek($this->fh, $pos);

return (fread($this->fh, $length));

}

function add($tag, $data)

{

if ($tag === 'head') {

$data = $this->splice($data, 8, "\0\0\0\0");

}

$this->otables[$tag] = $data;

}

function getCTG($file, $TTCfontID = 0, $debug = false, $useOTL = false)

{

// Only called if font is not to be used as embedded subset i.e. NOT called for SIP/SMP fonts

$this->useOTL = $useOTL; // mPDF 5.7.1

$this->filename = $file;

$this->fh = fopen($file, 'rb');

if (!$this->fh) {

throw new \Mpdf\Exception\FontException(sprintf('Unable to open file "%s"', $file));

}

$this->_pos = 0;

$this->charWidths = '';

$this->glyphPos = [];

$this->charToGlyph = [];

$this->tables = [];

$this->numTTCFonts = 0;

$this->TTCFonts = [];

$this->skip(4);

if ($TTCfontID > 0) {

$this->version = $version = $this->read_ulong(); // TTC Header version now

if (!in_array($version, [0x00010000, 0x00020000], true)) {

throw new \Mpdf\Exception\FontException(sprintf("Error parsing TrueType Collection: version=%s (%s)", $version, $file));

}

$this->numTTCFonts = $this->read_ulong();

for ($i = 1; $i <= $this->numTTCFonts; $i++) {

$this->TTCFonts[$i]['offset'] = $this->read_ulong();

}

$this->seek($this->TTCFonts[$TTCfontID]['offset']);

$this->version = $version = $this->read_ulong(); // TTFont version again now

}

$this->readTableDirectory($debug);

// cmap - Character to glyph index mapping table

$cmap_offset = $this->seek_table('cmap');

$this->skip(2);

$cmapTableCount = $this->read_ushort();

$unicode_cmap_offset = 0;

for ($i = 0; $i < $cmapTableCount; $i++) {

$platformID = $this->read_ushort();

$encodingID = $this->read_ushort();

$offset = $this->read_ulong();

$save_pos = $this->_pos;

if ($platformID == 3 && $encodingID == 1) { // Microsoft, Unicode

$format = $this->get_ushort($cmap_offset + $offset);

if ($format == 4) {

$unicode_cmap_offset = $cmap_offset + $offset;

break;

}

} elseif ($platformID == 0) { // Unicode -- assume all encodings are compatible

$format = $this->get_ushort($cmap_offset + $offset);

if ($format == 4) {

$unicode_cmap_offset = $cmap_offset + $offset;

break;

}

}

$this->seek($save_pos);

}

$glyphToChar = [];

$charToGlyph = [];

$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);

// Map Unmapped glyphs - from $numGlyphs

if ($useOTL) {

$this->seek_table("maxp");

$this->skip(4);

$numGlyphs = $this->read_ushort();

$bctr = 0xE000;

for ($gid = 1; $gid < $numGlyphs; $gid++) {

if (!isset($glyphToChar[$gid])) {

while (isset($charToGlyph[$bctr])) {

$bctr++;

} // Avoid overwriting a glyph already mapped in PUA

if ($bctr > 0xF8FF) {

throw new \Mpdf\Exception\FontException(sprintf('Font "%s" cannot map all included glyphs into Private Use Area U+E000-U+F8FF; cannot use useOTL on this font', $file));

}

$glyphToChar[$gid][] = $bctr;

$charToGlyph[$bctr] = $gid;

$bctr++;

}

}

}

fclose($this->fh);

return $charToGlyph;

}

function getTTCFonts($file)

{

$this->filename = $file;

$this->fh = fopen($file, 'rb');

if (!$this->fh) {

throw new \Mpdf\Exception\FontException(sprintf('Unable to open file "%s"', $file));

}

$this->numTTCFonts = 0;

$this->TTCFonts = [];

$this->version = $version = $this->read_ulong();

if ($version === 0x74746366) {

$this->version = $version = $this->read_ulong(); // TTC Header version now

if (!in_array($version, [0x00010000, 0x00020000], true)) {

throw new \Mpdf\Exception\FontException(sprintf("Error parsing TrueType Collection: version=%s (%s)", $version, $file));

}

} else {

throw new \Mpdf\Exception\FontException(sprintf("Not a TrueType Collection: version=%s (%s)", $version, $file));

}

$this->numTTCFonts = $this->read_ulong();

for ($i = 1; $i <= $this->numTTCFonts; $i++) {

$this->TTCFonts[$i]['offset'] = $this->read_ulong();

}

}

function extractInfo($debug = false, $BMPonly = false, $useOTL = 0)

{

// Values are all set to 0 or blank at start of getMetrics

// name - Naming table

$name_offset = $this->seek_table("name");

$format = $this->read_ushort();

if ($format != 0 && $format != 1) {

throw new \Mpdf\Exception\FontException("Error loading font: Unknown name table format $format for font $this->filename");

}

$numRecords = $this->read_ushort();

$string_data_offset = $name_offset + $this->read_ushort();

$names = [1 => '', 2 => '', 3 => '', 4 => '', 6 => ''];

$K = array_keys($names);

$nameCount = count($names);

for ($i = 0; $i < $numRecords; $i++) {

$platformId = $this->read_ushort();

$encodingId = $this->read_ushort();

$languageId = $this->read_ushort();

$nameId = $this->read_ushort();

$length = $this->read_ushort();

$offset = $this->read_ushort();

if (!in_array($nameId, $K)) {

continue;

}

$N = '';

if ($platformId == 3 && $encodingId == 1 && $languageId == 0x409) { // Microsoft, Unicode, US English, PS Name

$opos = $this->_pos;

$this->seek($string_data_offset + $offset);

if ($length % 2 != 0) {

throw new \Mpdf\Exception\FontException("Error loading font: PostScript name is UTF-16BE string of odd length for font $this->filename");

}

$length /= 2;

$N = '';

while ($length > 0) {

$char = $this->read_ushort();

$N .= (chr($char));

$length -= 1;

}

$this->_pos = $opos;

$this->seek($opos);

} elseif ($platformId == 1 && $encodingId == 0 && $languageId == 0) { // Macintosh, Roman, English, PS Name

$opos = $this->_pos;

$N = $this->get_chunk($string_data_offset + $offset, $length);

$this->_pos = $opos;

$this->seek($opos);

}

if ($N && $names[$nameId] == '') {

$names[$nameId] = $N;

$nameCount -= 1;

if ($nameCount == 0) {

break;

}

}

}

if ($names[6]) {

$psName = $names[6];

} elseif ($names[4]) {

$psName = preg_replace('/ /', '-', $names[4]);

} elseif ($names[1]) {

$psName = preg_replace('/ /', '-', $names[1]);

} else {

$psName = '';

}

if (!$psName) {

throw new \Mpdf\Exception\FontException("Error loading font: Could not find PostScript font name '$this->filename'");

}

// CHECK IF psName valid (PadaukBook contains illegal characters in Name ID 6 i.e. Postscript Name)

$psNameInvalid = false;

$nameLength = strlen($psName);

for ($i = 0; $i < $nameLength; $i++) {

$c = $psName[$i];

$oc = ord($c);

if ($oc > 126 || strpos(' [](){}<>/%', $c) !== false) {

//throw new \Mpdf\Exception\FontException("psName=".$psName." contains invalid character ".$c." ie U+".ord(c));

$psNameInvalid = true;

break;

}

}

if ($psNameInvalid && $names[4]) {

$psName = preg_replace('/ /', '-', $names[4]);

}

$this->name = $psName;

if ($names[1]) {

$this->familyName = $names[1];

} else {

$this->familyName = $psName;

}

if ($names[2]) {

$this->styleName = $names[2];

} else {

$this->styleName = 'Regular';

}

if ($names[4]) {

$this->fullName = $names[4];

} else {

$this->fullName = $psName;

}

if ($names[3]) {

$this->uniqueFontID = $names[3];

} else {

$this->uniqueFontID = $psName;

}

if (!$psNameInvalid && $names[6]) {

$this->fullName = $names[6];

}

// head - Font header table

$this->seek_table('head');

if ($debug) {

$ver_maj = $this->read_ushort();

$ver_min = $this->read_ushort();

if ($ver_maj != 1) {

throw new \Mpdf\Exception\FontException('Error loading font: Unknown head table version ' . $ver_maj . '.' . $ver_min);

}

$this->fontRevision = $this->read_ushort() . $this->read_ushort();

$this->skip(4);

$magic = $this->read_ulong();

if ($magic !== 0x5F0F3CF5) {

throw new \Mpdf\Exception\FontException('Error loading font: Invalid head table magic ' . $magic);

}

$this->skip(2);

} else {

$this->skip(18);

}

$this->unitsPerEm = $unitsPerEm = $this->read_ushort();

$scale = 1000 / $unitsPerEm;

$this->skip(16);

$xMin = $this->read_short();

$yMin = $this->read_short();

$xMax = $this->read_short();

$yMax = $this->read_short();

$this->bbox = [($xMin * $scale), ($yMin * $scale), ($xMax * $scale), ($yMax * $scale)];

$this->skip(3 * 2);

$indexToLocFormat = $this->read_ushort();

$glyphDataFormat = $this->read_ushort();

if ($glyphDataFormat != 0) {

throw new \Mpdf\Exception\FontException(sprintf('Error loading font: Unknown glyph data format %s', $glyphDataFormat));

}

// hhea metrics table

if (isset($this->tables["hhea"])) {

$this->seek_table("hhea");

$this->skip(4);

$hheaAscender = $this->read_short();

$hheaDescender = $this->read_short();

$hheaLineGap = $this->read_short();

$hheaAdvanceWidthMax = $this->read_ushort();

$this->hheaascent = ($hheaAscender * $scale);

$this->hheadescent = ($hheaDescender * $scale);

$this->hhealineGap = ($hheaLineGap * $scale);

$this->advanceWidthMax = ($hheaAdvanceWidthMax * $scale);

}

// OS/2 - OS/2 and Windows metrics table

$use_typo_metrics = false;

if (isset($this->tables["OS/2"])) {

$this->seek_table("OS/2");

$version = $this->read_ushort();

$this->skip(2);

$usWeightClass = $this->read_ushort();

$this->skip(2);

$fsType = $this->read_ushort();

if ($fsType == 0x0002 || ($fsType & 0x0300) != 0) {

$this->restrictedUse = true;

}

$this->skip(16);

$yStrikeoutSize = $this->read_short();

$yStrikeoutPosition = $this->read_short();

$this->strikeoutSize = ($yStrikeoutSize * $scale);

$this->strikeoutPosition = ($yStrikeoutPosition * $scale);

$sF = $this->read_short();

$this->sFamilyClass = ($sF >> 8);

$this->sFamilySubClass = ($sF & 0xFF);

$this->_pos += 10; //PANOSE = 10 byte length

$panose = fread($this->fh, 10);

$this->panose = [];

$panoseLenght = strlen($panose);

for ($p = 0; $p < $panoseLenght; $p++) {

$this->panose[] = ord($panose[$p]);

}

$this->skip(20);

$fsSelection = $this->read_ushort();

$use_typo_metrics = (($fsSelection & 0x80) === 0x80); // bit#7 = USE_TYPO_METRICS

$this->skip(4);

$sTypoAscender = $this->read_short();

$sTypoDescender = $this->read_short();

$sTypoLineGap = $this->read_short();

if ($sTypoAscender) {

$this->typoAscender = ($sTypoAscender * $scale);

}

if ($sTypoDescender) {

$this->typoDescender = ($sTypoDescender * $scale);

}

if ($sTypoLineGap) {

$this->typoLineGap = ($sTypoLineGap * $scale);

}

$usWinAscent = $this->read_ushort();

$usWinDescent = $this->read_ushort();

if ($usWinAscent) {

$this->usWinAscent = ($usWinAscent * $scale);

}

if ($usWinDescent) {

$this->usWinDescent = ($usWinDescent * $scale);

}

if ($version > 1) {

$this->skip(8);

$sxHeight = $this->read_short();

$this->xHeight = ($sxHeight * $scale);

$sCapHeight = $this->read_short();

$this->capHeight = ($sCapHeight * $scale);

}

} else {

$usWeightClass = 400;

}

$this->stemV = 50 + (int) (($usWeightClass / 65.0) ** 2);

// FONT DESCRIPTOR METRICS

if ($this->fontDescriptor === 'winTypo') {

$this->ascent = $this->typoAscender;

$this->descent = $this->typoDescender;

$this->lineGap = $this->typoLineGap;

} elseif ($this->fontDescriptor === 'mac') {

$this->ascent = $this->hheaascent;

$this->descent = $this->hheadescent;

$this->lineGap = $this->hhealineGap;

} else { // $this->fontDescriptor === 'win'

$this->ascent = $this->usWinAscent;

$this->descent = -$this->usWinDescent;

$this->lineGap = 0;

// Special case - if either the winAscent or winDescent are greater than the

// font bounding box yMin yMax, then reduce them accordingly.

// This works with Myanmar Text (Windows 8 version) to give a

// line-height normal that is equivalent to that produced in browsers.

// Also Khmer OS = compatible with MSWord, Wordpad and browser.

if ($this->ascent > $this->bbox[3]) {

$this->ascent = $this->bbox[3];

}

if ($this->descent < $this->bbox[1]) {

$this->descent = $this->bbox[1];

}

// Override case - if the USE_TYPO_METRICS bit is set on OS/2 fsSelection

// this is telling the font to use the sTypo values and not the usWinAscent values.

// This works as a fix with Cambria Math to give a normal line-height;

// at present, this is the only font I have found with this bit set;

// although note that MS WordPad and windows FF browser uses the big line-height from winAscent

// but Word 2007 get it right

if ($use_typo_metrics && $this->typoAscender) {

$this->ascent = $this->typoAscender;

$this->descent = $this->typoDescender;

$this->lineGap = $this->typoLineGap;

}

}

// post - PostScript table

$this->seek_table('post');

if ($debug) {

$ver_maj = $this->read_ushort();

if ($ver_maj < 1 || $ver_maj > 4) {

throw new \Mpdf\Exception\FontException(sprintf('Error loading font: Unknown post table version %s', $ver_maj));

}

} else {

$this->skip(4);

}

$this->italicAngle = $this->read_short() + $this->read_ushort() / 65536.0;

$this->underlinePosition = $this->read_short() * $scale;

$this->underlineThickness = $this->read_short() * $scale;

$isFixedPitch = $this->read_ulong();

$this->flags = 4;

if ($this->italicAngle != 0) {

$this->flags |= 64;

}

if ($usWeightClass >= 600) {

$this->flags |= 262144;

}

if ($isFixedPitch) {

$this->flags |= 1;

}

// hhea - Horizontal header table

$this->seek_table('hhea');

if ($debug) {

$ver_maj = $this->read_ushort();

if ($ver_maj != 1) {

throw new \Mpdf\Exception\FontException(sprintf('Error loading font: Unknown hhea table version %s', $ver_maj));

}

$this->skip(28);

} else {

$this->skip(32);

}

$metricDataFormat = $this->read_ushort();

if ($metricDataFormat != 0) {

throw new \Mpdf\Exception\FontException(sprintf('Error loading font: Unknown horizontal metric data format "%s"', $metricDataFormat));

}

$numberOfHMetrics = $this->read_ushort();

if ($numberOfHMetrics == 0) {

throw new \Mpdf\Exception\FontException('Error loading font: Number of horizontal metrics is 0');

}

// maxp - Maximum profile table