1460 lines
42 KiB
PHP
1460 lines
42 KiB
PHP
<?php
|
|
mb_internal_encoding('utf-8'); // @important
|
|
|
|
|
|
class WOE_FPDF_TT_Font_File
|
|
{
|
|
private $gfWords = 0b1;
|
|
private $gfScale = 0b1000;
|
|
private $gfMore = 0b100000;
|
|
private $gfXYScale = 0b1000000;
|
|
private $gfTwoByTwo = 0b10000000;
|
|
|
|
// Define the value used in the "head" table of a created TTF file
|
|
// 0x74727565 "true" for Mac
|
|
// 0x00010000 for Windows
|
|
// Either seems to work for a font embedded in a PDF file
|
|
// when read by Adobe Reader on a Windows PC(!)
|
|
private $ttf_mac_header = false;
|
|
|
|
private $maxUni;
|
|
private $_pos;
|
|
private $numTables;
|
|
private $searchRange;
|
|
private $entrySelector;
|
|
private $rangeShift;
|
|
private $tables;
|
|
private $otables;
|
|
private $filename;
|
|
private $fh;
|
|
private $glyphPos;
|
|
private $charToGlyph;
|
|
private $codeToGlyph;
|
|
private $ascent;
|
|
private $descent;
|
|
private $name;
|
|
private $familyName;
|
|
private $styleName;
|
|
private $fullName;
|
|
private $uniqueFontID;
|
|
private $unitsPerEm;
|
|
private $bbox;
|
|
private $capHeight;
|
|
private $stemV;
|
|
private $italicAngle;
|
|
private $flags;
|
|
private $underlinePosition;
|
|
private $underlineThickness;
|
|
private $charWidths;
|
|
private $defaultWidth;
|
|
private $maxStrLenRead;
|
|
|
|
private $TTCFonts, $version, $sFamilyClass, $sFamilySubClass, $maxUniChar, $glyphdata;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->maxStrLenRead = 200000; // Maximum size of glyf table to read in as string (otherwise reads each glyph from file)
|
|
}
|
|
|
|
public function getMetrics($file)
|
|
{
|
|
if (!file_exists($file)) {
|
|
throw new \RuntimeException('Can\'t open file ' . $file);
|
|
}
|
|
|
|
$this->filename = $file;
|
|
$this->fh = fopen($file, 'rb');
|
|
$this->_pos = 0;
|
|
$this->charWidths = '';
|
|
$this->glyphPos = array();
|
|
$this->charToGlyph = array();
|
|
$this->tables = array();
|
|
$this->otables = array();
|
|
$this->ascent = 0;
|
|
$this->descent = 0;
|
|
$this->TTCFonts = array();
|
|
$this->version = $version = $this->read_ulong();
|
|
|
|
if ($version === 0x4F54544F) {
|
|
throw new \RuntimeException('Postscript outlines are not supported');
|
|
}
|
|
|
|
if ($version === 0x74746366) {
|
|
throw new \RuntimeException('ERROR - TrueType Fonts Collections not supported');
|
|
}
|
|
|
|
if (!in_array($version, array(0x00010000, 0x74727565))) {
|
|
throw new \RuntimeException("Not a TrueType font: version=" . $version);
|
|
}
|
|
|
|
$this->readTableDirectory();
|
|
$this->extractInfo();
|
|
fclose($this->fh);
|
|
}
|
|
|
|
public function getCharWidths()
|
|
{
|
|
return $this->charWidths;
|
|
}
|
|
|
|
private function readTableDirectory()
|
|
{
|
|
$this->numTables = $this->read_ushort();
|
|
$this->searchRange = $this->read_ushort();
|
|
$this->entrySelector = $this->read_ushort();
|
|
$this->rangeShift = $this->read_ushort();
|
|
$this->tables = array();
|
|
for ($i = 0; $i < $this->numTables; $i++) {
|
|
$record = array();
|
|
$record['tag'] = $this->read_tag();
|
|
$record['checksum'] = array($this->read_ushort(), $this->read_ushort());
|
|
$record['offset'] = $this->read_ulong();
|
|
$record['length'] = $this->read_ulong();
|
|
$this->tables[$record['tag']] = $record;
|
|
}
|
|
}
|
|
|
|
|
|
private function sub32($x, $y)
|
|
{
|
|
$xlo = $x[1];
|
|
$xhi = $x[0];
|
|
$ylo = $y[1];
|
|
$yhi = $y[0];
|
|
if ($ylo > $xlo) {
|
|
$xlo += 1 << 16;
|
|
$yhi += 1;
|
|
}
|
|
$reslo = $xlo - $ylo;
|
|
if ($yhi > $xhi) {
|
|
$xhi += 1 << 16;
|
|
}
|
|
$reshi = $xhi - $yhi;
|
|
$reshi = $reshi & 0xFFFF;
|
|
return array($reshi, $reslo);
|
|
}
|
|
|
|
private function calcChecksum($data)
|
|
{
|
|
if (strlen($data) % 4) {
|
|
$data .= str_repeat("\0", (4 - (strlen($data) % 4)));
|
|
}
|
|
$hi = 0x0000;
|
|
$lo = 0x0000;
|
|
for ($i = 0; $i < strlen($data); $i += 4) {
|
|
$hi += (ord($data[$i]) << 8) + ord($data[$i + 1]);
|
|
$lo += (ord($data[$i + 2]) << 8) + ord($data[$i + 3]);
|
|
$hi += $lo >> 16;
|
|
$lo = $lo & 0xFFFF;
|
|
$hi = $hi & 0xFFFF;
|
|
}
|
|
return array($hi, $lo);
|
|
}
|
|
|
|
private function get_table_pos($tag)
|
|
{
|
|
$offset = $this->tables[$tag]['offset'];
|
|
$length = $this->tables[$tag]['length'];
|
|
return array($offset, $length);
|
|
}
|
|
|
|
private function seek($pos)
|
|
{
|
|
$this->_pos = $pos;
|
|
fseek($this->fh, $this->_pos);
|
|
}
|
|
|
|
private function skip($delta)
|
|
{
|
|
$this->_pos = $this->_pos + $delta;
|
|
fseek($this->fh, $this->_pos);
|
|
}
|
|
|
|
private 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;
|
|
}
|
|
|
|
private function read_tag()
|
|
{
|
|
$this->_pos += 4;
|
|
return fread($this->fh, 4);
|
|
}
|
|
|
|
private 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;
|
|
}
|
|
|
|
private function unpack_short($s)
|
|
{
|
|
$a = (ord($s[0]) << 8) + ord($s[1]);
|
|
if ($a & (1 << 15)) {
|
|
$a = ($a - (1 << 16));
|
|
}
|
|
return $a;
|
|
}
|
|
|
|
private function read_ushort()
|
|
{
|
|
$this->_pos += 2;
|
|
$s = fread($this->fh, 2);
|
|
return (ord($s[0]) << 8) + ord($s[1]);
|
|
}
|
|
|
|
private 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
|
|
}
|
|
|
|
private function get_ushort($pos)
|
|
{
|
|
fseek($this->fh, $pos);
|
|
$s = fread($this->fh, 2);
|
|
return (ord($s[0]) << 8) + ord($s[1]);
|
|
}
|
|
|
|
private 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
|
|
}
|
|
|
|
private function pack_short($val)
|
|
{
|
|
if ($val < 0) {
|
|
$val = abs($val);
|
|
$val = ~$val;
|
|
$val += 1;
|
|
}
|
|
return pack("n", $val);
|
|
}
|
|
|
|
private function splice($stream, $offset, $value)
|
|
{
|
|
return substr($stream, 0, $offset) . $value . substr($stream, $offset + strlen($value));
|
|
}
|
|
|
|
private function _set_ushort($stream, $offset, $value)
|
|
{
|
|
$up = pack("n", $value);
|
|
return $this->splice($stream, $offset, $up);
|
|
}
|
|
|
|
private 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);
|
|
}
|
|
|
|
private function get_chunk($pos, $length)
|
|
{
|
|
fseek($this->fh, $pos);
|
|
if ($length < 1) {
|
|
return '';
|
|
}
|
|
return (fread($this->fh, $length));
|
|
}
|
|
|
|
private function get_table($tag)
|
|
{
|
|
list($pos, $length) = $this->get_table_pos($tag);
|
|
if ($length == 0) {
|
|
throw new \RuntimeException('Truetype font (' . $this->filename . '): error reading table: ' . $tag);
|
|
}
|
|
fseek($this->fh, $pos);
|
|
return (fread($this->fh, $length));
|
|
}
|
|
|
|
private function add($tag, $data)
|
|
{
|
|
if ($tag == 'head') {
|
|
$data = $this->splice($data, 8, "\0\0\0\0");
|
|
}
|
|
$this->otables[$tag] = $data;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
private function extractInfo()
|
|
{
|
|
///////////////////////////////////
|
|
// name - Naming table
|
|
///////////////////////////////////
|
|
$this->sFamilyClass = 0;
|
|
$this->sFamilySubClass = 0;
|
|
|
|
$name_offset = $this->seek_table('name');
|
|
$format = $this->read_ushort();
|
|
if ($format != 0)
|
|
throw new \RuntimeException('Unknown name table format ' . $format);
|
|
$numRecords = $this->read_ushort();
|
|
$string_data_offset = $name_offset + $this->read_ushort();
|
|
$names = array(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 \RuntimeException("PostScript name is UTF-16BE string of odd length");
|
|
$length /= 2;
|
|
$N = '';
|
|
while ($length > 0) {
|
|
$char = $this->read_ushort();
|
|
$N .= (chr($char));
|
|
$length -= 1;
|
|
}
|
|
$this->_pos = $opos;
|
|
$this->seek($opos);
|
|
} else if ($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];
|
|
else if ($names[4])
|
|
$psName = preg_replace('/ /', '-', $names[4]);
|
|
else if ($names[1])
|
|
$psName = preg_replace('/ /', '-', $names[1]);
|
|
else
|
|
$psName = '';
|
|
if (!$psName)
|
|
throw new \RuntimeException("Could not find PostScript font name");
|
|
$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 ($names[6]) {
|
|
$this->fullName = $names[6];
|
|
}
|
|
|
|
///////////////////////////////////
|
|
// head - Font header table
|
|
///////////////////////////////////
|
|
$this->seek_table("head");
|
|
$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 = array(($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 \RuntimeException('Unknown glyph data format ' . $glyphDataFormat);
|
|
|
|
///////////////////////////////////
|
|
// hhea metrics table
|
|
///////////////////////////////////
|
|
// ttf2t1 seems to use this value rather than the one in OS/2 - so put in for compatibility
|
|
if (isset($this->tables["hhea"])) {
|
|
$this->seek_table("hhea");
|
|
$this->skip(4);
|
|
$hheaAscender = $this->read_short();
|
|
$hheaDescender = $this->read_short();
|
|
$this->ascent = ($hheaAscender * $scale);
|
|
$this->descent = ($hheaDescender * $scale);
|
|
}
|
|
|
|
///////////////////////////////////
|
|
// OS/2 - OS/2 and Windows metrics table
|
|
///////////////////////////////////
|
|
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) {
|
|
throw new \RuntimeException('ERROR - Font file ' . $this->filename . ' cannot be embedded due to copyright restrictions.');
|
|
}
|
|
$this->skip(20);
|
|
$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->skip(26);
|
|
$sTypoAscender = $this->read_short();
|
|
$sTypoDescender = $this->read_short();
|
|
if (!$this->ascent) $this->ascent = ($sTypoAscender * $scale);
|
|
if (!$this->descent) $this->descent = ($sTypoDescender * $scale);
|
|
if ($version > 1) {
|
|
$this->skip(16);
|
|
$sCapHeight = $this->read_short();
|
|
$this->capHeight = ($sCapHeight * $scale);
|
|
} else {
|
|
$this->capHeight = $this->ascent;
|
|
}
|
|
} else {
|
|
$usWeightClass = 500;
|
|
if (!$this->ascent) $this->ascent = ($yMax * $scale);
|
|
if (!$this->descent) $this->descent = ($yMin * $scale);
|
|
$this->capHeight = $this->ascent;
|
|
}
|
|
$this->stemV = 50 + (int) pow($usWeightClass / 65.0, 2);
|
|
|
|
///////////////////////////////////
|
|
// post - PostScript table
|
|
///////////////////////////////////
|
|
$this->seek_table('post');
|
|
$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 = $this->flags | 64;
|
|
if ($usWeightClass >= 600)
|
|
$this->flags = $this->flags | 262144;
|
|
if ($isFixedPitch)
|
|
$this->flags = $this->flags | 1;
|
|
|
|
///////////////////////////////////
|
|
// hhea - Horizontal header table
|
|
///////////////////////////////////
|
|
$this->seek_table("hhea");
|
|
$this->skip(32);
|
|
$metricDataFormat = $this->read_ushort();
|
|
if ($metricDataFormat != 0)
|
|
throw new \RuntimeException('Unknown horizontal metric data format ' . $metricDataFormat);
|
|
$numberOfHMetrics = $this->read_ushort();
|
|
if ($numberOfHMetrics == 0)
|
|
throw new \RuntimeException('Number of horizontal metrics is 0');
|
|
|
|
///////////////////////////////////
|
|
// maxp - Maximum profile table
|
|
///////////////////////////////////
|
|
$this->seek_table("maxp");
|
|
$this->skip(4);
|
|
$numGlyphs = $this->read_ushort();
|
|
|
|
|
|
///////////////////////////////////
|
|
// 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) || $platformID == 0) { // Microsoft, Unicode
|
|
$format = $this->get_ushort($cmap_offset + $offset);
|
|
if ($format == 4) {
|
|
if (!$unicode_cmap_offset) $unicode_cmap_offset = $cmap_offset + $offset;
|
|
break;
|
|
}
|
|
}
|
|
$this->seek($save_pos);
|
|
}
|
|
if (!$unicode_cmap_offset)
|
|
throw new \RuntimeException('Font (' . $this->filename . ') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
|
|
|
|
|
|
$glyphToChar = array();
|
|
$charToGlyph = array();
|
|
$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);
|
|
|
|
///////////////////////////////////
|
|
// hmtx - Horizontal metrics table
|
|
///////////////////////////////////
|
|
$this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
|
|
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
public function makeSubset($file, &$subset)
|
|
{
|
|
if (!file_exists($file)) {
|
|
throw new \RuntimeException('Can\'t open file to create subset');
|
|
}
|
|
|
|
$this->filename = $file;
|
|
$this->fh = fopen($file, 'rb');
|
|
$this->_pos = 0;
|
|
$this->charWidths = '';
|
|
$this->glyphPos = array();
|
|
$this->charToGlyph = array();
|
|
$this->tables = array();
|
|
$this->otables = array();
|
|
$this->ascent = 0;
|
|
$this->descent = 0;
|
|
$this->skip(4);
|
|
$this->maxUni = 0;
|
|
$this->readTableDirectory();
|
|
|
|
|
|
///////////////////////////////////
|
|
// head - Font header table
|
|
///////////////////////////////////
|
|
$this->seek_table("head");
|
|
$this->skip(50);
|
|
$indexToLocFormat = $this->read_ushort();
|
|
$glyphDataFormat = $this->read_ushort();
|
|
|
|
///////////////////////////////////
|
|
// hhea - Horizontal header table
|
|
///////////////////////////////////
|
|
$this->seek_table("hhea");
|
|
$this->skip(32);
|
|
$metricDataFormat = $this->read_ushort();
|
|
$orignHmetrics = $numberOfHMetrics = $this->read_ushort();
|
|
|
|
///////////////////////////////////
|
|
// maxp - Maximum profile table
|
|
///////////////////////////////////
|
|
$this->seek_table("maxp");
|
|
$this->skip(4);
|
|
$numGlyphs = $this->read_ushort();
|
|
|
|
|
|
///////////////////////////////////
|
|
// 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) || $platformID == 0) { // Microsoft, Unicode
|
|
$format = $this->get_ushort($cmap_offset + $offset);
|
|
if ($format == 4) {
|
|
$unicode_cmap_offset = $cmap_offset + $offset;
|
|
break;
|
|
}
|
|
}
|
|
$this->seek($save_pos);
|
|
}
|
|
|
|
if (!$unicode_cmap_offset)
|
|
throw new \RuntimeException('Font (' . $this->filename . ') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)');
|
|
|
|
|
|
$glyphToChar = array();
|
|
$charToGlyph = array();
|
|
$this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph);
|
|
|
|
$this->charToGlyph = $charToGlyph;
|
|
|
|
///////////////////////////////////
|
|
// hmtx - Horizontal metrics table
|
|
///////////////////////////////////
|
|
$scale = 1; // not used
|
|
$this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale);
|
|
|
|
///////////////////////////////////
|
|
// loca - Index to location
|
|
///////////////////////////////////
|
|
$this->getLOCA($indexToLocFormat, $numGlyphs);
|
|
|
|
$subsetglyphs = array(0 => 0);
|
|
$subsetCharToGlyph = array();
|
|
foreach ($subset AS $code) {
|
|
if (isset($this->charToGlyph[$code])) {
|
|
$subsetglyphs[$this->charToGlyph[$code]] = $code; // Old Glyph ID => Unicode
|
|
$subsetCharToGlyph[$code] = $this->charToGlyph[$code]; // Unicode to old GlyphID
|
|
|
|
}
|
|
$this->maxUni = max($this->maxUni, $code);
|
|
}
|
|
|
|
list($start, $dummy) = $this->get_table_pos('glyf');
|
|
|
|
$glyphSet = array();
|
|
ksort($subsetglyphs);
|
|
$n = 0;
|
|
$fsLastCharIndex = 0; // maximum Unicode index (character code) in this font, according to the cmap subtable for platform ID 3 and platform- specific encoding ID 0 or 1.
|
|
foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
|
|
$fsLastCharIndex = max($fsLastCharIndex, $uni);
|
|
$glyphSet[$originalGlyphIdx] = $n; // old glyphID to new glyphID
|
|
$n++;
|
|
}
|
|
|
|
ksort($subsetCharToGlyph);
|
|
foreach ($subsetCharToGlyph AS $uni => $originalGlyphIdx) {
|
|
$codeToGlyph[$uni] = $glyphSet[$originalGlyphIdx];
|
|
}
|
|
$this->codeToGlyph = $codeToGlyph;
|
|
|
|
ksort($subsetglyphs);
|
|
foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
|
|
$this->getGlyphs($originalGlyphIdx, $start, $glyphSet, $subsetglyphs);
|
|
}
|
|
|
|
$numGlyphs = $numberOfHMetrics = count($subsetglyphs);
|
|
|
|
//tables copied from the original
|
|
$tags = array('name');
|
|
foreach ($tags AS $tag) {
|
|
$this->add($tag, $this->get_table($tag));
|
|
}
|
|
$tags = array('cvt ', 'fpgm', 'prep', 'gasp');
|
|
foreach ($tags AS $tag) {
|
|
if (isset($this->tables[$tag])) {
|
|
$this->add($tag, $this->get_table($tag));
|
|
}
|
|
}
|
|
|
|
// post - PostScript
|
|
$opost = $this->get_table('post');
|
|
$post = "\x00\x03\x00\x00" . substr($opost, 4, 12) . "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
|
|
$this->add('post', $post);
|
|
|
|
// Sort CID2GID map into segments of contiguous codes
|
|
ksort($codeToGlyph);
|
|
unset($codeToGlyph[0]);
|
|
//unset($codeToGlyph[65535]);
|
|
$rangeid = 0;
|
|
$range = array();
|
|
$prevcid = -2;
|
|
$prevglidx = -1;
|
|
// for each character
|
|
foreach ($codeToGlyph as $cid => $glidx) {
|
|
if ($cid == ($prevcid + 1) && $glidx == ($prevglidx + 1)) {
|
|
$range[$rangeid][] = $glidx;
|
|
} else {
|
|
// new range
|
|
$rangeid = $cid;
|
|
$range[$rangeid] = array();
|
|
$range[$rangeid][] = $glidx;
|
|
}
|
|
$prevcid = $cid;
|
|
$prevglidx = $glidx;
|
|
}
|
|
|
|
// cmap - Character to glyph mapping - Format 4 (MS / )
|
|
$segCount = count($range) + 1; // + 1 Last segment has missing character 0xFFFF
|
|
$searchRange = 1;
|
|
$entrySelector = 0;
|
|
while ($searchRange * 2 <= $segCount) {
|
|
$searchRange = $searchRange * 2;
|
|
$entrySelector = $entrySelector + 1;
|
|
}
|
|
$searchRange = $searchRange * 2;
|
|
$rangeShift = $segCount * 2 - $searchRange;
|
|
$length = 16 + (8 * $segCount) + ($numGlyphs + 1);
|
|
$cmap = array(0, 1, // Index : version, number of encoding subtables
|
|
3, 1, // Encoding Subtable : platform (MS=3), encoding (Unicode)
|
|
0, 12, // Encoding Subtable : offset (hi,lo)
|
|
4, $length, 0, // Format 4 Mapping subtable: format, length, language
|
|
$segCount * 2,
|
|
$searchRange,
|
|
$entrySelector,
|
|
$rangeShift);
|
|
|
|
// endCode(s)
|
|
foreach ($range AS $start => $subrange) {
|
|
$endCode = $start + (count($subrange) - 1);
|
|
$cmap[] = $endCode; // endCode(s)
|
|
}
|
|
$cmap[] = 0xFFFF; // endCode of last Segment
|
|
$cmap[] = 0; // reservedPad
|
|
|
|
// startCode(s)
|
|
foreach ($range AS $start => $subrange) {
|
|
$cmap[] = $start; // startCode(s)
|
|
}
|
|
$cmap[] = 0xFFFF; // startCode of last Segment
|
|
// idDelta(s)
|
|
foreach ($range AS $start => $subrange) {
|
|
$idDelta = -($start - $subrange[0]);
|
|
$n += count($subrange);
|
|
$cmap[] = $idDelta; // idDelta(s)
|
|
}
|
|
$cmap[] = 1; // idDelta of last Segment
|
|
// idRangeOffset(s)
|
|
foreach ($range AS $subrange) {
|
|
$cmap[] = 0; // idRangeOffset[segCount] Offset in bytes to glyph indexArray, or 0
|
|
|
|
}
|
|
$cmap[] = 0; // idRangeOffset of last Segment
|
|
foreach ($range AS $subrange) {
|
|
foreach ($subrange AS $glidx) {
|
|
$cmap[] = $glidx;
|
|
}
|
|
}
|
|
$cmap[] = 0; // Mapping for last character
|
|
$cmapstr = '';
|
|
foreach ($cmap AS $cm) {
|
|
$cmapstr .= pack("n", $cm);
|
|
}
|
|
$this->add('cmap', $cmapstr);
|
|
|
|
|
|
// glyf - Glyph data
|
|
list($glyfOffset, $glyfLength) = $this->get_table_pos('glyf');
|
|
if ($glyfLength < $this->maxStrLenRead) {
|
|
$glyphData = $this->get_table('glyf');
|
|
}
|
|
|
|
$offsets = array();
|
|
$glyf = '';
|
|
$pos = 0;
|
|
|
|
$hmtxstr = '';
|
|
$xMinT = 0;
|
|
$yMinT = 0;
|
|
$xMaxT = 0;
|
|
$yMaxT = 0;
|
|
$advanceWidthMax = 0;
|
|
$minLeftSideBearing = 0;
|
|
$minRightSideBearing = 0;
|
|
$xMaxExtent = 0;
|
|
$maxPoints = 0; // points in non-compound glyph
|
|
$maxContours = 0; // contours in non-compound glyph
|
|
$maxComponentPoints = 0; // points in compound glyph
|
|
$maxComponentContours = 0; // contours in compound glyph
|
|
$maxComponentElements = 0; // number of glyphs referenced at top level
|
|
$maxComponentDepth = 0; // levels of recursion, set to 0 if font has only simple glyphs
|
|
$this->glyphdata = array();
|
|
|
|
foreach ($subsetglyphs AS $originalGlyphIdx => $uni) {
|
|
// hmtx - Horizontal Metrics
|
|
$hm = $this->getHMetric($orignHmetrics, $originalGlyphIdx);
|
|
$hmtxstr .= $hm;
|
|
|
|
$offsets[] = $pos;
|
|
$glyphPos = $this->glyphPos[$originalGlyphIdx];
|
|
$glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
|
|
if ($glyfLength < $this->maxStrLenRead) {
|
|
$data = substr($glyphData, $glyphPos, $glyphLen);
|
|
} else {
|
|
if ($glyphLen > 0) $data = $this->get_chunk($glyfOffset + $glyphPos, $glyphLen);
|
|
else $data = '';
|
|
}
|
|
|
|
if ($glyphLen > 0) {
|
|
$up = unpack("n", substr($data, 0, 2));
|
|
}
|
|
|
|
if ($glyphLen > 2 && ($up[1] & (1 << 15))) { // If number of contours <= -1 i.e. composiste glyph
|
|
$pos_in_glyph = 10;
|
|
$flags = $this->gfMore;
|
|
$nComponentElements = 0;
|
|
while ($flags & $this->gfMore) {
|
|
$nComponentElements += 1; // number of glyphs referenced at top level
|
|
$up = unpack("n", substr($data, $pos_in_glyph, 2));
|
|
$flags = $up[1];
|
|
$up = unpack("n", substr($data, $pos_in_glyph + 2, 2));
|
|
$glyphIdx = $up[1];
|
|
$this->glyphdata[$originalGlyphIdx]['compGlyphs'][] = $glyphIdx;
|
|
$data = $this->_set_ushort($data, $pos_in_glyph + 2, $glyphSet[$glyphIdx]);
|
|
$pos_in_glyph += 4;
|
|
if ($flags & $this->gfWords) {
|
|
$pos_in_glyph += 4;
|
|
} else {
|
|
$pos_in_glyph += 2;
|
|
}
|
|
if ($flags & $this->gfScale) {
|
|
$pos_in_glyph += 2;
|
|
} else if ($flags & $this->gfXYScale) {
|
|
$pos_in_glyph += 4;
|
|
} else if ($flags & $this->gfTwoByTwo) {
|
|
$pos_in_glyph += 8;
|
|
}
|
|
}
|
|
$maxComponentElements = max($maxComponentElements, $nComponentElements);
|
|
}
|
|
|
|
$glyf .= $data;
|
|
$pos += $glyphLen;
|
|
if ($pos % 4 != 0) {
|
|
$padding = 4 - ($pos % 4);
|
|
$glyf .= str_repeat("\0", $padding);
|
|
$pos += $padding;
|
|
}
|
|
}
|
|
|
|
$offsets[] = $pos;
|
|
$this->add('glyf', $glyf);
|
|
|
|
// hmtx - Horizontal Metrics
|
|
$this->add('hmtx', $hmtxstr);
|
|
|
|
// loca - Index to location
|
|
$locastr = '';
|
|
if ((($pos + 1) >> 1) > 0xFFFF) {
|
|
$indexToLocFormat = 1; // long format
|
|
foreach ($offsets AS $offset) {
|
|
$locastr .= pack("N", $offset);
|
|
}
|
|
} else {
|
|
$indexToLocFormat = 0; // short format
|
|
foreach ($offsets AS $offset) {
|
|
$locastr .= pack("n", ($offset / 2));
|
|
}
|
|
}
|
|
$this->add('loca', $locastr);
|
|
|
|
// head - Font header
|
|
$head = $this->get_table('head');
|
|
$head = $this->_set_ushort($head, 50, $indexToLocFormat);
|
|
$this->add('head', $head);
|
|
|
|
|
|
// hhea - Horizontal Header
|
|
$hhea = $this->get_table('hhea');
|
|
$hhea = $this->_set_ushort($hhea, 34, $numberOfHMetrics);
|
|
$this->add('hhea', $hhea);
|
|
|
|
// maxp - Maximum Profile
|
|
$maxp = $this->get_table('maxp');
|
|
$maxp = $this->_set_ushort($maxp, 4, $numGlyphs);
|
|
$this->add('maxp', $maxp);
|
|
|
|
|
|
// OS/2 - OS/2
|
|
$os2 = $this->get_table('OS/2');
|
|
$this->add('OS/2', $os2);
|
|
|
|
fclose($this->fh);
|
|
|
|
// Put the TTF file together
|
|
$stm = '';
|
|
$this->endTTFile($stm);
|
|
return $stm;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
// Recursively get composite glyph data
|
|
private function getGlyphData($originalGlyphIdx, &$maxdepth, &$depth, &$points, &$contours)
|
|
{
|
|
$depth++;
|
|
$maxdepth = max($maxdepth, $depth);
|
|
if (count($this->glyphdata[$originalGlyphIdx]['compGlyphs'])) {
|
|
foreach ($this->glyphdata[$originalGlyphIdx]['compGlyphs'] AS $glyphIdx) {
|
|
$this->getGlyphData($glyphIdx, $maxdepth, $depth, $points, $contours);
|
|
}
|
|
} else if (($this->glyphdata[$originalGlyphIdx]['nContours'] > 0) && $depth > 0) { // simple
|
|
$contours += $this->glyphdata[$originalGlyphIdx]['nContours'];
|
|
$points += $this->glyphdata[$originalGlyphIdx]['nPoints'];
|
|
}
|
|
$depth--;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
// Recursively get composite glyphs
|
|
private function getGlyphs($originalGlyphIdx, &$start, &$glyphSet, &$subsetglyphs)
|
|
{
|
|
$glyphPos = $this->glyphPos[$originalGlyphIdx];
|
|
$glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos;
|
|
if (!$glyphLen) {
|
|
return;
|
|
}
|
|
$this->seek($start + $glyphPos);
|
|
$numberOfContours = $this->read_short();
|
|
if ($numberOfContours < 0) {
|
|
$this->skip(8);
|
|
$flags = $this->gfMore;
|
|
while ($flags & $this->gfMore) {
|
|
$flags = $this->read_ushort();
|
|
$glyphIdx = $this->read_ushort();
|
|
if (!isset($glyphSet[$glyphIdx])) {
|
|
$glyphSet[$glyphIdx] = count($subsetglyphs); // old glyphID to new glyphID
|
|
$subsetglyphs[$glyphIdx] = true;
|
|
}
|
|
$savepos = ftell($this->fh);
|
|
$this->getGlyphs($glyphIdx, $start, $glyphSet, $subsetglyphs);
|
|
$this->seek($savepos);
|
|
if ($flags & $this->gfWords)
|
|
$this->skip(4);
|
|
else
|
|
$this->skip(2);
|
|
if ($flags & $this->gfScale)
|
|
$this->skip(2);
|
|
else if ($flags & $this->gfXYScale)
|
|
$this->skip(4);
|
|
else if ($flags & $this->gfTwoByTwo)
|
|
$this->skip(8);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
private function getHMTX($numberOfHMetrics, $numGlyphs, &$glyphToChar, $scale)
|
|
{
|
|
$start = $this->seek_table("hmtx");
|
|
$aw = 0;
|
|
$this->charWidths = str_pad('', 256 * 256 * 2, "\x00");
|
|
$nCharWidths = 0;
|
|
if (($numberOfHMetrics * 4) < $this->maxStrLenRead) {
|
|
$data = $this->get_chunk($start, ($numberOfHMetrics * 4));
|
|
$arr = unpack("n*", $data);
|
|
} else {
|
|
$this->seek($start);
|
|
}
|
|
for ($glyph = 0; $glyph < $numberOfHMetrics; $glyph++) {
|
|
|
|
if (($numberOfHMetrics * 4) < $this->maxStrLenRead) {
|
|
$aw = $arr[($glyph * 2) + 1];
|
|
} else {
|
|
$aw = $this->read_ushort();
|
|
$lsb = $this->read_ushort();
|
|
}
|
|
if (isset($glyphToChar[$glyph]) || $glyph == 0) {
|
|
|
|
if ($aw >= (1 << 15)) {
|
|
$aw = 0;
|
|
} // 1.03 Some (arabic) fonts have -ve values for width
|
|
// although should be unsigned value - comes out as e.g. 65108 (intended -50)
|
|
if ($glyph == 0) {
|
|
$this->defaultWidth = $scale * $aw;
|
|
continue;
|
|
}
|
|
foreach ($glyphToChar[$glyph] AS $char) {
|
|
if ($char != 0 && $char != 65535) {
|
|
$w = intval(round($scale * $aw));
|
|
if ($w == 0) {
|
|
$w = 65535;
|
|
}
|
|
if ($char < 196608) {
|
|
$this->charWidths[$char * 2] = chr($w >> 8);
|
|
$this->charWidths[$char * 2 + 1] = chr($w & 0xFF);
|
|
$nCharWidths++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$data = $this->get_chunk(($start + $numberOfHMetrics * 4), ($numGlyphs * 2));
|
|
$arr = unpack("n*", $data);
|
|
$diff = $numGlyphs - $numberOfHMetrics;
|
|
for ($pos = 0; $pos < $diff; $pos++) {
|
|
$glyph = $pos + $numberOfHMetrics;
|
|
if (isset($glyphToChar[$glyph])) {
|
|
foreach ($glyphToChar[$glyph] AS $char) {
|
|
if ($char != 0 && $char != 65535) {
|
|
$w = intval(round($scale * $aw));
|
|
if ($w == 0) {
|
|
$w = 65535;
|
|
}
|
|
if ($char < 196608) {
|
|
$this->charWidths[$char * 2] = chr($w >> 8);
|
|
$this->charWidths[$char * 2 + 1] = chr($w & 0xFF);
|
|
$nCharWidths++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// NB 65535 is a set width of 0
|
|
// First bytes define number of chars in font
|
|
$this->charWidths[0] = chr($nCharWidths >> 8);
|
|
$this->charWidths[1] = chr($nCharWidths & 0xFF);
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getGfWords()
|
|
{
|
|
return $this->gfWords;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getGfScale()
|
|
{
|
|
return $this->gfScale;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getGfMore()
|
|
{
|
|
return $this->gfMore;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getGfXYScale()
|
|
{
|
|
return $this->gfXYScale;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getGfTwoByTwo()
|
|
{
|
|
return $this->gfTwoByTwo;
|
|
}
|
|
|
|
/**
|
|
* @return boolean
|
|
*/
|
|
public function isTtfMacHeader()
|
|
{
|
|
return $this->ttf_mac_header;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getMaxUni()
|
|
{
|
|
return $this->maxUni;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getPos()
|
|
{
|
|
return $this->_pos;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getNumTables()
|
|
{
|
|
return $this->numTables;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getSearchRange()
|
|
{
|
|
return $this->searchRange;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getEntrySelector()
|
|
{
|
|
return $this->entrySelector;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getRangeShift()
|
|
{
|
|
return $this->rangeShift;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getTables()
|
|
{
|
|
return $this->tables;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getOtables()
|
|
{
|
|
return $this->otables;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getFilename()
|
|
{
|
|
return $this->filename;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getFh()
|
|
{
|
|
return $this->fh;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getGlyphPos()
|
|
{
|
|
return $this->glyphPos;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getCharToGlyph()
|
|
{
|
|
return $this->charToGlyph;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getAscent()
|
|
{
|
|
return $this->ascent;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getDescent()
|
|
{
|
|
return $this->descent;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getName()
|
|
{
|
|
return $this->name;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getFamilyName()
|
|
{
|
|
return $this->familyName;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getStyleName()
|
|
{
|
|
return $this->styleName;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getFullName()
|
|
{
|
|
return $this->fullName;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getUniqueFontID()
|
|
{
|
|
return $this->uniqueFontID;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getUnitsPerEm()
|
|
{
|
|
return $this->unitsPerEm;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getBbox()
|
|
{
|
|
return $this->bbox;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getCapHeight()
|
|
{
|
|
return $this->capHeight;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getStemV()
|
|
{
|
|
return $this->stemV;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getItalicAngle()
|
|
{
|
|
return $this->italicAngle;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getFlags()
|
|
{
|
|
return $this->flags;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getUnderlinePosition()
|
|
{
|
|
return $this->underlinePosition;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getUnderlineThickness()
|
|
{
|
|
return $this->underlineThickness;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getDefaultWidth()
|
|
{
|
|
return $this->defaultWidth;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getMaxStrLenRead()
|
|
{
|
|
return $this->maxStrLenRead;
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function getCodeToGlyph()
|
|
{
|
|
return $this->codeToGlyph;
|
|
}
|
|
|
|
private function getHMetric($numberOfHMetrics, $gid)
|
|
{
|
|
$start = $this->seek_table("hmtx");
|
|
if ($gid < $numberOfHMetrics) {
|
|
$this->seek($start + ($gid * 4));
|
|
$hm = fread($this->fh, 4);
|
|
} else {
|
|
$this->seek($start + (($numberOfHMetrics - 1) * 4));
|
|
$hm = fread($this->fh, 2);
|
|
$this->seek($start + ($numberOfHMetrics * 2) + ($gid * 2));
|
|
$hm .= fread($this->fh, 2);
|
|
}
|
|
return $hm;
|
|
}
|
|
|
|
private function getLOCA($indexToLocFormat, $numGlyphs)
|
|
{
|
|
$start = $this->seek_table('loca');
|
|
$this->glyphPos = array();
|
|
if ($indexToLocFormat == 0) {
|
|
$data = $this->get_chunk($start, ($numGlyphs * 2) + 2);
|
|
$arr = unpack("n*", $data);
|
|
for ($n = 0; $n <= $numGlyphs; $n++) {
|
|
$this->glyphPos[] = ($arr[$n + 1] * 2);
|
|
}
|
|
} else if ($indexToLocFormat == 1) {
|
|
$data = $this->get_chunk($start, ($numGlyphs * 4) + 4);
|
|
$arr = unpack("N*", $data);
|
|
for ($n = 0; $n <= $numGlyphs; $n++) {
|
|
$this->glyphPos[] = ($arr[$n + 1]);
|
|
}
|
|
} else
|
|
throw new \RuntimeException('Unknown location table format ' . $indexToLocFormat);
|
|
}
|
|
|
|
|
|
// CMAP Format 4
|
|
private function getCMAP4($unicode_cmap_offset, &$glyphToChar, &$charToGlyph)
|
|
{
|
|
$this->maxUniChar = 0;
|
|
$this->seek($unicode_cmap_offset + 2);
|
|
$length = $this->read_ushort();
|
|
$limit = $unicode_cmap_offset + $length;
|
|
$this->skip(2);
|
|
|
|
$segCount = $this->read_ushort() / 2;
|
|
$this->skip(6);
|
|
$endCount = array();
|
|
for ($i = 0; $i < $segCount; $i++) {
|
|
$endCount[] = $this->read_ushort();
|
|
}
|
|
$this->skip(2);
|
|
$startCount = array();
|
|
for ($i = 0; $i < $segCount; $i++) {
|
|
$startCount[] = $this->read_ushort();
|
|
}
|
|
$idDelta = array();
|
|
for ($i = 0; $i < $segCount; $i++) {
|
|
$idDelta[] = $this->read_short();
|
|
} // ???? was unsigned short
|
|
$idRangeOffset_start = $this->_pos;
|
|
$idRangeOffset = array();
|
|
for ($i = 0; $i < $segCount; $i++) {
|
|
$idRangeOffset[] = $this->read_ushort();
|
|
}
|
|
|
|
for ($n = 0; $n < $segCount; $n++) {
|
|
$endpoint = ($endCount[$n] + 1);
|
|
for ($unichar = $startCount[$n]; $unichar < $endpoint; $unichar++) {
|
|
if ($idRangeOffset[$n] == 0)
|
|
$glyph = ($unichar + $idDelta[$n]) & 0xFFFF;
|
|
else {
|
|
$offset = ($unichar - $startCount[$n]) * 2 + $idRangeOffset[$n];
|
|
$offset = $idRangeOffset_start + 2 * $n + $offset;
|
|
if ($offset >= $limit)
|
|
$glyph = 0;
|
|
else {
|
|
$glyph = $this->get_ushort($offset);
|
|
if ($glyph != 0)
|
|
$glyph = ($glyph + $idDelta[$n]) & 0xFFFF;
|
|
}
|
|
}
|
|
$charToGlyph[$unichar] = $glyph;
|
|
if ($unichar < 196608) {
|
|
$this->maxUniChar = max($unichar, $this->maxUniChar);
|
|
}
|
|
$glyphToChar[$glyph][] = $unichar;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Put the TTF file together
|
|
private function endTTFile(&$stm)
|
|
{
|
|
$stm = '';
|
|
$numTables = count($this->otables);
|
|
$searchRange = 1;
|
|
$entrySelector = 0;
|
|
while ($searchRange * 2 <= $numTables) {
|
|
$searchRange = $searchRange * 2;
|
|
$entrySelector = $entrySelector + 1;
|
|
}
|
|
$searchRange = $searchRange * 16;
|
|
$rangeShift = $numTables * 16 - $searchRange;
|
|
|
|
// Header
|
|
if ($this->ttf_mac_header) {
|
|
$stm .= (pack("Nnnnn", 0x74727565, $numTables, $searchRange, $entrySelector, $rangeShift)); // Mac
|
|
} else {
|
|
$stm .= (pack("Nnnnn", 0x00010000, $numTables, $searchRange, $entrySelector, $rangeShift)); // Windows
|
|
}
|
|
|
|
// Table directory
|
|
$tables = $this->otables;
|
|
|
|
ksort($tables);
|
|
$offset = 12 + $numTables * 16;
|
|
foreach ($tables AS $tag => $data) {
|
|
if ($tag == 'head') {
|
|
$head_start = $offset;
|
|
}
|
|
$stm .= $tag;
|
|
$checksum = $this->calcChecksum($data);
|
|
$stm .= pack("nn", $checksum[0], $checksum[1]);
|
|
$stm .= pack("NN", $offset, strlen($data));
|
|
$paddedLength = (strlen($data) + 3) & ~3;
|
|
$offset = $offset + $paddedLength;
|
|
}
|
|
|
|
// Table data
|
|
foreach ($tables AS $tag => $data) {
|
|
$data .= "\0\0\0";
|
|
$stm .= substr($data, 0, (strlen($data) & ~3));
|
|
}
|
|
|
|
$checksum = $this->calcChecksum($stm);
|
|
$checksum = $this->sub32(array(0xB1B0, 0xAFBA), $checksum);
|
|
$chk = pack("nn", $checksum[0], $checksum[1]);
|
|
$stm = $this->splice($stm, ($head_start + 8), $chk);
|
|
return $stm;
|
|
}
|
|
|
|
|
|
}
|