From 4188f38ad56d7ba2ea46e94403f305243514f80c Mon Sep 17 00:00:00 2001 From: tcit Date: Thu, 24 Jul 2014 15:49:36 +0200 Subject: add pdf and mobi libraries --- inc/3rdparty/libraries/mpdf/classes/ttfontsuni.php | 2065 ++++++++++++++++++++ 1 file changed, 2065 insertions(+) create mode 100644 inc/3rdparty/libraries/mpdf/classes/ttfontsuni.php (limited to 'inc/3rdparty/libraries/mpdf/classes/ttfontsuni.php') diff --git a/inc/3rdparty/libraries/mpdf/classes/ttfontsuni.php b/inc/3rdparty/libraries/mpdf/classes/ttfontsuni.php new file mode 100644 index 00000000..1c93b600 --- /dev/null +++ b/inc/3rdparty/libraries/mpdf/classes/ttfontsuni.php @@ -0,0 +1,2065 @@ + * +* License: LGPL * +* Copyright (c) Ian Back, 2010 * +* This class is based on The ReportLab Open Source PDF library * +* written in Python - http://www.reportlab.com/software/opensource/ * +* together with ideas from the OpenOffice source code and others. * +* This header must be retained in any redistribution or * +* modification of the file. * +* * +*******************************************************************************/ + +// 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(!) +if (!defined('_TTF_MAC_HEADER')) define("_TTF_MAC_HEADER", false); + +// Recalculate correct metadata/profiles when making subset fonts (not SIP/SMP) +// e.g. xMin, xMax, maxNContours +if (!defined('_RECALC_PROFILE')) define("_RECALC_PROFILE", false); + +// TrueType Font Glyph operators +define("GF_WORDS",(1 << 0)); +define("GF_SCALE",(1 << 3)); +define("GF_MORE",(1 << 5)); +define("GF_XYSCALE",(1 << 6)); +define("GF_TWOBYTWO",(1 << 7)); + + + +class TTFontFile { + +var $unAGlyphs; // mPDF 5.4.05 +var $panose; +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 $name; +var $familyName; +var $styleName; +var $fullName; +var $uniqueFontID; +var $unitsPerEm; +var $bbox; +var $capHeight; +var $stemV; +var $italicAngle; +var $flags; +var $underlinePosition; +var $underlineThickness; +var $charWidths; +var $defaultWidth; +var $maxStrLenRead; +var $numTTCFonts; +var $TTCFonts; +var $maxUniChar; +var $kerninfo; + + function TTFontFile() { + $this->maxStrLenRead = 200000; // Maximum size of glyf table to read in as string (otherwise reads each glyph from file) + } + + + function getMetrics($file, $TTCfontID=0, $debug=false, $BMPonly=false, $kerninfo=false, $unAGlyphs=false) { // mPDF 5.4.05 + $this->unAGlyphs = $unAGlyphs; // mPDF 5.4.05 + $this->filename = $file; + $this->fh = fopen($file,'rb') or die('Can\'t open file ' . $file); + $this->_pos = 0; + $this->charWidths = ''; + $this->glyphPos = array(); + $this->charToGlyph = array(); + $this->tables = array(); + $this->otables = array(); + $this->kerninfo = array(); + $this->ascent = 0; + $this->descent = 0; + $this->numTTCFonts = 0; + $this->TTCFonts = array(); + $this->version = $version = $this->read_ulong(); + $this->panose = array(); + if ($version==0x4F54544F) + die("Postscript outlines are not supported"); + if ($version==0x74746366 && !$TTCfontID) + die("ERROR - You must define the TTCfontID for a TrueType Collection in config_fonts.php (". $file.")"); + if (!in_array($version, array(0x00010000,0x74727565)) && !$TTCfontID) + die("Not a TrueType font: version=".$version); + if ($TTCfontID > 0) { + $this->version = $version = $this->read_ulong(); // TTC Header version now + if (!in_array($version, array(0x00010000,0x00020000))) + die("ERROR - Error parsing TrueType Collection: version=".$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, $kerninfo); + 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 = 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; + } + 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) + die(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 += 1; } + $reslo = $xlo-$ylo; + if ($yhi > $xhi) { $xhi += 1 << 16; } + $reshi = $xhi-$yhi; + $reshi = $reshi & 0xFFFF; + return array($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 = $lo & 0xFFFF; + } + return array($hi, $lo); + } + + function get_table_pos($tag) { + $offset = $this->tables[$tag]['offset']; + $length = $this->tables[$tag]['length']; + return array($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 += 1; + } + 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 ''; } + return (fread($this->fh,$length)); + } + + 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, $unAGlyphs=false) { // mPDF 5.4.05 + $this->unAGlyphs = $unAGlyphs; // mPDF 5.4.05 + $this->filename = $file; + $this->fh = fopen($file,'rb') or die('Can\'t open file ' . $file); + $this->_pos = 0; + $this->charWidths = ''; + $this->glyphPos = array(); + $this->charToGlyph = array(); + $this->tables = array(); + $this->numTTCFonts = 0; + $this->TTCFonts = array(); + $this->skip(4); + if ($TTCfontID > 0) { + $this->version = $version = $this->read_ulong(); // TTC Header version now + if (!in_array($version, array(0x00010000,0x00020000))) + die("ERROR - Error parsing TrueType Collection: version=".$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; + } + } + else if ($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 = array(); + $charToGlyph = array(); + $this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph ); + + fclose($this->fh); + return ($charToGlyph); + } + +///////////////////////////////////////////////////////////////////////////////////////// + function getTTCFonts($file) { + $this->filename = $file; + $this->fh = fopen($file,'rb'); + if (!$this->fh) { return ('ERROR - Can\'t open file ' . $file); } + $this->numTTCFonts = 0; + $this->TTCFonts = array(); + $this->version = $version = $this->read_ulong(); + if ($version==0x74746366) { + $this->version = $version = $this->read_ulong(); // TTC Header version now + if (!in_array($version, array(0x00010000,0x00020000))) + return("ERROR - Error parsing TrueType Collection: version=".$version." - " . $file); + } + else { + return("ERROR - Not a TrueType Collection: version=".$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, $kerninfo=false) { + $this->panose = array(); + $this->sFamilyClass = 0; + $this->sFamilySubClass = 0; + /////////////////////////////////// + // name - Naming table + /////////////////////////////////// + $name_offset = $this->seek_table("name"); + $format = $this->read_ushort(); + if ($format != 0 && $format != 1) + die("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) + die("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) + die("Could not find PostScript font name: ".$this->filename); + if ($debug) { + for ($i=0;$i126 || strpos(' [](){}<>/%',$c)!==false) + die("psName=".$psName." contains invalid character ".$c." ie U+".ord(c)); + } + } + $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"); + if ($debug) { + $ver_maj = $this->read_ushort(); + $ver_min = $this->read_ushort(); + if ($ver_maj != 1) + die('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) + die('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 = array(($xMin*$scale), ($yMin*$scale), ($xMax*$scale), ($yMax*$scale)); + $this->skip(3*2); + $indexToLocFormat = $this->read_ushort(); + $glyphDataFormat = $this->read_ushort(); + if ($glyphDataFormat != 0) + die('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) { + global $overrideTTFFontRestriction; + if (!$overrideTTFFontRestriction) die('ERROR - Font file '.$this->filename.' cannot be embedded due to copyright restrictions.'); + $this->restrictedUse = true; + } + $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->panose = array(); + for ($p=0;$ppanose[] = ord($panose[$p]); } + $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 + intval(pow(($usWeightClass / 65.0),2)); + + /////////////////////////////////// + // post - PostScript table + /////////////////////////////////// + $this->seek_table("post"); + if ($debug) { + $ver_maj = $this->read_ushort(); + $ver_min = $this->read_ushort(); + if ($ver_maj <1 || $ver_maj >4) + die('Unknown post table version '.$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 = $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"); + if ($debug) { + $ver_maj = $this->read_ushort(); + $ver_min = $this->read_ushort(); + if ($ver_maj != 1) + die('Unknown hhea table version '.$ver_maj); + $this->skip(28); + } + else { + $this->skip(32); + } + $metricDataFormat = $this->read_ushort(); + if ($metricDataFormat != 0) + die('Unknown horizontal metric data format '.$metricDataFormat); + $numberOfHMetrics = $this->read_ushort(); + if ($numberOfHMetrics == 0) + die('Number of horizontal metrics is 0'); + + /////////////////////////////////// + // maxp - Maximum profile table + /////////////////////////////////// + $this->seek_table("maxp"); + if ($debug) { + $ver_maj = $this->read_ushort(); + $ver_min = $this->read_ushort(); + if ($ver_maj != 1) + die('Unknown maxp table version '.$ver_maj); + } + else { + $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; + if ($BMPonly) break; + } + } + // Microsoft, Unicode Format 12 table HKCS + else if ((($platformID == 3 && $encodingID == 10) || $platformID == 0) && !$BMPonly) { + $format = $this->get_ushort($cmap_offset + $offset); + if ($format == 12) { + $unicode_cmap_offset = $cmap_offset + $offset; + break; + } + } + $this->seek($save_pos ); + } + if (!$unicode_cmap_offset) + die('Font ('.$this->filename .') does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)'); + + + $sipset = false; + $smpset = false; + // Format 12 CMAP does characters above Unicode BMP i.e. some HKCS characters U+20000 and above + if ($format == 12 && !$BMPonly) { + $this->maxUniChar = 0; + $this->seek($unicode_cmap_offset + 4); + $length = $this->read_ulong(); + $limit = $unicode_cmap_offset + $length; + $this->skip(4); + + $nGroups = $this->read_ulong(); + + $glyphToChar = array(); + $charToGlyph = array(); + for($i=0; $i<$nGroups ; $i++) { + $startCharCode = $this->read_ulong(); + $endCharCode = $this->read_ulong(); + $startGlyphCode = $this->read_ulong(); + if (($endCharCode > 0x20000 && $endCharCode < 0x2A6DF) || ($endCharCode > 0x2F800 && $endCharCode < 0x2FA1F)) { + $sipset = true; + } + else if ($endCharCode > 0x10000 && $endCharCode < 0x1FFFF) { + $smpset = true; + } + $offset = 0; + for ($unichar=$startCharCode;$unichar<=$endCharCode;$unichar++) { + $glyph = $startGlyphCode + $offset ; + $offset++; + $charToGlyph[$unichar] = $glyph; + if ($unichar < 196608) { $this->maxUniChar = max($unichar,$this->maxUniChar); } + $glyphToChar[$glyph][] = $unichar; + } + } + } + else { + + $glyphToChar = array(); + $charToGlyph = array(); + $this->getCMAP4($unicode_cmap_offset, $glyphToChar, $charToGlyph ); + + } + $this->sipset = $sipset ; + $this->smpset = $smpset ; + + /////////////////////////////////// + // hmtx - Horizontal metrics table + /////////////////////////////////// + $this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale); + + /////////////////////////////////// + // kern - Kerning pair table + /////////////////////////////////// + if ($kerninfo) { + // Recognises old form of Kerning table - as required by Windows - Format 0 only + $kern_offset = $this->seek_table("kern"); + $version = $this->read_ushort(); + $nTables = $this->read_ushort(); + // subtable header + $sversion = $this->read_ushort(); + $slength = $this->read_ushort(); + $scoverage = $this->read_ushort(); + $format = $scoverage >> 8; + if ($kern_offset && $version==0 && $format==0) { + // Format 0 + $nPairs = $this->read_ushort(); + $this->skip(6); + for ($i=0; $i<$nPairs; $i++) { + $left = $this->read_ushort(); + $right = $this->read_ushort(); + $val = $this->read_short(); + if (count($glyphToChar[$left])==1 && count($glyphToChar[$right])==1) { + if ($left != 32 && $right != 32) { + $this->kerninfo[$glyphToChar[$left][0]][$glyphToChar[$right][0]] = intval($val*$scale); + } + } + } + } + } + } + + +///////////////////////////////////////////////////////////////////////////////////////// + + + function makeSubset($file, &$subset, $TTCfontID=0, $debug=false, $unAGlyphs=false) { // mPDF 5.4.05 + $this->unAGlyphs = $unAGlyphs; // mPDF 5.4.05 + $this->filename = $file; + $this->fh = fopen($file ,'rb') or die('Can\'t open file ' . $file); + $this->_pos = 0; + $this->charWidths = ''; + $this->glyphPos = array(); + $this->charToGlyph = array(); + $this->tables = array(); + $this->otables = array(); + $this->ascent = 0; + $this->descent = 0; + $this->numTTCFonts = 0; + $this->TTCFonts = array(); + $this->skip(4); + $this->maxUni = 0; + if ($TTCfontID > 0) { + $this->version = $version = $this->read_ulong(); // TTC Header version now + if (!in_array($version, array(0x00010000,0x00020000))) + die("ERROR - Error parsing TrueType Collection: version=".$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); + + /////////////////////////////////// + // 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) + die('Font ('.$this->filename .') does not have Unicode cmap (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, 1=>1, 2=>2); + $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 ); + + /////////////////////////////////// + // name - table copied from the original + /////////////////////////////////// + $this->add('name', $this->get_table('name')); + + /////////////////////////////////// + //tables copied from the original + /////////////////////////////////// + $tags = array ('cvt ', 'fpgm', 'prep', 'gasp'); + foreach($tags AS $tag) { + if (isset($this->tables[$tag])) { $this->add($tag, $this->get_table($tag)); } + } + + /////////////////////////////////// + // post - PostScript + /////////////////////////////////// + if (isset($this->tables['post'])) { + $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 table + /////////////////////////////////// + // cmap - Character to glyph mapping + $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, 3, // Index : version, number of encoding subtables + 0, 0, // Encoding Subtable : platform (UNI=0), encoding 0 + 0, 28, // Encoding Subtable : offset (hi,lo) + 0, 3, // Encoding Subtable : platform (UNI=0), encoding 3 + 0, 28, // Encoding Subtable : offset (hi,lo) + 3, 1, // Encoding Subtable : platform (MS=3), encoding 1 + 0, 28, // 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) { + if (_RECALC_PROFILE) { + $xMin = $this->unpack_short(substr($data,2,2)); + $yMin = $this->unpack_short(substr($data,4,2)); + $xMax = $this->unpack_short(substr($data,6,2)); + $yMax = $this->unpack_short(substr($data,8,2)); + $xMinT = min($xMinT,$xMin); + $yMinT = min($yMinT,$yMin); + $xMaxT = max($xMaxT,$xMax); + $yMaxT = max($yMaxT,$yMax); + $aw = $this->unpack_short(substr($hm,0,2)); + $lsb = $this->unpack_short(substr($hm,2,2)); + $advanceWidthMax = max($advanceWidthMax,$aw); + $minLeftSideBearing = min($minLeftSideBearing,$lsb); + $minRightSideBearing = min($minRightSideBearing,($aw - $lsb - ($xMax - $xMin))); + $xMaxExtent = max($xMaxExtent,($lsb + ($xMax - $xMin))); + } + $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 = GF_MORE; + $nComponentElements = 0; + while ($flags & GF_MORE) { + $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 & GF_WORDS) { $pos_in_glyph += 4; } + else { $pos_in_glyph += 2; } + if ($flags & GF_SCALE) { $pos_in_glyph += 2; } + else if ($flags & GF_XYSCALE) { $pos_in_glyph += 4; } + else if ($flags & GF_TWOBYTWO) { $pos_in_glyph += 8; } + } + $maxComponentElements = max($maxComponentElements, $nComponentElements); + } + // Simple Glyph + else if (_RECALC_PROFILE && $glyphLen > 2 && $up[1] < (1 << 15) && $up[1] > 0) { // Number of contours > 0 simple glyph + $nContours = $up[1]; + $this->glyphdata[$originalGlyphIdx]['nContours'] = $nContours; + $maxContours = max($maxContours, $nContours); + + // Count number of points in simple glyph + $pos_in_glyph = 10 + ($nContours * 2) - 2; // Last endContourPoint + $up = unpack("n", substr($data,$pos_in_glyph,2)); + $points = $up[1]+1; + $this->glyphdata[$originalGlyphIdx]['nPoints'] = $points; + $maxPoints = max($maxPoints, $points); + } + + $glyf .= $data; + $pos += $glyphLen; + if ($pos % 4 != 0) { + $padding = 4 - ($pos % 4); + $glyf .= str_repeat("\0",$padding); + $pos += $padding; + } + } + + if (_RECALC_PROFILE) { + foreach($this->glyphdata AS $originalGlyphIdx => $val) { + $maxdepth = $depth = -1; + $points = 0; + $contours = 0; + $this->getGlyphData($originalGlyphIdx, $maxdepth, $depth, $points, $contours) ; + $maxComponentDepth = max($maxComponentDepth , $maxdepth); + $maxComponentPoints = max($maxComponentPoints , $points); + $maxComponentContours = max($maxComponentContours , $contours); + } + } + + + $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); + if (_RECALC_PROFILE) { + $head = $this->_set_short($head, 36, $xMinT); // for all glyph bounding boxes + $head = $this->_set_short($head, 38, $yMinT); // for all glyph bounding boxes + $head = $this->_set_short($head, 40, $xMaxT); // for all glyph bounding boxes + $head = $this->_set_short($head, 42, $yMaxT); // for all glyph bounding boxes + $head[17] = chr($head[17] & ~(1 << 4)); // Unset Bit 4 (as hdmx/LTSH tables not included) + } + $this->add('head', $head); + + + /////////////////////////////////// + // hhea - Horizontal Header + /////////////////////////////////// + $hhea = $this->get_table('hhea'); + $hhea = $this->_set_ushort($hhea, 34, $numberOfHMetrics); + if (_RECALC_PROFILE) { + $hhea = $this->_set_ushort($hhea, 10, $advanceWidthMax); + $hhea = $this->_set_short($hhea, 12, $minLeftSideBearing); + $hhea = $this->_set_short($hhea, 14, $minRightSideBearing); + $hhea = $this->_set_short($hhea, 16, $xMaxExtent); + } + $this->add('hhea', $hhea); + + /////////////////////////////////// + // maxp - Maximum Profile + /////////////////////////////////// + $maxp = $this->get_table('maxp'); + $maxp = $this->_set_ushort($maxp, 4, $numGlyphs); + if (_RECALC_PROFILE) { + $maxp = $this->_set_ushort($maxp, 6, $maxPoints); // points in non-compound glyph + $maxp = $this->_set_ushort($maxp, 8, $maxContours); // contours in non-compound glyph + $maxp = $this->_set_ushort($maxp, 10, $maxComponentPoints); // points in compound glyph + $maxp = $this->_set_ushort($maxp, 12, $maxComponentContours); // contours in compound glyph + $maxp = $this->_set_ushort($maxp, 28, $maxComponentElements); // number of glyphs referenced at top level + $maxp = $this->_set_ushort($maxp, 30, $maxComponentDepth); // levels of recursion, set to 0 if font has only simple glyphs + } + $this->add('maxp', $maxp); + + + /////////////////////////////////// + // OS/2 - OS/2 + /////////////////////////////////// + if (isset($this->tables['OS/2'])) { + $os2_offset = $this->seek_table("OS/2"); + if (_RECALC_PROFILE) { + $fsSelection = $this->get_ushort($os2_offset+62); + $fsSelection = ($fsSelection & ~(1 << 6)); // 2-byte bit field containing information concerning the nature of the font patterns + // bit#0 = Italic; bit#5=Bold + // Match name table's font subfamily string + // Clear bit#6 used for 'Regular' and optional + } + + // NB Currently this method never subsets characters above BMP + // Could set nonBMP bit according to $this->maxUni + $nonBMP = $this->get_ushort($os2_offset+46); + $nonBMP = ($nonBMP & ~(1 << 9)); // Unset Bit 57 (indicates non-BMP) - for interactive forms + + $os2 = $this->get_table('OS/2'); + if (_RECALC_PROFILE) { + $os2 = $this->_set_ushort($os2, 62, $fsSelection); + $os2 = $this->_set_ushort($os2, 66, $fsLastCharIndex); + $os2 = $this->_set_ushort($os2, 42, 0x0000); // ulCharRange (ulUnicodeRange) bits 24-31 | 16-23 + $os2 = $this->_set_ushort($os2, 44, 0x0000); // ulCharRange (Unicode ranges) bits 8-15 | 0-7 + $os2 = $this->_set_ushort($os2, 46, $nonBMP); // ulCharRange (Unicode ranges) bits 56-63 | 48-55 + $os2 = $this->_set_ushort($os2, 48, 0x0000); // ulCharRange (Unicode ranges) bits 40-47 | 32-39 + $os2 = $this->_set_ushort($os2, 50, 0x0000); // ulCharRange (Unicode ranges) bits 88-95 | 80-87 + $os2 = $this->_set_ushort($os2, 52, 0x0000); // ulCharRange (Unicode ranges) bits 72-79 | 64-71 + $os2 = $this->_set_ushort($os2, 54, 0x0000); // ulCharRange (Unicode ranges) bits 120-127 | 112-119 + $os2 = $this->_set_ushort($os2, 56, 0x0000); // ulCharRange (Unicode ranges) bits 104-111 | 96-103 + } + $os2 = $this->_set_ushort($os2, 46, $nonBMP); // Unset Bit 57 (indicates non-BMP) - for interactive forms + + $this->add('OS/2', $os2 ); + } + + fclose($this->fh); + // Put the TTF file together + $stm = ''; + $this->endTTFile($stm); + //file_put_contents('testfont.ttf', $stm); exit; + return $stm ; + } + +//================================================================================ + + // Also does SMP + function makeSubsetSIP($file, &$subset, $TTCfontID=0, $debug=false) { + $this->fh = fopen($file ,'rb') or die('Can\'t open file ' . $file); + $this->filename = $file; + $this->_pos = 0; + $this->unAGlyphs = false; // mPDF 5.4.05 + $this->charWidths = ''; + $this->glyphPos = array(); + $this->charToGlyph = array(); + $this->tables = array(); + $this->otables = array(); + $this->ascent = 0; + $this->descent = 0; + $this->numTTCFonts = 0; + $this->TTCFonts = array(); + $this->skip(4); + if ($TTCfontID > 0) { + $this->version = $version = $this->read_ulong(); // TTC Header version now + if (!in_array($version, array(0x00010000,0x00020000))) + die("ERROR - Error parsing TrueType Collection: version=".$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); + + + + /////////////////////////////////// + // 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 == 10) || $platformID == 0) { // Microsoft, Unicode Format 12 table HKCS + $format = $this->get_ushort($cmap_offset + $offset); + if ($format == 12) { + $unicode_cmap_offset = $cmap_offset + $offset; + break; + } + } + $this->seek($save_pos ); + } + + if (!$unicode_cmap_offset) + die('Font does not have cmap for Unicode (platform 3, encoding 1, format 4, or platform 0, any encoding, format 4)'); + // Format 12 CMAP does characters above Unicode BMP i.e. some HKCS characters U+20000 and above + if ($format == 12) { + $this->maxUniChar = 0; + $this->seek($unicode_cmap_offset + 4); + $length = $this->read_ulong(); + $limit = $unicode_cmap_offset + $length; + $this->skip(4); + + $nGroups = $this->read_ulong(); + + $glyphToChar = array(); + $charToGlyph = array(); + for($i=0; $i<$nGroups ; $i++) { + $startCharCode = $this->read_ulong(); + $endCharCode = $this->read_ulong(); + $startGlyphCode = $this->read_ulong(); + $offset = 0; + for ($unichar=$startCharCode;$unichar<=$endCharCode;$unichar++) { + $glyph = $startGlyphCode + $offset ; + $offset++; + $charToGlyph[$unichar] = $glyph; + if ($unichar < 196608) { $this->maxUniChar = max($unichar,$this->maxUniChar); } + $glyphToChar[$glyph][] = $unichar; + } + } + } + else + die('Font does not have cmap for Unicode (format 12)'); + + + /////////////////////////////////// + // hmtx - Horizontal metrics table + /////////////////////////////////// + $scale = 1; // not used here + $this->getHMTX($numberOfHMetrics, $numGlyphs, $glyphToChar, $scale); + + /////////////////////////////////// + // loca - Index to location + /////////////////////////////////// + $this->getLOCA($indexToLocFormat, $numGlyphs); + + /////////////////////////////////////////////////////////////////// + + $glyphMap = array(0=>0); + $glyphSet = array(0=>0); + $codeToGlyph = array(); + // Set a substitute if ASCII characters do not have glyphs + if (isset($charToGlyph[0x3F])) { $subs = $charToGlyph[0x3F]; } // Question mark + else { $subs = $charToGlyph[32]; } + foreach($subset AS $code) { + if (isset($charToGlyph[$code])) + $originalGlyphIdx = $charToGlyph[$code]; + else if ($code<128) { + $originalGlyphIdx = $subs; + } + else { $originalGlyphIdx = 0; } + if (!isset($glyphSet[$originalGlyphIdx])) { + $glyphSet[$originalGlyphIdx] = count($glyphMap); + $glyphMap[] = $originalGlyphIdx; + } + $codeToGlyph[$code] = $glyphSet[$originalGlyphIdx]; + } + + list($start,$dummy) = $this->get_table_pos('glyf'); + + $n = 0; + while ($n < count($glyphMap)) { + $originalGlyphIdx = $glyphMap[$n]; + $glyphPos = $this->glyphPos[$originalGlyphIdx]; + $glyphLen = $this->glyphPos[$originalGlyphIdx + 1] - $glyphPos; + $n += 1; + if (!$glyphLen) continue; + $this->seek($start + $glyphPos); + $numberOfContours = $this->read_short(); + if ($numberOfContours < 0) { + $this->skip(8); + $flags = GF_MORE; + while ($flags & GF_MORE) { + $flags = $this->read_ushort(); + $glyphIdx = $this->read_ushort(); + if (!isset($glyphSet[$glyphIdx])) { + $glyphSet[$glyphIdx] = count($glyphMap); + $glyphMap[] = $glyphIdx; + } + if ($flags & GF_WORDS) + $this->skip(4); + else + $this->skip(2); + if ($flags & GF_SCALE) + $this->skip(2); + else if ($flags & GF_XYSCALE) + $this->skip(4); + else if ($flags & GF_TWOBYTWO) + $this->skip(8); + } + } + } + + $numGlyphs = $n = count($glyphMap); + $numberOfHMetrics = $n; + + /////////////////////////////////// + // name + /////////////////////////////////// + // Needs to have a name entry in 3,0 (e.g. symbol) - original font will be 3,1 (i.e. Unicode) + $name = $this->get_table('name'); + $name_offset = $this->seek_table("name"); + $format = $this->read_ushort(); + $numRecords = $this->read_ushort(); + $string_data_offset = $name_offset + $this->read_ushort(); + for ($i=0;$i<$numRecords; $i++) { + $platformId = $this->read_ushort(); + $encodingId = $this->read_ushort(); + if ($platformId == 3 && $encodingId == 1) { + $pos = 6 + ($i * 12) + 2; + $name = $this->_set_ushort($name, $pos, 0x00); // Change encoding to 3,0 rather than 3,1 + } + $this->skip(8); + } + $this->add('name', $name); + + /////////////////////////////////// + // OS/2 + /////////////////////////////////// + if (isset($this->tables['OS/2'])) { + $os2 = $this->get_table('OS/2'); + $os2 = $this->_set_ushort($os2, 42, 0x00); // ulCharRange (Unicode ranges) + $os2 = $this->_set_ushort($os2, 44, 0x00); // ulCharRange (Unicode ranges) + $os2 = $this->_set_ushort($os2, 46, 0x00); // ulCharRange (Unicode ranges) + $os2 = $this->_set_ushort($os2, 48, 0x00); // ulCharRange (Unicode ranges) + + $os2 = $this->_set_ushort($os2, 50, 0x00); // ulCharRange (Unicode ranges) + $os2 = $this->_set_ushort($os2, 52, 0x00); // ulCharRange (Unicode ranges) + $os2 = $this->_set_ushort($os2, 54, 0x00); // ulCharRange (Unicode ranges) + $os2 = $this->_set_ushort($os2, 56, 0x00); // ulCharRange (Unicode ranges) + // Set Symbol character only in ulCodePageRange + $os2 = $this->_set_ushort($os2, 78, 0x8000); // ulCodePageRange = Bit #31 Symbol **** 78 = Bit 16-31 + $os2 = $this->_set_ushort($os2, 80, 0x0000); // ulCodePageRange = Bit #31 Symbol **** 80 = Bit 0-15 + $os2 = $this->_set_ushort($os2, 82, 0x0000); // ulCodePageRange = Bit #32- Symbol **** 82 = Bits 48-63 + $os2 = $this->_set_ushort($os2, 84, 0x0000); // ulCodePageRange = Bit #32- Symbol **** 84 = Bits 32-47 + + $os2 = $this->_set_ushort($os2, 64, 0x01); // FirstCharIndex + $os2 = $this->_set_ushort($os2, 66, count($subset)); // LastCharIndex + // Set PANOSE first bit to 5 for Symbol + $os2 = $this->splice($os2, 32, chr(5).chr(0).chr(1).chr(0).chr(1).chr(0).chr(0).chr(0).chr(0).chr(0)); + $this->add('OS/2', $os2 ); + } + + + /////////////////////////////////// + //tables copied from the original + /////////////////////////////////// + $tags = array ('cvt ', 'fpgm', 'prep', 'gasp'); + foreach($tags AS $tag) { // 1.02 + if (isset($this->tables[$tag])) { $this->add($tag, $this->get_table($tag)); } + } + + /////////////////////////////////// + // post - PostScript + /////////////////////////////////// + if (isset($this->tables['post'])) { + $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); + + /////////////////////////////////// + // 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); + + + /////////////////////////////////// + // CMap table Formats [1,0,]6 and [3,0,]4 + /////////////////////////////////// + /////////////////////////////////// + // Sort CID2GID map into segments of contiguous codes + /////////////////////////////////// + $rangeid = 0; + $range = array(); + $prevcid = -2; + $prevglidx = -1; + // for each character + foreach ($subset as $cid => $code) { + $glidx = $codeToGlyph[$code]; + 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 + $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( + 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 + $cmapstr4 = ''; + foreach($cmap AS $cm) { $cmapstr4 .= pack("n",$cm); } + + /////////////////////////////////// + // cmap - Character to glyph mapping + /////////////////////////////////// + $entryCount = count($subset); + $length = 10 + $entryCount * 2; + + $off = 20 + $length; + $hoff = $off >> 16; + $loff = $off & 0xFFFF; + + $cmap = array(0, 2, // Index : version, number of subtables + 1, 0, // Subtable : platform, encoding + 0, 20, // offset (hi,lo) + 3, 0, // Subtable : platform, encoding + $hoff, $loff, // offset (hi,lo) + 6, $length, // Format 6 Mapping table: format, length + 0, 1, // language, First char code + $entryCount + ); + $cmapstr = ''; + foreach($subset AS $code) { $cmap[] = $codeToGlyph[$code]; } + foreach($cmap AS $cm) { $cmapstr .= pack("n",$cm); } + $cmapstr .= $cmapstr4; + $this->add('cmap', $cmapstr); + + /////////////////////////////////// + // hmtx - Horizontal Metrics + /////////////////////////////////// + $hmtxstr = ''; + for($n=0;$n<$numGlyphs;$n++) { + $originalGlyphIdx = $glyphMap[$n]; + $hm = $this->getHMetric($orignHmetrics, $originalGlyphIdx); + $hmtxstr .= $hm; + } + $this->add('hmtx', $hmtxstr); + + /////////////////////////////////// + // 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; + for ($n=0;$n<$numGlyphs;$n++) { + $offsets[] = $pos; + $originalGlyphIdx = $glyphMap[$n]; + $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)) ) { + $pos_in_glyph = 10; + $flags = GF_MORE; + while ($flags & GF_MORE) { + $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]; + $data = $this->_set_ushort($data, $pos_in_glyph + 2, $glyphSet[$glyphIdx]); + $pos_in_glyph += 4; + if ($flags & GF_WORDS) { $pos_in_glyph += 4; } + else { $pos_in_glyph += 2; } + if ($flags & GF_SCALE) { $pos_in_glyph += 2; } + else if ($flags & GF_XYSCALE) { $pos_in_glyph += 4; } + else if ($flags & GF_TWOBYTWO) { $pos_in_glyph += 8; } + } + } + $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); + + /////////////////////////////////// + // 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); + + fclose($this->fh); + + // Put the TTF file together + $stm = ''; + $this->endTTFile($stm); + //file_put_contents('testfont.ttf', $stm); exit; + return $stm ; + } + + ////////////////////////////////////////////////////////////////////////////////// + // Recursively get composite glyph data + 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 + 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 = GF_MORE; + while ($flags & GF_MORE) { + $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 & GF_WORDS) + $this->skip(4); + else + $this->skip(2); + if ($flags & GF_SCALE) + $this->skip(2); + else if ($flags & GF_XYSCALE) + $this->skip(4); + else if ($flags & GF_TWOBYTWO) + $this->skip(8); + } + } + } + + ////////////////////////////////////////////////////////////////////////////////// + + function getHMTX($numberOfHMetrics, $numGlyphs, &$glyphToChar, $scale) { + $start = $this->seek_table("hmtx"); + $aw = 0; + $this->charWidths = str_pad('', 256*256*2, "\x00"); + if ($this->maxUniChar > 65536) { $this->charWidths .= str_pad('', 256*256*2, "\x00"); } // Plane 1 SMP + if ($this->maxUniChar > 131072) { $this->charWidths .= str_pad('', 256*256*2, "\x00"); } // Plane 2 SMP + $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) { + //$this->charWidths[$char] = intval(round($scale*$aw)); + 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; + $w = intval(round($scale*$aw)); + if ($w == 0) { $w = 65535; } + for( $pos=0; $pos<$diff; $pos++) { + $glyph = $pos + $numberOfHMetrics; + if (isset($glyphToChar[$glyph])) { + foreach($glyphToChar[$glyph] AS $char) { + if ($char != 0 && $char != 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); + } + + 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; + } + + 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 + die('Unknown location table format '.$indexToLocFormat); + } + + + // CMAP Format 4 + 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; + } + } + + // mPDF 5.4.05 + if ($this->unAGlyphs) { + if (isset($this->tables['post'])) { + $this->seek_table("post"); + $formata = $this->read_ushort(); + $formatb = $this->read_ushort(); + // Only works on Format 2.0 + if ($formata != 2 || $formatb != 0) { die("Cannot set unAGlyphs for this font (".$file."). POST table must be in Format 2."); } + $this->skip(28); + $nGlyfs = $this->read_ushort(); + $glyphNameIndex = array(); + for ($i=0; $i<$nGlyfs; $i++) { + $glyphNameIndex[($this->read_ushort())] = $i; + } + + $opost = $this->get_table('post'); + $ptr = 34+($nGlyfs*2); + for ($i=0; $i<$nGlyfs; $i++) { + $len = ord(substr($opost,$ptr,1)); + $ptr++; + $name = substr($opost,$ptr,$len); + $gid = $glyphNameIndex[$i+258]; + // Select uni0600.xxx(x) - uni06FF.xxx(x) + if (preg_match('/^uni(06[0-9a-f]{2})\.(fina|medi|init|fin|med|ini)$/i',$name,$m)) { + if (!isset($glyphToChar[$gid]) || (isset($glyphToChar[$gid]) && is_array($glyphToChar[$gid]) && count($glyphToChar[$gid])==1 && $glyphToChar[$gid][0]>57343 && $glyphToChar[$gid][0]<63489)) { // if set in PUA private use area E000-F8FF, or NOT Unicode mapped + $uni = hexdec($m[1]); + $form = strtoupper(substr($m[2],0,1)); + // Assign new PUA Unicode between F500 - F7FF + $bit = $uni & 0xFF; + if ($form == 'I') { $bit += 0xF600; } + else if ($form == 'M') { $bit += 0xF700; } + else { $bit += 0xF500; } + // ADD TO CMAP + $glyphToChar[$gid][] = $bit; + $charToGlyph[$bit] = $gid; + } + } + // LAM with ALEF ligatures (Mandatory ligatures) + else if (preg_match('/^uni064406(22|23|25|27)(\.fina|\.fin){0,1}$/i',$name,$m)) { + if ($m[1]=='22') { + if ($m[2]) { $uni = hexdec('FEF6'); } else { $uni = hexdec('FEF5'); } + } + else if ($m[1]=='23') { + if ($m[2]) { $uni = hexdec('FEF8'); } else { $uni = hexdec('FEF7'); } + } + else if ($m[1]=='25') { + if ($m[2]) { $uni = hexdec('FEFA'); } else { $uni = hexdec('FEF9'); } + } + else if ($m[1]=='27') { + if ($m[2]) { $uni = hexdec('FEFC'); } else { $uni = hexdec('FEFB'); } + } + if (!isset($glyphToChar[$gid]) || (isset($glyphToChar[$gid]) && is_array($glyphToChar[$gid]) && count($glyphToChar[$gid])==1 && $glyphToChar[$gid][0]>57343 && $glyphToChar[$gid][0]<63489)) { // if set in PUA private use area E000-F8FF, or NOT Unicode mapped + // ADD TO CMAP + $glyphToChar[$gid][] = $uni; + $charToGlyph[$uni] = $gid; + } + } + $ptr += $len; + } + } + } + + } + + + // Put the TTF file together + 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 (_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 ; + } + + + function repackageTTF($file, $TTCfontID=0, $debug=false, $unAGlyphs=false) { // mPDF 5.4.05 + $this->unAGlyphs = $unAGlyphs; // mPDF 5.4.05 + $this->filename = $file; + $this->fh = fopen($file ,'rb') or die('Can\'t open file ' . $file); + $this->_pos = 0; + $this->charWidths = ''; + $this->glyphPos = array(); + $this->charToGlyph = array(); + $this->tables = array(); + $this->otables = array(); + $this->ascent = 0; + $this->descent = 0; + $this->numTTCFonts = 0; + $this->TTCFonts = array(); + $this->skip(4); + $this->maxUni = 0; + if ($TTCfontID > 0) { + $this->version = $version = $this->read_ulong(); // TTC Header version now + if (!in_array($version, array(0x00010000,0x00020000))) + die("ERROR - Error parsing TrueType Collection: version=".$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); + $tags = array ('OS/2', 'cmap', 'glyf', 'head', 'hhea', 'hmtx', 'loca', 'maxp', 'name', 'post', 'cvt ', 'fpgm', 'gasp', 'prep'); +/* +Tables which require glyphIndex +hdmx +kern +LTSH + +Tables which do NOT require glyphIndex +VDMX + +GDEF +GPOS +GSUB +JSTF + +DSIG +PCLT - not recommended +*/ + + foreach($tags AS $tag) { + if (isset($this->tables[$tag])) { $this->add($tag, $this->get_table($tag)); } + } + fclose($this->fh); + $stm = ''; + $this->endTTFile($stm); + return $stm ; + } + + +} + + +?> \ No newline at end of file -- cgit v1.2.3