| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_vcl.hxx" |
| |
| /* |
| * Sun Font Tools |
| * |
| * Author: Alexander Gelfenbain |
| * |
| */ |
| |
| #if OSL_DEBUG_LEVEL == 0 |
| # ifndef NDEBUG |
| # define NDEBUG |
| # endif |
| #endif |
| #include <assert.h> |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <fcntl.h> |
| #ifdef UNX |
| #include <sys/mman.h> |
| #include <sys/stat.h> |
| #endif |
| #include "sft.hxx" |
| #include "gsub.h" |
| #if ! (defined(NO_TTCR) && defined(NO_TYPE42)) |
| #include "ttcr.hxx" |
| #endif |
| #ifndef NO_MAPPERS /* include MapChar() and MapString() */ |
| #include "xlat.hxx" |
| #endif |
| #ifndef NO_TYPE3 /* include CreateT3FromTTGlyphs() */ |
| #include <rtl/crc.h> |
| #endif |
| |
| #include <osl/endian.h> |
| #include <algorithm> |
| |
| #ifdef TEST7 |
| #include <ctype.h> |
| #endif |
| |
| namespace vcl |
| { |
| |
| /*- module identification */ |
| |
| static const char *modname = "SunTypeTools-TT"; |
| static const char *modver = "1.0"; |
| static const char *modextra = "gelf"; |
| |
| /*- private functions, constants and data types */ /*FOLD00*/ |
| |
| enum PathSegmentType { |
| PS_NOOP = 0, |
| PS_MOVETO = 1, |
| PS_LINETO = 2, |
| PS_CURVETO = 3, |
| PS_CLOSEPATH = 4 |
| }; |
| |
| struct PSPathElement |
| { |
| PathSegmentType type; |
| int x1, y1; |
| int x2, y2; |
| int x3, y3; |
| |
| PSPathElement( PathSegmentType i_eType ) : type( i_eType ), |
| x1( 0 ), y1( 0 ), |
| x2( 0 ), y2( 0 ), |
| x3( 0 ), y3( 0 ) |
| { |
| } |
| }; |
| |
| /*- In horisontal writing mode right sidebearing is calculated using this formula |
| *- rsb = aw - (lsb + xMax - xMin) -*/ |
| typedef struct { |
| sal_Int16 xMin; |
| sal_Int16 yMin; |
| sal_Int16 xMax; |
| sal_Int16 yMax; |
| sal_uInt16 aw; /*- Advance Width (horisontal writing mode) */ |
| sal_Int16 lsb; /*- Left sidebearing (horisontal writing mode) */ |
| sal_uInt16 ah; /*- advance height (vertical writing mode) */ |
| sal_Int16 tsb; /*- top sidebearing (vertical writing mode) */ |
| } TTGlyphMetrics; |
| |
| #define HFORMAT_LINELEN 64 |
| |
| typedef struct { |
| FILE *o; |
| char buffer[HFORMAT_LINELEN]; |
| int bufpos; |
| int total; |
| } HexFmt; |
| |
| typedef struct { |
| sal_uInt32 nGlyphs; /* number of glyphs in the font + 1 */ |
| sal_uInt32 *offs; /* array of nGlyphs offsets */ |
| } GlyphOffsets; |
| |
| /* private tags */ |
| static const sal_uInt32 TTFontClassTag = 0x74746663; /* 'ttfc' */ |
| |
| static const sal_uInt32 T_true = 0x74727565; /* 'true' */ |
| static const sal_uInt32 T_ttcf = 0x74746366; /* 'ttcf' */ |
| static const sal_uInt32 T_otto = 0x4f54544f; /* 'OTTO' */ |
| |
| /* standard TrueType table tags */ |
| #define T_maxp 0x6D617870 |
| #define T_glyf 0x676C7966 |
| #define T_head 0x68656164 |
| #define T_loca 0x6C6F6361 |
| #define T_name 0x6E616D65 |
| #define T_hhea 0x68686561 |
| #define T_hmtx 0x686D7478 |
| #define T_cmap 0x636D6170 |
| #define T_vhea 0x76686561 |
| #define T_vmtx 0x766D7478 |
| #define T_OS2 0x4F532F32 |
| #define T_post 0x706F7374 |
| #define T_kern 0x6B65726E |
| #define T_cvt 0x63767420 |
| #define T_prep 0x70726570 |
| #define T_fpgm 0x6670676D |
| #define T_gsub 0x47535542 |
| #define T_CFF 0x43464620 |
| |
| #define LAST_URANGE_BIT 69 |
| const char *ulcodes[LAST_URANGE_BIT+2] = { |
| /* 0 */ "Basic Latin", |
| /* 1 */ "Latin-1 Supplement", |
| /* 2 */ "Latin Extended-A", |
| /* 3 */ "Latin Extended-B", |
| /* 4 */ "IPA Extensions", |
| /* 5 */ "Spacing Modifier Letters", |
| /* 6 */ "Combining Diacritical Marks", |
| /* 7 */ "Basic Greek", |
| /* 8 */ "Greek Symbols And Coptic", |
| /* 9 */ "Cyrillic", |
| /* 10 */ "Armenian", |
| /* 11 */ "Basic Hebrew", |
| /* 12 */ "Hebrew Extended (A and B blocks combined)", |
| /* 13 */ "Basic Arabic", |
| /* 14 */ "Arabic Extended", |
| /* 15 */ "Devanagari", |
| /* 16 */ "Bengali", |
| /* 17 */ "Gurmukhi", |
| /* 18 */ "Gujarati", |
| /* 19 */ "Oriya", |
| /* 20 */ "Tamil", |
| /* 21 */ "Telugu", |
| /* 22 */ "Kannada", |
| /* 23 */ "Malayalam", |
| /* 24 */ "Thai", |
| /* 25 */ "Lao", |
| /* 26 */ "Basic Georgian", |
| /* 27 */ "Georgian Extended", |
| /* 28 */ "Hangul Jamo", |
| /* 29 */ "Latin Extended Additional", |
| /* 30 */ "Greek Extended", |
| /* 31 */ "General Punctuation", |
| /* 32 */ "Superscripts And Subscripts", |
| /* 33 */ "Currency Symbols", |
| /* 34 */ "Combining Diacritical Marks For Symbols", |
| /* 35 */ "Letterlike Symbols", |
| /* 36 */ "Number Forms", |
| /* 37 */ "Arrows", |
| /* 38 */ "Mathematical Operators", |
| /* 39 */ "Miscellaneous Technical", |
| /* 40 */ "Control Pictures", |
| /* 41 */ "Optical Character Recognition", |
| /* 42 */ "Enclosed Alphanumerics", |
| /* 43 */ "Box Drawing", |
| /* 44 */ "Block Elements", |
| /* 45 */ "Geometric Shapes", |
| /* 46 */ "Miscellaneous Symbols", |
| /* 47 */ "Dingbats", |
| /* 48 */ "CJK Symbols And Punctuation", |
| /* 49 */ "Hiragana", |
| /* 50 */ "Katakana", |
| /* 51 */ "Bopomofo", |
| /* 52 */ "Hangul Compatibility Jamo", |
| /* 53 */ "CJK Miscellaneous", |
| /* 54 */ "Enclosed CJK Letters And Months", |
| /* 55 */ "CJK Compatibility", |
| /* 56 */ "Hangul", |
| /* 57 */ "Reserved for Unicode SubRanges", |
| /* 58 */ "Reserved for Unicode SubRanges", |
| /* 59 */ "CJK Unified Ideographs", |
| /* 60 */ "Private Use Area", |
| /* 61 */ "CJK Compatibility Ideographs", |
| /* 62 */ "Alphabetic Presentation Forms", |
| /* 63 */ "Arabic Presentation Forms-A", |
| /* 64 */ "Combining Half Marks", |
| /* 65 */ "CJK Compatibility Forms", |
| /* 66 */ "Small Form Variants", |
| /* 67 */ "Arabic Presentation Forms-B", |
| /* 68 */ "Halfwidth And Fullwidth Forms", |
| /* 69 */ "Specials", |
| /*70-127*/ "Reserved for Unicode SubRanges" |
| }; |
| |
| |
| |
| /*- inline functions */ /*FOLD01*/ |
| #ifdef __GNUC__ |
| #define _inline static __inline__ |
| #else |
| #define _inline static |
| #endif |
| |
| _inline void *smalloc(size_t size) |
| { |
| void *res = malloc(size); |
| assert(res != 0); |
| return res; |
| } |
| |
| _inline void *scalloc(size_t n, size_t size) |
| { |
| void *res = calloc(n, size); |
| assert(res != 0); |
| return res; |
| } |
| |
| _inline sal_uInt32 mkTag(sal_uInt8 a, sal_uInt8 b, sal_uInt8 c, sal_uInt8 d) { |
| return (a << 24) | (b << 16) | (c << 8) | d; |
| } |
| |
| /*- Data access macros for data stored in big-endian or little-endian format */ |
| _inline sal_Int16 GetInt16(const sal_uInt8 *ptr, size_t offset, int bigendian) |
| { |
| sal_Int16 t; |
| assert(ptr != 0); |
| |
| if (bigendian) { |
| t = (ptr+offset)[0] << 8 | (ptr+offset)[1]; |
| } else { |
| t = (ptr+offset)[1] << 8 | (ptr+offset)[0]; |
| } |
| |
| return t; |
| } |
| |
| _inline sal_uInt16 GetUInt16(const sal_uInt8 *ptr, size_t offset, int bigendian) |
| { |
| sal_uInt16 t; |
| assert(ptr != 0); |
| |
| if (bigendian) { |
| t = (ptr+offset)[0] << 8 | (ptr+offset)[1]; |
| } else { |
| t = (ptr+offset)[1] << 8 | (ptr+offset)[0]; |
| } |
| |
| return t; |
| } |
| |
| _inline sal_Int32 GetInt32(const sal_uInt8 *ptr, size_t offset, int bigendian) |
| { |
| sal_Int32 t; |
| assert(ptr != 0); |
| |
| if (bigendian) { |
| t = (ptr+offset)[0] << 24 | (ptr+offset)[1] << 16 | |
| (ptr+offset)[2] << 8 | (ptr+offset)[3]; |
| } else { |
| t = (ptr+offset)[3] << 24 | (ptr+offset)[2] << 16 | |
| (ptr+offset)[1] << 8 | (ptr+offset)[0]; |
| } |
| |
| return t; |
| } |
| |
| _inline sal_uInt32 GetUInt32(const sal_uInt8 *ptr, size_t offset, int bigendian) |
| { |
| sal_uInt32 t; |
| assert(ptr != 0); |
| |
| |
| if (bigendian) { |
| t = (ptr+offset)[0] << 24 | (ptr+offset)[1] << 16 | |
| (ptr+offset)[2] << 8 | (ptr+offset)[3]; |
| } else { |
| t = (ptr+offset)[3] << 24 | (ptr+offset)[2] << 16 | |
| (ptr+offset)[1] << 8 | (ptr+offset)[0]; |
| } |
| |
| return t; |
| } |
| |
| _inline void PutInt16(sal_Int16 val, sal_uInt8 *ptr, size_t offset, int bigendian) |
| { |
| assert(ptr != 0); |
| |
| if (bigendian) { |
| ptr[offset] = (sal_uInt8)((val >> 8) & 0xFF); |
| ptr[offset+1] = (sal_uInt8)(val & 0xFF); |
| } else { |
| ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF); |
| ptr[offset] = (sal_uInt8)(val & 0xFF); |
| } |
| |
| } |
| |
| #if defined(OSL_BIGENDIAN) |
| #define Int16FromMOTA(a) (a) |
| #define Int32FromMOTA(a) (a) |
| #else |
| static sal_uInt16 Int16FromMOTA(sal_uInt16 a) { |
| return (sal_uInt16) (((sal_uInt8)((a) >> 8)) | ((sal_uInt8)(a) << 8)); |
| } |
| static sal_uInt32 Int32FromMOTA(sal_uInt32 a) { |
| return ((a>>24)&0xFF) | (((a>>8)&0xFF00) | ((a&0xFF00)<<8) | ((a&0xFF)<<24)); |
| } |
| #endif |
| |
| _inline F16Dot16 fixedMul(F16Dot16 a, F16Dot16 b) |
| { |
| unsigned int a1, b1; |
| unsigned int a2, b2; |
| F16Dot16 res; |
| int sign; |
| |
| sign = (a & 0x80000000) ^ (b & 0x80000000); |
| if (a < 0) a = -a; |
| if (b < 0) b = -b; |
| |
| a1 = a >> 16; |
| b1 = a & 0xFFFF; |
| a2 = b >> 16; |
| b2 = b & 0xFFFF; |
| |
| res = a1 * a2; |
| |
| /* if (res > 0x7FFF) assert(!"fixedMul: F16Dot16 overflow"); */ |
| |
| res <<= 16; |
| res += a1 * b2 + b1 * a2 + ((b1 * b2) >> 16); |
| |
| return sign ? -res : res; |
| } |
| |
| |
| _inline F16Dot16 fixedDiv(F16Dot16 a, F16Dot16 b) |
| { |
| unsigned int f, r; |
| F16Dot16 res; |
| int sign; |
| |
| sign = (a & 0x80000000) ^ (b & 0x80000000); |
| if (a < 0) a = -a; |
| if (b < 0) b = -b; |
| |
| f = a / b; |
| r = a % b; |
| |
| /* if (f > 0x7FFFF) assert(!"fixedDiv: F16Dot16 overflow"); */ |
| |
| while (r > 0xFFFF) { |
| r >>= 1; |
| b >>= 1; |
| } |
| |
| res = (f << 16) + (r << 16) / b; |
| |
| return sign ? -res : res; |
| } |
| |
| /*- returns a * b / c -*/ |
| /* XXX provide a real implementation that preserves accuracy */ |
| _inline F16Dot16 fixedMulDiv(F16Dot16 a, F16Dot16 b, F16Dot16 c) |
| { |
| F16Dot16 res; |
| |
| res = fixedMul(a, b); |
| return fixedDiv(res, c); |
| } |
| |
| /*- Translate units from TT to PS (standard 1/1000) -*/ |
| _inline int XUnits(int unitsPerEm, int n) |
| { |
| return (n * 1000) / unitsPerEm; |
| } |
| |
| _inline const char *UnicodeRangeName(sal_uInt16 bit) |
| { |
| if (bit > LAST_URANGE_BIT) bit = LAST_URANGE_BIT+1; |
| |
| return ulcodes[bit]; |
| } |
| |
| _inline const sal_uInt8* getTable( TrueTypeFont *ttf, sal_uInt32 ord) |
| { |
| return (sal_uInt8*)ttf->tables[ord]; |
| } |
| |
| _inline sal_uInt32 getTableSize(TrueTypeFont *ttf, sal_uInt32 ord) |
| { |
| return ttf->tlens[ord]; |
| } |
| |
| #ifndef NO_TYPE42 |
| /* Hex Formatter functions */ |
| static char HexChars[] = "0123456789ABCDEF"; |
| |
| static HexFmt *HexFmtNew(FILE *outf) |
| { |
| HexFmt* res = (HexFmt*)smalloc(sizeof(HexFmt)); |
| res->bufpos = res->total = 0; |
| res->o = outf; |
| return res; |
| } |
| |
| static void HexFmtFlush(HexFmt *_this) |
| { |
| if (_this->bufpos) { |
| fwrite(_this->buffer, 1, _this->bufpos, _this->o); |
| _this->bufpos = 0; |
| } |
| } |
| |
| |
| _inline void HexFmtOpenString(HexFmt *_this) |
| { |
| fputs("<\n", _this->o); |
| } |
| |
| _inline void HexFmtCloseString(HexFmt *_this) |
| { |
| HexFmtFlush(_this); |
| fputs("00\n>\n", _this->o); |
| } |
| |
| _inline void HexFmtDispose(HexFmt *_this) |
| { |
| HexFmtFlush(_this); |
| free(_this); |
| } |
| |
| static void HexFmtBlockWrite(HexFmt *_this, const void *ptr, sal_uInt32 size) |
| { |
| sal_uInt8 Ch; |
| sal_uInt32 i; |
| |
| if (_this->total + size > 65534) { |
| HexFmtFlush(_this); |
| HexFmtCloseString(_this); |
| _this->total = 0; |
| HexFmtOpenString(_this); |
| } |
| for (i=0; i<size; i++) { |
| Ch = ((sal_uInt8 *) ptr)[i]; |
| _this->buffer[_this->bufpos++] = HexChars[Ch >> 4]; |
| _this->buffer[_this->bufpos++] = HexChars[Ch & 0xF]; |
| if (_this->bufpos == HFORMAT_LINELEN) { |
| HexFmtFlush(_this); |
| fputc('\n', _this->o); |
| } |
| |
| } |
| _this->total += size; |
| } |
| #endif |
| |
| |
| |
| /* Outline Extraction functions */ /*FOLD01*/ |
| |
| /* fills the aw and lsb entries of the TTGlyphMetrics structure from hmtx table -*/ |
| static void GetMetrics(TrueTypeFont *ttf, sal_uInt32 glyphID, TTGlyphMetrics *metrics) |
| { |
| const sal_uInt8* table = getTable( ttf, O_hmtx ); |
| |
| metrics->aw = metrics->lsb = metrics->ah = metrics->tsb = 0; |
| if (!table || !ttf->numberOfHMetrics) return; |
| |
| if (glyphID < ttf->numberOfHMetrics) { |
| metrics->aw = GetUInt16(table, 4 * glyphID, 1); |
| metrics->lsb = GetInt16(table, 4 * glyphID + 2, 1); |
| } else { |
| metrics->aw = GetUInt16(table, 4 * (ttf->numberOfHMetrics - 1), 1); |
| metrics->lsb = GetInt16(table + ttf->numberOfHMetrics * 4, (glyphID - ttf->numberOfHMetrics) * 2, 1); |
| } |
| |
| table = getTable(ttf, O_vmtx); |
| if( !table || !ttf->numOfLongVerMetrics ) |
| return; |
| |
| if (glyphID < ttf->numOfLongVerMetrics) { |
| metrics->ah = GetUInt16(table, 4 * glyphID, 1); |
| metrics->tsb = GetInt16(table, 4 * glyphID + 2, 1); |
| } else { |
| metrics->ah = GetUInt16(table, 4 * (ttf->numOfLongVerMetrics - 1), 1); |
| metrics->tsb = GetInt16(table + ttf->numOfLongVerMetrics * 4, (glyphID - ttf->numOfLongVerMetrics) * 2, 1); |
| } |
| } |
| |
| static int GetTTGlyphOutline(TrueTypeFont *, sal_uInt32 , ControlPoint **, TTGlyphMetrics *, std::vector< sal_uInt32 >* ); |
| |
| /* returns the number of control points, allocates the pointArray */ |
| static int GetSimpleTTOutline(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray, TTGlyphMetrics *metrics) /*FOLD02*/ |
| { |
| const sal_uInt8* table = getTable( ttf, O_glyf ); |
| sal_uInt8 flag, n; |
| sal_uInt16 t, lastPoint=0; |
| int i, j, z; |
| |
| *pointArray = 0; |
| |
| /* printf("GetSimpleTTOutline(%d)\n", glyphID); */ |
| |
| if( glyphID >= ttf->nglyphs ) /*- glyph is not present in the font */ |
| return 0; |
| const sal_uInt8* ptr = table + ttf->goffsets[glyphID]; |
| const sal_Int16 numberOfContours = GetInt16(ptr, 0, 1); |
| if( numberOfContours <= 0 ) /*- glyph is not simple */ |
| return 0; |
| |
| if (metrics) { /*- GetCompoundTTOutline() calls this function with NULL metrics -*/ |
| metrics->xMin = GetInt16(ptr, 2, 1); |
| metrics->yMin = GetInt16(ptr, 4, 1); |
| metrics->xMax = GetInt16(ptr, 6, 1); |
| metrics->yMax = GetInt16(ptr, 8, 1); |
| GetMetrics(ttf, glyphID, metrics); |
| } |
| |
| /* determine the last point and be extra safe about it. But probably this code is not needed */ |
| |
| for (i=0; i<numberOfContours; i++) { |
| if ((t = GetUInt16(ptr, 10+i*2, 1)) > lastPoint) lastPoint = t; |
| } |
| |
| sal_uInt16 instLen = GetUInt16(ptr, 10 + numberOfContours*2, 1); |
| const sal_uInt8* p = ptr + 10 + 2 * numberOfContours + 2 + instLen; |
| ControlPoint* pa = (ControlPoint*)calloc(lastPoint+1, sizeof(ControlPoint)); |
| |
| i = 0; |
| while (i <= lastPoint) { |
| pa[i++].flags = (sal_uInt32) (flag = *p++); |
| if (flag & 8) { /*- repeat flag */ |
| n = *p++; |
| for (j=0; j<n; j++) { |
| if (i > lastPoint) { /*- if the font is really broken */ |
| free(pa); |
| return 0; |
| } |
| pa[i++].flags = flag; |
| } |
| } |
| } |
| |
| /*- Process the X coordinate */ |
| z = 0; |
| for (i = 0; i <= lastPoint; i++) { |
| if (pa[i].flags & 0x02) { |
| if (pa[i].flags & 0x10) { |
| z += (int) (*p++); |
| } else { |
| z -= (int) (*p++); |
| } |
| } else if ( !(pa[i].flags & 0x10)) { |
| z += GetInt16(p, 0, 1); |
| p += 2; |
| } |
| pa[i].x = (sal_Int16)z; |
| } |
| |
| /*- Process the Y coordinate */ |
| z = 0; |
| for (i = 0; i <= lastPoint; i++) { |
| if (pa[i].flags & 0x04) { |
| if (pa[i].flags & 0x20) { |
| z += *p++; |
| } else { |
| z -= *p++; |
| } |
| } else if ( !(pa[i].flags & 0x20)) { |
| z += GetInt16(p, 0, 1); |
| p += 2; |
| } |
| pa[i].y = (sal_Int16)z; |
| } |
| |
| for (i=0; i<numberOfContours; i++) { |
| pa[GetUInt16(ptr, 10 + i * 2, 1)].flags |= 0x00008000; /*- set the end contour flag */ |
| } |
| |
| *pointArray = pa; |
| return lastPoint + 1; |
| } |
| |
| static int GetCompoundTTOutline(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray, TTGlyphMetrics *metrics, std::vector< sal_uInt32 >& glyphlist) /*FOLD02*/ |
| { |
| sal_uInt16 flags, index; |
| sal_Int16 e, f, numberOfContours; |
| const sal_uInt8* table = getTable( ttf, O_glyf ); |
| std::vector<ControlPoint> myPoints; |
| ControlPoint *nextComponent, *pa; |
| int i, np; |
| F16Dot16 a = 0x10000, b = 0, c = 0, d = 0x10000, m, n, abs1, abs2, abs3; |
| |
| *pointArray = 0; |
| /* printf("GetCompoundTTOutline(%d)\n", glyphID); */ |
| |
| if (glyphID >= ttf->nglyphs) /*- incorrect glyphID */ |
| return 0; |
| |
| const sal_uInt8* ptr = table + ttf->goffsets[glyphID]; |
| if ((numberOfContours = GetInt16(ptr, 0, 1)) != -1) /*- glyph is not compound */ |
| return 0; |
| |
| if (metrics) { |
| metrics->xMin = GetInt16(ptr, 2, 1); |
| metrics->yMin = GetInt16(ptr, 4, 1); |
| metrics->xMax = GetInt16(ptr, 6, 1); |
| metrics->yMax = GetInt16(ptr, 8, 1); |
| GetMetrics(ttf, glyphID, metrics); |
| } |
| |
| ptr += 10; |
| |
| do { |
| flags = GetUInt16(ptr, 0, 1); |
| /* printf("flags: 0x%X\n", flags); */ |
| index = GetUInt16(ptr, 2, 1); |
| ptr += 4; |
| |
| if( std::find( glyphlist.begin(), glyphlist.end(), index ) != glyphlist.end() ) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf(stderr, "Endless loop found in a compound glyph.\n"); |
| fprintf(stderr, "%d -> ", index); |
| fprintf(stderr," ["); |
| for( std::vector< sal_uInt32 >::const_iterator it = glyphlist.begin(); |
| it != glyphlist.end(); ++it ) |
| { |
| fprintf( stderr,"%d ", (int) *it ); |
| } |
| fprintf(stderr,"]\n"); |
| /**/ |
| #endif |
| } |
| |
| glyphlist.push_back( index ); |
| |
| #ifdef DEBUG2 |
| fprintf(stderr,"glyphlist: += %d\n", index); |
| #endif |
| |
| if ((np = GetTTGlyphOutline(ttf, index, &nextComponent, 0, &glyphlist)) == 0) |
| { |
| /* XXX that probably indicates a corrupted font */ |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf(stderr, "An empty compound!\n"); |
| /* assert(!"An empty compound"); */ |
| #endif |
| } |
| |
| #ifdef DEBUG2 |
| fprintf(stderr,"%d [", (int)glyphlist.size() ); |
| for( std::vector< sal_uInt32 >::const_iterator it = glyphlist.begin(); |
| it != glyphlist.end(); ++it ) |
| { |
| fprintf( stderr,"%d ", (int) *it ); |
| } |
| fprintf(stderr, "]\n"); |
| if( ! glyphlist.empty() ) |
| fprintf(stderr, "glyphlist: -= %d\n", (int) glyphlist.back()); |
| |
| #endif |
| if( ! glyphlist.empty() ) |
| glyphlist.pop_back(); |
| |
| if (flags & USE_MY_METRICS) { |
| if (metrics) GetMetrics(ttf, index, metrics); |
| } |
| |
| if (flags & ARG_1_AND_2_ARE_WORDS) { |
| e = GetInt16(ptr, 0, 1); |
| f = GetInt16(ptr, 2, 1); |
| /* printf("ARG_1_AND_2_ARE_WORDS: %d %d\n", e & 0xFFFF, f & 0xFFFF); */ |
| ptr += 4; |
| } else { |
| if (flags & ARGS_ARE_XY_VALUES) { /* args are signed */ |
| e = (sal_Int8) *ptr++; |
| f = (sal_Int8) *ptr++; |
| /* printf("ARGS_ARE_XY_VALUES: %d %d\n", e & 0xFF, f & 0xFF); */ |
| } else { /* args are unsigned */ |
| /* printf("!ARGS_ARE_XY_VALUES\n"); */ |
| e = *ptr++; |
| f = *ptr++; |
| } |
| |
| } |
| |
| a = d = 0x10000; |
| b = c = 0; |
| |
| if (flags & WE_HAVE_A_SCALE) { |
| #ifdef DEBUG2 |
| fprintf(stderr, "WE_HAVE_A_SCALE\n"); |
| #endif |
| a = GetInt16(ptr, 0, 1) << 2; |
| d = a; |
| ptr += 2; |
| } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) { |
| #ifdef DEBUG2 |
| fprintf(stderr, "WE_HAVE_AN_X_AND_Y_SCALE\n"); |
| #endif |
| a = GetInt16(ptr, 0, 1) << 2; |
| d = GetInt16(ptr, 2, 1) << 2; |
| ptr += 4; |
| } else if (flags & WE_HAVE_A_TWO_BY_TWO) { |
| #ifdef DEBUG2 |
| fprintf(stderr, "WE_HAVE_A_TWO_BY_TWO\n"); |
| #endif |
| a = GetInt16(ptr, 0, 1) << 2; |
| b = GetInt16(ptr, 2, 1) << 2; |
| c = GetInt16(ptr, 4, 1) << 2; |
| d = GetInt16(ptr, 6, 1) << 2; |
| ptr += 8; |
| } |
| |
| abs1 = (a < 0) ? -a : a; |
| abs2 = (b < 0) ? -b : b; |
| m = (abs1 > abs2) ? abs1 : abs2; |
| abs3 = abs1 - abs2; |
| if (abs3 < 0) abs3 = -abs3; |
| if (abs3 <= 33) m *= 2; |
| |
| abs1 = (c < 0) ? -c : c; |
| abs2 = (d < 0) ? -d : d; |
| n = (abs1 > abs2) ? abs1 : abs2; |
| abs3 = abs1 - abs2; |
| if (abs3 < 0) abs3 = -abs3; |
| if (abs3 <= 33) n *= 2; |
| |
| if (!ARGS_ARE_XY_VALUES) { /* match the points */ |
| assert(!"ARGS_ARE_XY_VALUES is not implemented!!!\n"); |
| } |
| |
| #ifdef DEBUG2 |
| fprintf(stderr, "a: %f, b: %f, c: %f, d: %f, e: %f, f: %f, m: %f, n: %f\n", |
| ((double) a) / 65536, |
| ((double) b) / 65536, |
| ((double) c) / 65536, |
| ((double) d) / 65536, |
| ((double) e) / 65536, |
| ((double) f) / 65536, |
| ((double) m) / 65536, |
| ((double) n) / 65536); |
| #endif |
| |
| for (i=0; i<np; i++) { |
| F16Dot16 t; |
| ControlPoint cp; |
| cp.flags = nextComponent[i].flags; |
| t = fixedMulDiv(a, nextComponent[i].x << 16, m) + fixedMulDiv(c, nextComponent[i].y << 16, m) + (e << 16); |
| cp.x = (sal_Int16)(fixedMul(t, m) >> 16); |
| t = fixedMulDiv(b, nextComponent[i].x << 16, n) + fixedMulDiv(d, nextComponent[i].y << 16, n) + (f << 16); |
| cp.y = (sal_Int16)(fixedMul(t, n) >> 16); |
| |
| #ifdef DEBUG2 |
| fprintf(stderr, "( %d %d ) -> ( %d %d )\n", nextComponent[i].x, nextComponent[i].y, cp.x, cp.y); |
| #endif |
| |
| myPoints.push_back( cp ); |
| } |
| |
| free(nextComponent); |
| |
| } while (flags & MORE_COMPONENTS); |
| |
| // #i123417# some fonts like IFAOGrec have no outline points in some compound glyphs |
| // so this unlikely but possible scenario should be handled gracefully |
| if( myPoints.empty() ) |
| return 0; |
| |
| np = myPoints.size(); |
| |
| pa = (ControlPoint*)calloc(np, sizeof(ControlPoint)); |
| assert(pa != 0); |
| |
| memcpy( pa, &myPoints[0], np*sizeof(ControlPoint) ); |
| |
| *pointArray = pa; |
| return np; |
| } |
| |
| /* NOTE: GetTTGlyphOutline() returns -1 if the glyphID is incorrect, |
| * but Get{Simple|Compound}GlyphOutline returns 0 in such a case. |
| * |
| * NOTE: glyphlist is the stack of glyphs traversed while constructing |
| * a composite glyph. This is a safequard against endless recursion |
| * in corrupted fonts. |
| */ |
| static int GetTTGlyphOutline(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray, TTGlyphMetrics *metrics, std::vector< sal_uInt32 >* glyphlist) |
| { |
| const sal_uInt8 *table = getTable( ttf, O_glyf ); |
| sal_Int16 numberOfContours; |
| int res; |
| *pointArray = 0; |
| |
| if (metrics) { |
| memset(metrics, 0, sizeof(TTGlyphMetrics)); /*- metrics is initialized to all zeroes */ |
| } |
| |
| if (glyphID >= ttf->nglyphs) return -1; /**/ |
| |
| const sal_uInt8* ptr = table + ttf->goffsets[glyphID]; |
| int length = ttf->goffsets[glyphID+1] - ttf->goffsets[glyphID]; |
| |
| if (length == 0) { /*- empty glyphs still have hmtx and vmtx metrics values */ |
| if (metrics) GetMetrics(ttf, glyphID, metrics); |
| return 0; |
| } |
| |
| numberOfContours = GetInt16(ptr, 0, 1); |
| |
| if (numberOfContours >= 0) |
| { |
| res=GetSimpleTTOutline(ttf, glyphID, pointArray, metrics); |
| } |
| else |
| { |
| std::vector< sal_uInt32 > aPrivList; |
| aPrivList.push_back( glyphID ); |
| res = GetCompoundTTOutline(ttf, glyphID, pointArray, metrics, glyphlist ? *glyphlist : aPrivList ); |
| } |
| |
| #ifdef DEBUG3 |
| { |
| int i; |
| FILE *out = fopen("points.dat", "a"); |
| assert(out != 0); |
| fprintf(out, "Glyph: %d\nPoints: %d\n", glyphID, res); |
| for (i=0; i<res; i++) { |
| fprintf(out, "%c ", ((*pointArray)[i].flags & 0x8000) ? 'X' : '.'); |
| fprintf(out, "%c ", ((*pointArray)[i].flags & 1) ? '+' : '-'); |
| fprintf(out, "%d %d\n", (*pointArray)[i].x, (*pointArray)[i].y); |
| } |
| fclose(out); |
| } |
| #endif |
| |
| return res; |
| } |
| |
| #ifndef NO_TYPE3 |
| |
| /*- returns the number of items in the path -*/ |
| |
| static int BSplineToPSPath(ControlPoint *srcA, int srcCount, PSPathElement **path) |
| { |
| std::vector< PSPathElement > aPathList; |
| int nPathCount = 0; |
| PSPathElement p( PS_NOOP ); |
| |
| int x0 = 0, y0 = 0, x1 = 0, y1 = 0, x2, y2, curx, cury; |
| int lastOff = 0; /*- last point was off-contour */ |
| int scflag = 1; /*- start contour flag */ |
| int ecflag = 0; /*- end contour flag */ |
| int cp = 0; /*- current point */ |
| int StartContour = 0, EndContour = 1; |
| |
| *path = 0; |
| |
| /* if (srcCount > 0) for(;;) */ |
| while (srcCount > 0) { /*- srcCount does not get changed inside the loop. */ |
| if (scflag) { |
| int l = cp; |
| StartContour = cp; |
| while (!(srcA[l].flags & 0x8000)) l++; |
| EndContour = l; |
| if (StartContour == EndContour) { |
| if (cp + 1 < srcCount) { |
| cp++; |
| continue; |
| } else { |
| break; |
| } |
| } |
| p = PSPathElement(PS_MOVETO); |
| if (!(srcA[cp].flags & 1)) { |
| if (!(srcA[EndContour].flags & 1)) { |
| p.x1 = x0 = (srcA[cp].x + srcA[EndContour].x + 1) / 2; |
| p.y1 = y0 = (srcA[cp].y + srcA[EndContour].y + 1) / 2; |
| } else { |
| p.x1 = x0 = srcA[EndContour].x; |
| p.y1 = y0 = srcA[EndContour].y; |
| } |
| } else { |
| p.x1 = x0 = srcA[cp].x; |
| p.y1 = y0 = srcA[cp].y; |
| cp++; |
| } |
| aPathList.push_back( p ); |
| lastOff = 0; |
| scflag = 0; |
| } |
| |
| curx = srcA[cp].x; |
| cury = srcA[cp].y; |
| |
| if (srcA[cp].flags & 1) |
| { |
| if (lastOff) |
| { |
| p = PSPathElement(PS_CURVETO); |
| p.x1 = x0 + (2 * (x1 - x0) + 1) / 3; |
| p.y1 = y0 + (2 * (y1 - y0) + 1) / 3; |
| p.x2 = x1 + (curx - x1 + 1) / 3; |
| p.y2 = y1 + (cury - y1 + 1) / 3; |
| p.x3 = curx; |
| p.y3 = cury; |
| aPathList.push_back( p ); |
| } |
| else |
| { |
| if (!(x0 == curx && y0 == cury)) |
| { /* eliminate empty lines */ |
| p = PSPathElement(PS_LINETO); |
| p.x1 = curx; |
| p.y1 = cury; |
| aPathList.push_back( p ); |
| } |
| } |
| x0 = curx; y0 = cury; lastOff = 0; |
| } |
| else |
| { |
| if (lastOff) |
| { |
| x2 = (x1 + curx + 1) / 2; |
| y2 = (y1 + cury + 1) / 2; |
| p = PSPathElement(PS_CURVETO); |
| p.x1 = x0 + (2 * (x1 - x0) + 1) / 3; |
| p.y1 = y0 + (2 * (y1 - y0) + 1) / 3; |
| p.x2 = x1 + (x2 - x1 + 1) / 3; |
| p.y2 = y1 + (y2 - y1 + 1) / 3; |
| p.x3 = x2; |
| p.y3 = y2; |
| aPathList.push_back( p ); |
| x0 = x2; y0 = y2; |
| x1 = curx; y1 = cury; |
| } else { |
| x1 = curx; y1 = cury; |
| } |
| lastOff = true; |
| } |
| |
| if (ecflag) { |
| aPathList.push_back( PSPathElement(PS_CLOSEPATH) ); |
| scflag = 1; |
| ecflag = 0; |
| cp = EndContour + 1; |
| if (cp >= srcCount) break; |
| continue; |
| } |
| |
| |
| if (cp == EndContour) { |
| cp = StartContour; |
| ecflag = true; |
| } else { |
| cp++; |
| } |
| } |
| |
| if( (nPathCount = (int)aPathList.size()) > 0) |
| { |
| *path = (PSPathElement*)calloc(nPathCount, sizeof(PSPathElement)); |
| assert(*path != 0); |
| memcpy( *path, &aPathList[0], nPathCount * sizeof(PSPathElement) ); |
| } |
| |
| return nPathCount; |
| } |
| |
| #endif |
| |
| /*- Extracts a string from the name table and allocates memory for it -*/ |
| |
| static char *nameExtract( const sal_uInt8* name, int nTableSize, int n, int dbFlag, sal_uInt16** ucs2result ) |
| { |
| int i; |
| char *res; |
| const sal_uInt8* ptr = name + GetUInt16(name, 4, 1) + GetUInt16(name + 6, 12 * n + 10, 1); |
| int len = GetUInt16(name+6, 12 * n + 8, 1); |
| |
| // sanity check |
| if( (len <= 0) || ((ptr+len) > (name+nTableSize)) ) |
| { |
| if( ucs2result ) |
| *ucs2result = NULL; |
| return NULL; |
| } |
| |
| if( ucs2result ) |
| *ucs2result = NULL; |
| if (dbFlag) { |
| res = (char*)malloc(1 + len/2); |
| assert(res != 0); |
| for (i = 0; i < len/2; i++) res[i] = *(ptr + i * 2 + 1); |
| res[len/2] = 0; |
| if( ucs2result ) |
| { |
| *ucs2result = (sal_uInt16*)malloc( len+2 ); |
| for (i = 0; i < len/2; i++ ) (*ucs2result)[i] = GetUInt16( ptr, 2*i, 1 ); |
| (*ucs2result)[len/2] = 0; |
| } |
| } else { |
| res = (char*)malloc(1 + len); |
| assert(res != 0); |
| memcpy(res, ptr, len); |
| res[len] = 0; |
| } |
| |
| return res; |
| } |
| |
| static int findname( const sal_uInt8 *name, sal_uInt16 n, sal_uInt16 platformID, |
| sal_uInt16 encodingID, sal_uInt16 languageID, sal_uInt16 nameID ) |
| { |
| int l = 0, r = n-1, i; |
| sal_uInt32 t1, t2; |
| sal_uInt32 m1, m2; |
| |
| if (n == 0) return -1; |
| |
| m1 = (platformID << 16) | encodingID; |
| m2 = (languageID << 16) | nameID; |
| |
| do { |
| i = (l + r) >> 1; |
| t1 = GetUInt32(name + 6, i * 12 + 0, 1); |
| t2 = GetUInt32(name + 6, i * 12 + 4, 1); |
| |
| if (! ((m1 < t1) || ((m1 == t1) && (m2 < t2)))) l = i + 1; |
| if (! ((m1 > t1) || ((m1 == t1) && (m2 > t2)))) r = i - 1; |
| } while (l <= r); |
| |
| if (l - r == 2) { |
| return l - 1; |
| } |
| |
| return -1; |
| } |
| |
| /* XXX marlett.ttf uses (3, 0, 1033) instead of (3, 1, 1033) and does not have any Apple tables. |
| * Fix: if (3, 1, 1033) is not found - need to check for (3, 0, 1033) |
| * |
| * /d/fonts/ttzh_tw/Big5/Hanyi/ma6b5p uses (1, 0, 19) for English strings, instead of (1, 0, 0) |
| * and does not have (3, 1, 1033) |
| * Fix: if (1, 0, 0) and (3, 1, 1033) are not found need to look for (1, 0, *) - that will |
| * require a change in algorithm |
| * |
| * /d/fonts/fdltest/Korean/h2drrm has unsorted names and a an unknown (to me) Mac LanguageID, |
| * but (1, 0, 1042) strings usable |
| * Fix: change algorithm, and use (1, 0, *) if both standard Mac and MS strings are not found |
| */ |
| |
| static void GetNames(TrueTypeFont *t) |
| { |
| const sal_uInt8* table = getTable( t, O_name ); |
| int nTableSize = getTableSize(t, O_name); |
| |
| if (nTableSize < 4) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf(stderr, "O_name table too small\n"); |
| #endif |
| return; |
| } |
| |
| sal_uInt16 n = GetUInt16(table, 2, 1); |
| int i, r; |
| sal_Bool bPSNameOK = sal_True; |
| |
| /* #129743# simple sanity check for name table entry count */ |
| if( nTableSize <= n * 12 + 6 ) |
| n = 0; |
| |
| /* PostScript name: preferred Microsoft */ |
| t->psname = NULL; |
| if ((r = findname(table, n, 3, 1, 0x0409, 6)) != -1) |
| t->psname = nameExtract(table, nTableSize, r, 1, NULL); |
| if ( ! t->psname && (r = findname(table, n, 1, 0, 0, 6)) != -1) |
| t->psname = nameExtract(table, nTableSize, r, 0, NULL); |
| if ( ! t->psname && (r = findname(table, n, 3, 0, 0x0409, 6)) != -1) |
| { |
| // some symbol fonts like Marlett have a 3,0 name! |
| t->psname = nameExtract(table, nTableSize, r, 1, NULL); |
| } |
| // for embedded font in Ghostscript PDFs |
| if ( ! t->psname && (r = findname(table, n, 2, 2, 0, 6)) != -1) |
| { |
| t->psname = nameExtract(table, nTableSize, r, 0, NULL); |
| } |
| if ( ! t->psname ) |
| { |
| if ( t->fname ) |
| { |
| char* pReverse = t->fname + strlen(t->fname); |
| /* take only last token of filename */ |
| while(pReverse != t->fname && *pReverse != '/') pReverse--; |
| if(*pReverse == '/') pReverse++; |
| t->psname = strdup(pReverse); |
| assert(t->psname != 0); |
| for (i=strlen(t->psname) - 1; i > 0; i--) |
| { |
| /*- Remove the suffix -*/ |
| if (t->psname[i] == '.' ) { |
| t->psname[i] = 0; |
| break; |
| } |
| } |
| } |
| else |
| t->psname = strdup( "Unknown" ); |
| } |
| |
| /* Font family and subfamily names: preferred Apple */ |
| t->family = NULL; |
| if ((r = findname(table, n, 0, 0, 0, 1)) != -1) |
| t->family = nameExtract(table, nTableSize, r, 1, &t->ufamily); |
| if ( ! t->family && (r = findname(table, n, 3, 1, 0x0409, 1)) != -1) |
| t->family = nameExtract(table, nTableSize, r, 1, &t->ufamily); |
| if ( ! t->family && (r = findname(table, n, 1, 0, 0, 1)) != -1) |
| t->family = nameExtract(table, nTableSize, r, 0, NULL); |
| if ( ! t->family && (r = findname(table, n, 3, 1, 0x0411, 1)) != -1) |
| t->family = nameExtract(table, nTableSize, r, 1, &t->ufamily); |
| if ( ! t->family && (r = findname(table, n, 3, 0, 0x0409, 1)) != -1) |
| t->family = nameExtract(table, nTableSize, r, 1, &t->ufamily); |
| if ( ! t->family ) |
| { |
| t->family = strdup(t->psname); |
| assert(t->family != 0); |
| } |
| |
| t->subfamily = NULL; |
| t->usubfamily = NULL; |
| if ((r = findname(table, n, 1, 0, 0, 2)) != -1) |
| t->subfamily = nameExtract(table, nTableSize, r, 0, &t->usubfamily); |
| if ( ! t->subfamily && (r = findname(table, n, 3, 1, 0x0409, 2)) != -1) |
| t->subfamily = nameExtract(table, nTableSize, r, 1, &t->usubfamily); |
| if ( ! t->subfamily ) |
| { |
| t->subfamily = strdup(""); |
| } |
| |
| /* #i60349# sanity check psname |
| * psname parctically has to be 7bit ascii and should not contains spaces |
| * there is a class of broken fonts which do not fulfill that at all, so let's try |
| * if the family name is 7bit ascii and take it instead if so |
| */ |
| /* check psname */ |
| for( i = 0; t->psname[i] != 0 && bPSNameOK; i++ ) |
| if( t->psname[ i ] < 33 || (t->psname[ i ] & 0x80) ) |
| bPSNameOK = sal_False; |
| if( bPSNameOK == sal_False ) |
| { |
| sal_Bool bReplace = sal_True; |
| /* check if family is a suitable replacement */ |
| if( t->ufamily && t->family ) |
| { |
| for( i = 0; t->ufamily[ i ] != 0 && bReplace; i++ ) |
| if( t->ufamily[ i ] < 33 || t->ufamily[ i ] > 127 ) |
| bReplace = sal_False; |
| if( bReplace ) |
| { |
| free( t->psname ); |
| t->psname = strdup( t->family ); |
| } |
| } |
| } |
| } |
| |
| enum cmapType { |
| CMAP_NOT_USABLE = -1, |
| CMAP_MS_Symbol = 10, |
| CMAP_MS_Unicode = 11, |
| CMAP_MS_ShiftJIS = 12, |
| CMAP_MS_Big5 = 13, |
| CMAP_MS_PRC = 14, |
| CMAP_MS_Wansung = 15, |
| CMAP_MS_Johab = 16 |
| }; |
| |
| #define MISSING_GLYPH_INDEX 0 |
| |
| /* |
| * getGlyph[0246]() functions and freinds are implemented by: |
| * @author Manpreet Singh |
| * getGlyph12() function and friends by: |
| * @author HDU |
| */ |
| static sal_uInt32 getGlyph0(const sal_uInt8* cmap, sal_uInt32 c) { |
| if (c <= 255) { |
| return *(cmap + 6 + c); |
| } else { |
| return MISSING_GLYPH_INDEX; |
| } |
| } |
| |
| typedef struct _subHeader2 { |
| sal_uInt16 firstCode; |
| sal_uInt16 entryCount; |
| sal_uInt16 idDelta; |
| sal_uInt16 idRangeOffset; |
| } subHeader2; |
| |
| static sal_uInt32 getGlyph2(const sal_uInt8 *cmap, sal_uInt32 c) { |
| sal_uInt16 *CMAP2 = (sal_uInt16 *) cmap; |
| sal_uInt8 theHighByte; |
| |
| sal_uInt8 theLowByte; |
| subHeader2* subHeader2s; |
| sal_uInt16* subHeader2Keys; |
| sal_uInt16 firstCode; |
| int k; |
| sal_uInt32 ToReturn; |
| |
| theHighByte = (sal_uInt8)((c >> 8) & 0x00ff); |
| theLowByte = (sal_uInt8)(c & 0x00ff); |
| subHeader2Keys = CMAP2 + 3; |
| subHeader2s = (subHeader2 *)(subHeader2Keys + 256); |
| k = Int16FromMOTA(subHeader2Keys[theHighByte]) / 8; |
| |
| if(k == 0) { |
| firstCode = Int16FromMOTA(subHeader2s[k].firstCode); |
| if(theLowByte >= firstCode && theLowByte < (firstCode + Int16FromMOTA(subHeader2s[k].entryCount))) { |
| return *((&(subHeader2s[0].idRangeOffset)) |
| + (Int16FromMOTA(subHeader2s[0].idRangeOffset)/2) /* + offset */ |
| + theLowByte /* + to_look */ |
| - Int16FromMOTA(subHeader2s[0].firstCode) |
| ); |
| } else { |
| return MISSING_GLYPH_INDEX; |
| } |
| } else if (k > 0) { |
| firstCode = Int16FromMOTA(subHeader2s[k].firstCode); |
| if(theLowByte >= firstCode && theLowByte < (firstCode + Int16FromMOTA(subHeader2s[k].entryCount))) { |
| ToReturn = *((&(subHeader2s[k].idRangeOffset)) |
| + (Int16FromMOTA(subHeader2s[k].idRangeOffset)/2) |
| + theLowByte - firstCode); |
| if(ToReturn == 0) { |
| return MISSING_GLYPH_INDEX; |
| } else { |
| ToReturn += Int16FromMOTA(subHeader2s[k].idDelta); |
| return (ToReturn & 0xFFFF); |
| } |
| } else { |
| return MISSING_GLYPH_INDEX; |
| } |
| } else { |
| return MISSING_GLYPH_INDEX; |
| } |
| } |
| |
| static sal_uInt32 getGlyph6(const sal_uInt8 *cmap, sal_uInt32 c) { |
| sal_uInt16 firstCode, lastCode, count; |
| sal_uInt16 *CMAP6 = (sal_uInt16 *) cmap; |
| |
| firstCode = Int16FromMOTA(*(CMAP6 + 3)); |
| count = Int16FromMOTA(*(CMAP6 + 4)); |
| lastCode = firstCode + count - 1; |
| if (c < firstCode || c > lastCode) { |
| return MISSING_GLYPH_INDEX; |
| } else { |
| return *((CMAP6 + 5)/*glyphIdArray*/ + (c - firstCode)); |
| } |
| } |
| |
| static sal_uInt16 GEbinsearch(sal_uInt16 *ar, sal_uInt16 length, sal_uInt16 toSearch) { |
| signed int low, mid, high, lastfound = 0xffff; |
| sal_uInt16 res; |
| if(length == (sal_uInt16)0 || length == (sal_uInt16)0xFFFF) { |
| return (sal_uInt16)0xFFFF; |
| } |
| low = 0; |
| high = length - 1; |
| while(high >= low) { |
| mid = (high + low)/2; |
| res = Int16FromMOTA(*(ar+mid)); |
| if(res >= toSearch) { |
| lastfound = mid; |
| high = --mid; |
| } else { |
| low = ++mid; |
| } |
| } |
| return (sal_uInt16)lastfound; |
| } |
| |
| |
| static sal_uInt32 getGlyph4(const sal_uInt8 *cmap, sal_uInt32 c) { |
| sal_uInt16 i; |
| int ToReturn; |
| sal_uInt16 segCount; |
| sal_uInt16 * startCode; |
| sal_uInt16 * endCode; |
| sal_uInt16 * idDelta; |
| /* sal_uInt16 * glyphIdArray; */ |
| sal_uInt16 * idRangeOffset; |
| sal_uInt16 * glyphIndexArray; |
| sal_uInt16 *CMAP4 = (sal_uInt16 *) cmap; |
| /* sal_uInt16 GEbinsearch(sal_uInt16 *ar, sal_uInt16 length, sal_uInt16 toSearch); */ |
| |
| segCount = Int16FromMOTA(*(CMAP4 + 3))/2; |
| endCode = CMAP4 + 7; |
| i = GEbinsearch(endCode, segCount, (sal_uInt16)c); |
| |
| if (i == (sal_uInt16) 0xFFFF) { |
| return MISSING_GLYPH_INDEX; |
| } |
| startCode = endCode + segCount + 1; |
| |
| if(Int16FromMOTA(startCode[i]) > c) { |
| return MISSING_GLYPH_INDEX; |
| } |
| idDelta = startCode + segCount; |
| idRangeOffset = idDelta + segCount; |
| glyphIndexArray = idRangeOffset + segCount; |
| |
| if(Int16FromMOTA(idRangeOffset[i]) != 0) { |
| c = Int16FromMOTA(*(&(idRangeOffset[i]) + (Int16FromMOTA(idRangeOffset[i])/2 + (c - Int16FromMOTA(startCode[i]))))); |
| } |
| |
| ToReturn = (Int16FromMOTA(idDelta[i]) + c) & 0xFFFF; |
| return ToReturn; |
| } |
| |
| static sal_uInt32 getGlyph12(const sal_uInt8 *pCmap, sal_uInt32 cChar) { |
| const sal_uInt32* pCMAP12 = (const sal_uInt32*)pCmap; |
| int nLength = Int32FromMOTA( pCMAP12[1] ); |
| int nGroups = Int32FromMOTA( pCMAP12[3] ); |
| int nLower = 0; |
| int nUpper = nGroups; |
| |
| if( nUpper > (nLength-16)/12 ) |
| nUpper = (nLength-16)/12; |
| |
| /* binary search in "segmented coverage" subtable */ |
| while( nLower < nUpper ) { |
| int nIndex = (nLower + nUpper) / 2; |
| const sal_uInt32* pEntry = &pCMAP12[ 4 + 3*nIndex ]; |
| sal_uInt32 cStart = Int32FromMOTA( pEntry[0] ); |
| sal_uInt32 cLast = Int32FromMOTA( pEntry[1] ); |
| if( cChar < cStart ) |
| nUpper = nIndex; |
| else if( cChar > cLast ) |
| nLower = nIndex + 1; |
| else { /* found matching entry! */ |
| sal_uInt32 nGlyph = Int32FromMOTA( pEntry[2] ); |
| nGlyph += cChar - cStart; |
| return nGlyph; |
| } |
| } |
| |
| return MISSING_GLYPH_INDEX; |
| } |
| |
| |
| static void FindCmap(TrueTypeFont *ttf) |
| { |
| const sal_uInt8* table = getTable(ttf, O_cmap); |
| sal_uInt32 table_size = getTableSize(ttf, O_cmap); |
| sal_uInt16 ncmaps = GetUInt16(table, 2, 1); |
| unsigned int i; |
| sal_uInt32 AppleUni = 0; // Apple Unicode |
| sal_uInt32 ThreeZero = 0; /* MS Symbol */ |
| sal_uInt32 ThreeOne = 0; /* MS UCS-2 */ |
| sal_uInt32 ThreeTwo = 0; /* MS ShiftJIS */ |
| sal_uInt32 ThreeThree = 0; /* MS Big5 */ |
| sal_uInt32 ThreeFour = 0; /* MS PRC */ |
| sal_uInt32 ThreeFive = 0; /* MS Wansung */ |
| sal_uInt32 ThreeSix = 0; /* MS Johab */ |
| |
| for (i = 0; i < ncmaps; i++) { |
| sal_uInt32 offset; |
| sal_uInt16 pID, eID; |
| |
| /* sanity check, cmap entry must lie within table */ |
| if( i*8+4 > table_size ) |
| break; |
| |
| pID = GetUInt16(table, 4 + i * 8, 1); |
| eID = GetUInt16(table, 6 + i * 8, 1); |
| offset = GetUInt32(table, 8 + i * 8, 1); |
| |
| /* sanity check, cmap must lie within file */ |
| if( (table - ttf->ptr) + offset > (sal_uInt32)ttf->fsize ) |
| continue; |
| |
| /* Unicode tables in Apple fonts */ |
| if (pID == 0) { |
| AppleUni = offset; |
| } |
| |
| if (pID == 3) { |
| switch (eID) { |
| case 0: ThreeZero = offset; break; |
| case 10: // UCS-4 |
| case 1: ThreeOne = offset; break; |
| case 2: ThreeTwo = offset; break; |
| case 3: ThreeThree = offset; break; |
| case 4: ThreeFour = offset; break; |
| case 5: ThreeFive = offset; break; |
| case 6: ThreeSix = offset; break; |
| } |
| } |
| } |
| |
| // fall back to AppleUnicode if there are no ThreeOne/Threezero tables |
| if( AppleUni && !ThreeZero && !ThreeOne) |
| ThreeOne = AppleUni; |
| |
| if (ThreeOne) { |
| ttf->cmapType = CMAP_MS_Unicode; |
| ttf->cmap = table + ThreeOne; |
| } else if (ThreeTwo) { |
| ttf->cmapType = CMAP_MS_ShiftJIS; |
| ttf->cmap = table + ThreeTwo; |
| } else if (ThreeThree) { |
| ttf->cmapType = CMAP_MS_Big5; |
| ttf->cmap = table + ThreeThree; |
| } else if (ThreeFour) { |
| ttf->cmapType = CMAP_MS_PRC; |
| ttf->cmap = table + ThreeFour; |
| } else if (ThreeFive) { |
| ttf->cmapType = CMAP_MS_Wansung; |
| ttf->cmap = table + ThreeFive; |
| } else if (ThreeSix) { |
| ttf->cmapType = CMAP_MS_Johab; |
| ttf->cmap = table + ThreeSix; |
| } else if (ThreeZero) { |
| ttf->cmapType = CMAP_MS_Symbol; |
| ttf->cmap = table + ThreeZero; |
| } else { |
| ttf->cmapType = CMAP_NOT_USABLE; |
| ttf->cmap = 0; |
| } |
| |
| if (ttf->cmapType != CMAP_NOT_USABLE) { |
| switch (GetUInt16(ttf->cmap, 0, 1)) { |
| case 0: ttf->mapper = getGlyph0; break; |
| case 2: ttf->mapper = getGlyph2; break; |
| case 4: ttf->mapper = getGlyph4; break; |
| case 6: ttf->mapper = getGlyph6; break; |
| case 12: ttf->mapper= getGlyph12; break; |
| default: |
| #if OSL_DEBUG_LEVEL > 1 |
| /*- if the cmap table is really broken */ |
| printf("%s: %d is not a recognized cmap format.\n", ttf->fname, GetUInt16(ttf->cmap, 0, 1)); |
| #endif |
| ttf->cmapType = CMAP_NOT_USABLE; |
| ttf->cmap = 0; |
| ttf->mapper = 0; |
| } |
| } |
| } |
| |
| static void GetKern(TrueTypeFont *ttf) |
| { |
| const sal_uInt8* table = getTable(ttf, O_kern); |
| const sal_uInt8 *ptr; |
| |
| if( !table ) |
| goto badtable; |
| |
| if (GetUInt16(table, 0, 1) == 0) { /* Traditional Microsoft style table with sal_uInt16 version and nTables fields */ |
| ttf->nkern = GetUInt16(table, 2, 1); |
| ttf->kerntables = (const sal_uInt8**)calloc(ttf->nkern, sizeof(sal_uInt8 *)); |
| assert(ttf->kerntables != 0); |
| memset(ttf->kerntables, 0, ttf->nkern * sizeof(sal_uInt8 *)); |
| ttf->kerntype = KT_MICROSOFT; |
| ptr = table + 4; |
| for( unsigned i = 0; i < ttf->nkern; ++i) { |
| ttf->kerntables[i] = ptr; |
| ptr += GetUInt16(ptr, 2, 1); |
| /* sanity check */ |
| if( ptr > ttf->ptr+ttf->fsize ) |
| { |
| free( ttf->kerntables ); |
| goto badtable; |
| } |
| } |
| return; |
| } |
| |
| if (GetUInt32(table, 0, 1) == 0x00010000) { /* MacOS style kern tables: fixed32 version and sal_uInt32 nTables fields */ |
| ttf->nkern = GetUInt32(table, 4, 1); |
| ttf->kerntables = (const sal_uInt8**)calloc(ttf->nkern, sizeof(sal_uInt8*)); |
| assert(ttf->kerntables != 0); |
| memset(ttf->kerntables, 0, ttf->nkern * sizeof(sal_uInt8 *)); |
| ttf->kerntype = KT_APPLE_NEW; |
| ptr = table + 8; |
| for( unsigned i = 0; i < ttf->nkern; ++i) { |
| ttf->kerntables[i] = ptr; |
| ptr += GetUInt32(ptr, 0, 1); |
| /* sanity check; there are some fonts that are broken in this regard */ |
| if( ptr > ttf->ptr+ttf->fsize ) |
| { |
| free( ttf->kerntables ); |
| goto badtable; |
| } |
| } |
| return; |
| } |
| |
| badtable: |
| ttf->kerntype = KT_NONE; |
| ttf->kerntables = 0; |
| |
| return; |
| } |
| |
| #ifdef TEST5 |
| /* KernGlyphsPrim?() functions expect the caller to ensure the validity of their arguments and |
| * that x and y elements of the kern array are initialized to zeroes |
| */ |
| static void KernGlyphsPrim1(TrueTypeFont *ttf, sal_uInt16 *glyphs, int nglyphs, int wmode, KernData *kern) |
| { |
| (void)ttf; /* avoid warning */ |
| (void)glyphs; /* avoid warning */ |
| (void)nglyphs; /* avoid warning */ |
| (void)wmode; /* avoid warning */ |
| (void)nglyphs; /* avoid warning */ |
| (void)kern; /* avoid warning */ |
| fprintf(stderr, "MacOS kerning tables have not been implemented yet!\n"); |
| } |
| |
| static void KernGlyphsPrim2(TrueTypeFont *ttf, sal_uInt16 *glyphs, int nglyphs, int wmode, KernData *kern) |
| { |
| sal_uInt32 i, j; |
| sal_uInt32 gpair; |
| |
| if( ! nglyphs ) |
| return; |
| |
| for (i = 0; i < (sal_uInt32)nglyphs - 1; i++) { |
| gpair = (glyphs[i] << 16) | glyphs[i+1]; |
| #ifdef DEBUG2 |
| /* All fonts with MS kern table that I've seen so far contain just one kern subtable. |
| * MS kern documentation is very poor and I doubt that font developers will be using |
| * several subtables. I expect them to be using OpenType tables instead. |
| * According to MS documention, format 2 subtables are not supported by Windows and OS/2. |
| */ |
| if (ttf->nkern > 1) { |
| fprintf(stderr, "KernGlyphsPrim2: %d kern tables found.\n", ttf->nkern); |
| } |
| #endif |
| for (j = 0; j < ttf->nkern; j++) { |
| sal_uInt16 coverage = GetUInt16(ttf->kerntables[j], 4, 1); |
| sal_uInt8 *ptr; |
| int npairs; |
| sal_uInt32 t; |
| int l, r, k; |
| |
| if (! ((coverage & 1) ^ wmode)) continue; |
| if ((coverage & 0xFFFE) != 0) { |
| #ifdef DEBUG2 |
| fprintf(stderr, "KernGlyphsPrim2: coverage flags are not supported: %04X.\n", coverage); |
| #endif |
| continue; |
| } |
| ptr = ttf->kerntables[j]; |
| npairs = GetUInt16(ptr, 6, 1); |
| ptr += 14; |
| l = 0; |
| r = npairs; |
| do { |
| k = (l + r) >> 1; |
| t = GetUInt32(ptr, k * 6, 1); |
| if (gpair >= t) l = k + 1; |
| if (gpair <= t) r = k - 1; |
| } while (l <= r); |
| if (l - r == 2) { |
| if (!wmode) { |
| kern[i].x = XUnits(ttf->unitsPerEm, GetInt16(ptr, 4 + (l-1) * 6, 1)); |
| } else { |
| kern[i].y = XUnits(ttf->unitsPerEm, GetInt16(ptr, 4 + (l-1) * 6, 1)); |
| } |
| /* !wmode ? kern[i].x : kern[i].y = GetInt16(ptr, 4 + (l-1) * 6, 1); */ |
| } |
| } |
| } |
| } |
| #endif |
| |
| /*- Public functions */ /*FOLD00*/ |
| |
| int CountTTCFonts(const char* fname) |
| { |
| int nFonts = 0; |
| sal_uInt8 buffer[12]; |
| FILE* fd = fopen(fname, "rb"); |
| if( fd ) { |
| if (fread(buffer, 1, 12, fd) == 12) { |
| if(GetUInt32(buffer, 0, 1) == T_ttcf ) |
| nFonts = GetUInt32(buffer, 8, 1); |
| } |
| fclose(fd); |
| } |
| return nFonts; |
| } |
| |
| static void allocTrueTypeFont( TrueTypeFont** ttf ) |
| { |
| *ttf = (TrueTypeFont*)calloc(1,sizeof(TrueTypeFont)); |
| if( *ttf != NULL ) |
| { |
| (*ttf)->tag = 0; |
| (*ttf)->fname = 0; |
| (*ttf)->fsize = -1; |
| (*ttf)->ptr = 0; |
| (*ttf)->nglyphs = 0xFFFFFFFF; |
| (*ttf)->pGSubstitution = 0; |
| } |
| } |
| |
| /* forward declariotn for the two entry points to use*/ |
| static int doOpenTTFont( sal_uInt32 facenum, TrueTypeFont* t ); |
| |
| #if !defined(WIN32) && !defined(OS2) |
| int OpenTTFontFile( const char* fname, sal_uInt32 facenum, TrueTypeFont** ttf ) |
| { |
| int ret, fd = -1; |
| struct stat st; |
| |
| if (!fname || !*fname) return SF_BADFILE; |
| |
| allocTrueTypeFont( ttf ); |
| if( ! *ttf ) |
| return SF_MEMORY; |
| |
| (*ttf)->fname = strdup(fname); |
| if( ! (*ttf)->fname ) |
| { |
| ret = SF_MEMORY; |
| goto cleanup; |
| } |
| |
| fd = open(fname, O_RDONLY); |
| |
| if (fd == -1) { |
| ret = SF_BADFILE; |
| goto cleanup; |
| } |
| |
| if (fstat(fd, &st) == -1) { |
| ret = SF_FILEIO; |
| goto cleanup; |
| } |
| |
| (*ttf)->fsize = st.st_size; |
| |
| /* On Mac OS, most likely will happen if a Mac user renames a font file |
| * to be .ttf when its really a Mac resource-based font. |
| * Size will be 0, but fonts smaller than 4 bytes would be broken anyway. |
| */ |
| if ((*ttf)->fsize == 0) { |
| ret = SF_BADFILE; |
| goto cleanup; |
| } |
| |
| if (((*ttf)->ptr = (sal_uInt8 *) mmap(0, (*ttf)->fsize, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { |
| ret = SF_MEMORY; |
| goto cleanup; |
| } |
| close(fd); |
| |
| return doOpenTTFont( facenum, *ttf ); |
| |
| cleanup: |
| if (fd != -1) close(fd); |
| /*- t and t->fname have been allocated! */ |
| free((*ttf)->fname); |
| free(*ttf); |
| *ttf = NULL; |
| return ret; |
| } |
| #endif |
| |
| int OpenTTFontBuffer(void* pBuffer, sal_uInt32 nLen, sal_uInt32 facenum, TrueTypeFont** ttf) |
| { |
| allocTrueTypeFont( ttf ); |
| if( *ttf == NULL ) |
| return SF_MEMORY; |
| |
| (*ttf)->fname = NULL; |
| (*ttf)->fsize = nLen; |
| (*ttf)->ptr = (sal_uInt8*)pBuffer; |
| |
| return doOpenTTFont( facenum, *ttf ); |
| } |
| |
| static int doOpenTTFont( sal_uInt32 facenum, TrueTypeFont* t ) |
| { |
| int i; |
| sal_uInt32 length, tag; |
| sal_uInt32 tdoffset = 0; /* offset to TableDirectory in a TTC file. For TTF files is 0 */ |
| int indexfmt, k; |
| |
| sal_uInt32 version = GetInt32(t->ptr, 0, 1); |
| |
| if ((version == 0x00010000) || (version == T_true)) { |
| tdoffset = 0; |
| } else if (version == T_otto) { /* PS-OpenType font */ |
| tdoffset = 0; |
| } else if (version == T_ttcf) { /* TrueType collection */ |
| if (GetUInt32(t->ptr, 4, 1) != 0x00010000) { |
| CloseTTFont(t); |
| return SF_TTFORMAT; |
| } |
| if (facenum >= GetUInt32(t->ptr, 8, 1)) { |
| CloseTTFont(t); |
| return SF_FONTNO; |
| } |
| tdoffset = GetUInt32(t->ptr, 12 + 4 * facenum, 1); |
| } else { |
| CloseTTFont(t); |
| return SF_TTFORMAT; |
| } |
| |
| #ifdef DEBUG2 |
| fprintf(stderr, "tdoffset: %d\n", tdoffset); |
| #endif |
| |
| /* magic number */ |
| t->tag = TTFontClassTag; |
| |
| t->ntables = GetUInt16(t->ptr + tdoffset, 4, 1); |
| if( t->ntables >= 128 ) |
| return SF_TTFORMAT; |
| |
| t->tables = (const sal_uInt8**)calloc(NUM_TAGS, sizeof(sal_uInt8*)); |
| assert(t->tables != 0); |
| t->tlens = (sal_uInt32*)calloc(NUM_TAGS, sizeof(sal_uInt32)); |
| assert(t->tlens != 0); |
| |
| memset(t->tables, 0, NUM_TAGS * sizeof(void *)); |
| memset(t->tlens, 0, NUM_TAGS * sizeof(sal_uInt32)); |
| |
| /* parse the tables */ |
| for (i=0; i<(int)t->ntables; i++) { |
| int nIndex; |
| tag = GetUInt32(t->ptr + tdoffset + 12, 16 * i, 1); |
| switch( tag ) { |
| case T_maxp: nIndex = O_maxp; break; |
| case T_glyf: nIndex = O_glyf; break; |
| case T_head: nIndex = O_head; break; |
| case T_loca: nIndex = O_loca; break; |
| case T_name: nIndex = O_name; break; |
| case T_hhea: nIndex = O_hhea; break; |
| case T_hmtx: nIndex = O_hmtx; break; |
| case T_cmap: nIndex = O_cmap; break; |
| case T_vhea: nIndex = O_vhea; break; |
| case T_vmtx: nIndex = O_vmtx; break; |
| case T_OS2 : nIndex = O_OS2; break; |
| case T_post: nIndex = O_post; break; |
| case T_kern: nIndex = O_kern; break; |
| case T_cvt : nIndex = O_cvt; break; |
| case T_prep: nIndex = O_prep; break; |
| case T_fpgm: nIndex = O_fpgm; break; |
| case T_gsub: nIndex = O_gsub; break; |
| case T_CFF: nIndex = O_CFF; break; |
| default: nIndex = -1; break; |
| } |
| if( nIndex >= 0 ) { |
| sal_uInt32 nTableOffset = GetUInt32(t->ptr + tdoffset + 12, 16 * i + 8, 1); |
| length = GetUInt32(t->ptr + tdoffset + 12, 16 * i + 12, 1); |
| t->tables[nIndex] = t->ptr + nTableOffset; |
| t->tlens[nIndex] = length; |
| } |
| } |
| |
| /* Fixup offsets when only a TTC extract was provided */ |
| if( facenum == (sal_uInt32)~0 ) { |
| sal_uInt8* pHead = (sal_uInt8*)t->tables[O_head]; |
| if( !pHead ) |
| return SF_TTFORMAT; |
| /* limit Head candidate to TTC extract's limits */ |
| if( pHead > t->ptr + (t->fsize - 54) ) |
| pHead = t->ptr + (t->fsize - 54); |
| /* TODO: find better method than searching head table's magic */ |
| sal_uInt8* p = NULL; |
| for( p = pHead + 12; p > t->ptr; --p ) { |
| if( p[0]==0x5F && p[1]==0x0F && p[2]==0x3C && p[3]==0xF5 ) { |
| int nDelta = (pHead + 12) - p, j; |
| if( nDelta ) |
| for( j=0; j<NUM_TAGS; ++j ) |
| if( t->tables[j] ) |
| *(char**)&t->tables[j] -= nDelta; |
| break; |
| } |
| } |
| if( p <= t->ptr ) |
| return SF_TTFORMAT; |
| } |
| |
| /* Check the table offsets after TTC correction */ |
| for (i=0; i<NUM_TAGS; i++) { |
| /* sanity check: table must lay completely within the file |
| * at this point one could check the checksum of all contained |
| * tables, but this would be quite time intensive. |
| * Try to fix tables, so we can cope with minor problems. |
| */ |
| |
| if( (sal_uInt8*)t->tables[i] < t->ptr ) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| if( t->tables[i] ) |
| fprintf( stderr, "font file %s has bad table offset %d (tagnum=%d)\n", t->fname, (sal_uInt8*)t->tables[i]-t->ptr, i ); |
| #endif |
| t->tlens[i] = 0; |
| t->tables[i] = NULL; |
| } |
| else if( (sal_uInt8*)t->tables[i] + t->tlens[i] > t->ptr + t->fsize ) |
| { |
| int nMaxLen = (t->ptr + t->fsize) - (sal_uInt8*)t->tables[i]; |
| if( nMaxLen < 0 ) |
| nMaxLen = 0; |
| t->tlens[i] = nMaxLen; |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf( stderr, "font file %s has too big table (tagnum=%d)\n", t->fname, i ); |
| #endif |
| } |
| } |
| |
| /* At this point TrueTypeFont is constructed, now need to verify the font format |
| and read the basic font properties */ |
| |
| /* The following tables are absolutely required: |
| * maxp, head, name, cmap |
| */ |
| |
| if( !(getTable(t, O_maxp) && getTable(t, O_head) && getTable(t, O_name) && getTable(t, O_cmap)) ) { |
| CloseTTFont(t); |
| return SF_TTFORMAT; |
| } |
| |
| const sal_uInt8* table = getTable(t, O_maxp); |
| t->nglyphs = GetUInt16(table, 4, 1); |
| |
| table = getTable(t, O_head); |
| t->unitsPerEm = GetUInt16(table, 18, 1); |
| indexfmt = GetInt16(table, 50, 1); |
| |
| if( ((indexfmt != 0) && (indexfmt != 1)) || (t->unitsPerEm <= 0) ) { |
| CloseTTFont(t); |
| return SF_TTFORMAT; |
| } |
| |
| if( getTable(t, O_glyf) && getTable(t, O_loca) ) { /* TTF or TTF-OpenType */ |
| k = (getTableSize(t, O_loca) / (indexfmt ? 4 : 2)) - 1; |
| if( k < (int)t->nglyphs ) /* Hack for broken Chinese fonts */ |
| t->nglyphs = k; |
| |
| table = getTable(t, O_loca); |
| t->goffsets = (sal_uInt32 *) calloc(1+t->nglyphs, sizeof(sal_uInt32)); |
| assert(t->goffsets != 0); |
| |
| for( i = 0; i <= (int)t->nglyphs; ++i ) |
| t->goffsets[i] = indexfmt ? GetUInt32(table, i << 2, 1) : (sal_uInt32)GetUInt16(table, i << 1, 1) << 1; |
| } else if( getTable(t, O_CFF) ) { /* PS-OpenType */ |
| t->goffsets = (sal_uInt32 *) calloc(1+t->nglyphs, sizeof(sal_uInt32)); |
| /* TODO: implement to get subsetting */ |
| assert(t->goffsets != 0); |
| } else { |
| CloseTTFont(t); |
| return SF_TTFORMAT; |
| } |
| |
| table = getTable(t, O_hhea); |
| t->numberOfHMetrics = (table != 0) ? GetUInt16(table, 34, 1) : 0; |
| |
| table = getTable(t, O_vhea); |
| t->numOfLongVerMetrics = (table != 0) ? GetUInt16(table, 34, 1) : 0; |
| |
| GetNames(t); |
| FindCmap(t); |
| GetKern(t); |
| ReadGSUB( t, 0, 0 ); |
| |
| return SF_OK; |
| } |
| |
| void CloseTTFont(TrueTypeFont *ttf) /*FOLD01*/ |
| { |
| if (ttf->tag != TTFontClassTag) return; |
| |
| #if !defined(WIN32) && !defined(OS2) |
| if( ttf->fname ) |
| munmap((char *) ttf->ptr, ttf->fsize); |
| #endif |
| free(ttf->fname); |
| free(ttf->goffsets); |
| free(ttf->psname); |
| free(ttf->family); |
| if( ttf->ufamily ) |
| free( ttf->ufamily ); |
| free(ttf->subfamily); |
| if( ttf->usubfamily ) |
| free( ttf->usubfamily ); |
| free(ttf->tables); |
| free(ttf->tlens); |
| free(ttf->kerntables); |
| |
| ReleaseGSUB(ttf); |
| |
| free(ttf); |
| return; |
| } |
| |
| int GetTTGlyphPoints(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray) |
| { |
| return GetTTGlyphOutline(ttf, glyphID, pointArray, 0, 0); |
| } |
| |
| int GetTTGlyphComponents(TrueTypeFont *ttf, sal_uInt32 glyphID, std::vector< sal_uInt32 >& glyphlist) |
| { |
| int n = 1; |
| |
| if( glyphID >= ttf->nglyphs ) |
| return 0; |
| |
| const sal_uInt8* glyf = getTable(ttf, O_glyf); |
| const sal_uInt8* ptr = glyf + ttf->goffsets[glyphID]; |
| |
| glyphlist.push_back( glyphID ); |
| |
| if (GetInt16(ptr, 0, 1) == -1) { |
| sal_uInt16 flags, index; |
| ptr += 10; |
| do { |
| flags = GetUInt16(ptr, 0, 1); |
| index = GetUInt16(ptr, 2, 1); |
| |
| ptr += 4; |
| n += GetTTGlyphComponents(ttf, index, glyphlist); |
| |
| if (flags & ARG_1_AND_2_ARE_WORDS) { |
| ptr += 4; |
| } else { |
| ptr += 2; |
| } |
| |
| if (flags & WE_HAVE_A_SCALE) { |
| ptr += 2; |
| } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) { |
| ptr += 4; |
| } else if (flags & WE_HAVE_A_TWO_BY_TWO) { |
| ptr += 8; |
| } |
| } while (flags & MORE_COMPONENTS); |
| } |
| |
| return n; |
| } |
| |
| #ifndef NO_TYPE3 |
| int CreateT3FromTTGlyphs(TrueTypeFont *ttf, FILE *outf, const char *fname, /*FOLD00*/ |
| sal_uInt16 *glyphArray, sal_uInt8 *encoding, int nGlyphs, |
| int wmode) |
| { |
| ControlPoint *pa; |
| PSPathElement *path; |
| int i, j, r, n; |
| const sal_uInt8* table = getTable(ttf, O_head); |
| TTGlyphMetrics metrics; |
| int UPEm = ttf->unitsPerEm; |
| |
| const char *h01 = "%%!PS-AdobeFont-%d.%d-%d.%d\n"; |
| const char *h02 = "%% Creator: %s %s %s\n"; |
| const char *h09 = "%% Original font name: %s\n"; |
| |
| const char *h10 = |
| "30 dict begin\n" |
| "/PaintType 0 def\n" |
| "/FontType 3 def\n" |
| "/StrokeWidth 0 def\n"; |
| |
| const char *h11 = "/FontName (%s) cvn def\n"; |
| |
| /* |
| const char *h12 = "%/UniqueID %d def\n"; |
| */ |
| const char *h13 = "/FontMatrix [.001 0 0 .001 0 0] def\n"; |
| const char *h14 = "/FontBBox [%d %d %d %d] def\n"; |
| |
| const char *h15= |
| "/Encoding 256 array def\n" |
| " 0 1 255 {Encoding exch /.notdef put} for\n"; |
| |
| const char *h16 = " Encoding %d /glyph%d put\n"; |
| const char *h17 = "/XUID [103 0 0 16#%08X %d 16#%08X 16#%08X] def\n"; |
| |
| const char *h30 = "/CharProcs %d dict def\n"; |
| const char *h31 = " CharProcs begin\n"; |
| const char *h32 = " /.notdef {} def\n"; |
| const char *h33 = " /glyph%d {\n"; |
| const char *h34 = " } bind def\n"; |
| const char *h35 = " end\n"; |
| |
| const char *h40 = |
| "/BuildGlyph {\n" |
| " exch /CharProcs get exch\n" |
| " 2 copy known not\n" |
| " {pop /.notdef} if\n" |
| " get exec\n" |
| "} bind def\n" |
| "/BuildChar {\n" |
| " 1 index /Encoding get exch get\n" |
| " 1 index /BuildGlyph get exec\n" |
| "} bind def\n" |
| "currentdict end\n"; |
| |
| const char *h41 = "(%s) cvn exch definefont pop\n"; |
| |
| |
| if (!((nGlyphs > 0) && (nGlyphs <= 256))) return SF_GLYPHNUM; |
| if (!glyphArray) return SF_BADARG; |
| if (!fname) fname = ttf->psname; |
| |
| fprintf(outf, h01, GetInt16(table, 0, 1), GetUInt16(table, 2, 1), GetInt16(table, 4, 1), GetUInt16(table, 6, 1)); |
| fprintf(outf, h02, modname, modver, modextra); |
| fprintf(outf, h09, ttf->psname); |
| |
| fprintf(outf, h10); |
| fprintf(outf, h11, fname); |
| /* fprintf(outf, h12, 4000000); */ |
| |
| /* XUID generation: |
| * 103 0 0 C1 C2 C3 C4 |
| * C1 - CRC-32 of the entire source TrueType font |
| * C2 - number of glyphs in the subset |
| * C3 - CRC-32 of the glyph array |
| * C4 - CRC-32 of the encoding array |
| * |
| * All CRC-32 numbers are presented as hexadecimal numbers |
| */ |
| |
| fprintf(outf, h17, rtl_crc32(0, ttf->ptr, ttf->fsize), nGlyphs, rtl_crc32(0, glyphArray, nGlyphs * 2), rtl_crc32(0, encoding, nGlyphs)); |
| fprintf(outf, h13); |
| fprintf(outf, h14, XUnits(UPEm, GetInt16(table, 36, 1)), XUnits(UPEm, GetInt16(table, 38, 1)), XUnits(UPEm, GetInt16(table, 40, 1)), XUnits(UPEm, GetInt16(table, 42, 1))); |
| fprintf(outf, h15); |
| |
| for (i = 0; i < nGlyphs; i++) { |
| fprintf(outf, h16, encoding[i], i); |
| } |
| |
| fprintf(outf, h30, nGlyphs+1); |
| fprintf(outf, h31); |
| fprintf(outf, h32); |
| |
| for (i = 0; i < nGlyphs; i++) { |
| fprintf(outf, h33, i); |
| r = GetTTGlyphOutline(ttf, glyphArray[i] < ttf->nglyphs ? glyphArray[i] : 0, &pa, &metrics, 0); |
| |
| if (r > 0) { |
| n = BSplineToPSPath(pa, r, &path); |
| } else { |
| n = 0; /* glyph might have zero contours but valid metrics ??? */ |
| path = 0; |
| if (r < 0) { /* glyph is not present in the font - pa array was not allocated, so no need to free it */ |
| continue; |
| } |
| } |
| fprintf(outf, "\t%d %d %d %d %d %d setcachedevice\n", |
| wmode == 0 ? XUnits(UPEm, metrics.aw) : 0, |
| wmode == 0 ? 0 : -XUnits(UPEm, metrics.ah), |
| XUnits(UPEm, metrics.xMin), |
| XUnits(UPEm, metrics.yMin), |
| XUnits(UPEm, metrics.xMax), |
| XUnits(UPEm, metrics.yMax)); |
| |
| for (j = 0; j < n; j++) |
| { |
| switch (path[j].type) |
| { |
| case PS_MOVETO: |
| fprintf(outf, "\t%d %d moveto\n", XUnits(UPEm, path[j].x1), XUnits(UPEm, path[j].y1)); |
| break; |
| |
| case PS_LINETO: |
| fprintf(outf, "\t%d %d lineto\n", XUnits(UPEm, path[j].x1), XUnits(UPEm, path[j].y1)); |
| break; |
| |
| case PS_CURVETO: |
| fprintf(outf, "\t%d %d %d %d %d %d curveto\n", XUnits(UPEm, path[j].x1), XUnits(UPEm, path[j].y1), XUnits(UPEm, path[j].x2), XUnits(UPEm, path[j].y2), XUnits(UPEm, path[j].x3), XUnits(UPEm, path[j].y3)); |
| break; |
| |
| case PS_CLOSEPATH: |
| fprintf(outf, "\tclosepath\n"); |
| break; |
| case PS_NOOP: |
| break; |
| } |
| } |
| if (n > 0) fprintf(outf, "\tfill\n"); /* if glyph is not a whitespace character */ |
| |
| fprintf(outf, h34); |
| |
| free(pa); |
| free(path); |
| } |
| fprintf(outf, h35); |
| |
| fprintf(outf, h40); |
| fprintf(outf, h41, fname); |
| |
| return SF_OK; |
| } |
| #endif |
| |
| #ifndef NO_TTCR |
| int CreateTTFromTTGlyphs(TrueTypeFont *ttf, |
| const char *fname, |
| sal_uInt16 *glyphArray, |
| sal_uInt8 *encoding, |
| int nGlyphs, |
| int nNameRecs, |
| NameRecord *nr, |
| sal_uInt32 flags) |
| { |
| TrueTypeCreator *ttcr; |
| TrueTypeTable *head=0, *hhea=0, *maxp=0, *cvt=0, *prep=0, *glyf=0, *fpgm=0, *cmap=0, *name=0, *post = 0, *os2 = 0; |
| int i; |
| int res; |
| |
| TrueTypeCreatorNewEmpty(T_true, &ttcr); |
| |
| /** name **/ |
| |
| if (flags & TTCF_AutoName) { |
| /* not implemented yet |
| NameRecord *names; |
| NameRecord newname; |
| int n = GetTTNameRecords(ttf, &names); |
| int n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0, n6 = 0; |
| sal_uInt8 *cp1; |
| sal_uInt8 suffix[32]; |
| sal_uInt32 c1 = crc32(glyphArray, nGlyphs * 2); |
| sal_uInt32 c2 = crc32(encoding, nGlyphs); |
| int len; |
| snprintf(suffix, 31, "S%08X%08X-%d", c1, c2, nGlyphs); |
| |
| name = TrueTypeTableNew_name(0, 0); |
| for (i = 0; i < n; i++) { |
| if (names[i].platformID == 1 && names[i].encodingID == 0 && names[i].languageID == 0 && names[i].nameID == 1) { |
| |
| memcpy(newname, names+i, sizeof(NameRecord)); |
| newname.slen = name[i].slen + strlen(suffix); |
| */ |
| const sal_uInt8 ptr[] = {0,'T',0,'r',0,'u',0,'e',0,'T',0,'y',0,'p',0,'e',0,'S',0,'u',0,'b',0,'s',0,'e',0,'t'}; |
| NameRecord n1 = {1, 0, 0, 6, 14, (sal_uInt8*)"TrueTypeSubset"}; |
| NameRecord n2 = {3, 1, 1033, 6, 28, 0}; |
| n2.sptr = (sal_uInt8 *) ptr; |
| name = TrueTypeTableNew_name(0, 0); |
| nameAdd(name, &n1); |
| nameAdd(name, &n2); |
| } else { |
| if (nNameRecs == 0) { |
| NameRecord *names; |
| int n = GetTTNameRecords(ttf, &names); |
| name = TrueTypeTableNew_name(n, names); |
| DisposeNameRecords(names, n); |
| } else { |
| name = TrueTypeTableNew_name(nNameRecs, nr); |
| } |
| } |
| |
| /** maxp **/ |
| maxp = TrueTypeTableNew_maxp(getTable(ttf, O_maxp), getTableSize(ttf, O_maxp)); |
| |
| /** hhea **/ |
| const sal_uInt8* p = getTable(ttf, O_hhea); |
| if (p) { |
| hhea = TrueTypeTableNew_hhea(GetUInt16(p, 4, 1), GetUInt16(p, 6, 1), GetUInt16(p, 8, 1), GetUInt16(p, 18, 1), GetUInt16(p, 20, 1)); |
| } else { |
| hhea = TrueTypeTableNew_hhea(0, 0, 0, 0, 0); |
| } |
| |
| /** head **/ |
| |
| p = getTable(ttf, O_head); |
| assert(p != 0); |
| head = TrueTypeTableNew_head(GetUInt32(p, 4, 1), |
| GetUInt16(p, 16, 1), |
| GetUInt16(p, 18, 1), |
| p+20, |
| GetUInt16(p, 44, 1), |
| GetUInt16(p, 46, 1), |
| GetInt16(p, 48, 1)); |
| |
| |
| /** glyf **/ |
| |
| glyf = TrueTypeTableNew_glyf(); |
| sal_uInt32* gID = (sal_uInt32*)scalloc(nGlyphs, sizeof(sal_uInt32)); |
| |
| for (i = 0; i < nGlyphs; i++) { |
| gID[i] = glyfAdd(glyf, GetTTRawGlyphData(ttf, glyphArray[i]), ttf); |
| } |
| |
| /** cmap **/ |
| cmap = TrueTypeTableNew_cmap(); |
| |
| for (i=0; i < nGlyphs; i++) { |
| cmapAdd(cmap, 0x010000, encoding[i], gID[i]); |
| } |
| |
| /** cvt **/ |
| if ((p = getTable(ttf, O_cvt)) != 0) { |
| cvt = TrueTypeTableNew(T_cvt, getTableSize(ttf, O_cvt), p); |
| } |
| |
| /** prep **/ |
| if ((p = getTable(ttf, O_prep)) != 0) { |
| prep = TrueTypeTableNew(T_prep, getTableSize(ttf, O_prep), p); |
| } |
| |
| /** fpgm **/ |
| if ((p = getTable(ttf, O_fpgm)) != 0) { |
| fpgm = TrueTypeTableNew(T_fpgm, getTableSize(ttf, O_fpgm), p); |
| } |
| |
| /** post **/ |
| if ((p = getTable(ttf, O_post)) != 0) { |
| post = TrueTypeTableNew_post(0x00030000, |
| GetUInt32(p, 4, 1), |
| GetUInt16(p, 8, 1), |
| GetUInt16(p, 10, 1), |
| GetUInt16(p, 12, 1)); |
| } else { |
| post = TrueTypeTableNew_post(0x00030000, 0, 0, 0, 0); |
| } |
| |
| if (flags & TTCF_IncludeOS2) { |
| if ((p = getTable(ttf, O_OS2)) != 0) { |
| os2 = TrueTypeTableNew(T_OS2, getTableSize(ttf, O_OS2), p); |
| } |
| } |
| |
| AddTable(ttcr, name); AddTable(ttcr, maxp); AddTable(ttcr, hhea); |
| AddTable(ttcr, head); AddTable(ttcr, glyf); AddTable(ttcr, cmap); |
| AddTable(ttcr, cvt ); AddTable(ttcr, prep); AddTable(ttcr, fpgm); |
| AddTable(ttcr, post); AddTable(ttcr, os2); |
| |
| if ((res = StreamToFile(ttcr, fname)) != SF_OK) { |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf(stderr, "StreamToFile: error code: %d.\n", res); |
| #endif |
| } |
| |
| TrueTypeCreatorDispose(ttcr); |
| free(gID); |
| |
| return res; |
| } |
| #endif |
| |
| |
| #ifndef NO_TYPE42 |
| static GlyphOffsets *GlyphOffsetsNew(sal_uInt8 *sfntP) |
| { |
| GlyphOffsets* res = (GlyphOffsets*)smalloc(sizeof(GlyphOffsets)); |
| sal_uInt8 *loca = NULL; |
| sal_uInt16 i, numTables = GetUInt16(sfntP, 4, 1); |
| sal_uInt32 locaLen = 0; |
| sal_Int16 indexToLocFormat = 0; |
| |
| for (i = 0; i < numTables; i++) { |
| sal_uInt32 tag = GetUInt32(sfntP + 12, 16 * i, 1); |
| sal_uInt32 off = GetUInt32(sfntP + 12, 16 * i + 8, 1); |
| sal_uInt32 len = GetUInt32(sfntP + 12, 16 * i + 12, 1); |
| |
| if (tag == T_loca) { |
| loca = sfntP + off; |
| locaLen = len; |
| } else if (tag == T_head) { |
| indexToLocFormat = GetInt16(sfntP + off, 50, 1); |
| } |
| } |
| |
| res->nGlyphs = locaLen / ((indexToLocFormat == 1) ? 4 : 2); |
| assert(res->nGlyphs != 0); |
| res->offs = (sal_uInt32*)scalloc(res->nGlyphs, sizeof(sal_uInt32)); |
| |
| for (i = 0; i < res->nGlyphs; i++) { |
| if (indexToLocFormat == 1) { |
| res->offs[i] = GetUInt32(loca, i * 4, 1); |
| } else { |
| res->offs[i] = GetUInt16(loca, i * 2, 1) << 1; |
| } |
| } |
| return res; |
| } |
| |
| static void GlyphOffsetsDispose(GlyphOffsets *_this) |
| { |
| if (_this) { |
| free(_this->offs); |
| free(_this); |
| } |
| } |
| |
| static void DumpSfnts(FILE *outf, sal_uInt8 *sfntP) |
| { |
| HexFmt *h = HexFmtNew(outf); |
| sal_uInt16 i, numTables = GetUInt16(sfntP, 4, 1); |
| GlyphOffsets *go = GlyphOffsetsNew(sfntP); |
| sal_uInt8 pad[] = {0,0,0,0}; /* zeroes */ |
| |
| assert(numTables <= 9); /* Type42 has 9 required tables */ |
| |
| sal_uInt32* offs = (sal_uInt32*)scalloc(numTables, sizeof(sal_uInt32)); |
| // sal_uInt32* lens = (sal_uInt32*)scalloc(numTables, sizeof(sal_uInt32)); |
| |
| fputs("/sfnts [", outf); |
| HexFmtOpenString(h); |
| HexFmtBlockWrite(h, sfntP, 12); /* stream out the Offset Table */ |
| HexFmtBlockWrite(h, sfntP+12, 16 * numTables); /* stream out the Table Directory */ |
| |
| for (i=0; i<numTables; i++) { |
| sal_uInt32 tag = GetUInt32(sfntP + 12, 16 * i, 1); |
| sal_uInt32 off = GetUInt32(sfntP + 12, 16 * i + 8, 1); |
| sal_uInt32 len = GetUInt32(sfntP + 12, 16 * i + 12, 1); |
| |
| if (tag != T_glyf) { |
| HexFmtBlockWrite(h, sfntP + off, len); |
| } else { |
| sal_uInt8 *glyf = sfntP + off; |
| sal_uInt32 o, l, j; |
| for (j = 0; j < go->nGlyphs - 1; j++) { |
| o = go->offs[j]; |
| l = go->offs[j + 1] - o; |
| HexFmtBlockWrite(h, glyf + o, l); |
| } |
| } |
| HexFmtBlockWrite(h, pad, (4 - (len & 3)) & 3); |
| } |
| HexFmtCloseString(h); |
| fputs("] def\n", outf); |
| GlyphOffsetsDispose(go); |
| HexFmtDispose(h); |
| free(offs); |
| // free(lens); |
| } |
| |
| int CreateT42FromTTGlyphs(TrueTypeFont *ttf, |
| FILE *outf, |
| const char *psname, |
| sal_uInt16 *glyphArray, |
| sal_uInt8 *encoding, |
| int nGlyphs) |
| { |
| TrueTypeCreator *ttcr; |
| TrueTypeTable *head=0, *hhea=0, *maxp=0, *cvt=0, *prep=0, *glyf=0, *fpgm=0; |
| int i; |
| int res; |
| |
| sal_uInt32 ver, rev; |
| |
| sal_uInt8 *sfntP; |
| sal_uInt32 sfntLen; |
| int UPEm = ttf->unitsPerEm; |
| |
| if (nGlyphs >= 256) return SF_GLYPHNUM; |
| |
| assert(psname != 0); |
| |
| TrueTypeCreatorNewEmpty(T_true, &ttcr); |
| |
| /* head */ |
| const sal_uInt8* p = getTable(ttf, O_head); |
| const sal_uInt8* headP = p; |
| assert(p != 0); |
| head = TrueTypeTableNew_head(GetUInt32(p, 4, 1), GetUInt16(p, 16, 1), GetUInt16(p, 18, 1), p+20, GetUInt16(p, 44, 1), GetUInt16(p, 46, 1), GetInt16(p, 48, 1)); |
| ver = GetUInt32(p, 0, 1); |
| rev = GetUInt32(p, 4, 1); |
| |
| /** hhea **/ |
| p = getTable(ttf, O_hhea); |
| if (p) { |
| hhea = TrueTypeTableNew_hhea(GetUInt16(p, 4, 1), GetUInt16(p, 6, 1), GetUInt16(p, 8, 1), GetUInt16(p, 18, 1), GetUInt16(p, 20, 1)); |
| } else { |
| hhea = TrueTypeTableNew_hhea(0, 0, 0, 0, 0); |
| } |
| |
| /** maxp **/ |
| maxp = TrueTypeTableNew_maxp(getTable(ttf, O_maxp), getTableSize(ttf, O_maxp)); |
| |
| /** cvt **/ |
| if ((p = getTable(ttf, O_cvt)) != 0) { |
| cvt = TrueTypeTableNew(T_cvt, getTableSize(ttf, O_cvt), p); |
| } |
| |
| /** prep **/ |
| if ((p = getTable(ttf, O_prep)) != 0) { |
| prep = TrueTypeTableNew(T_prep, getTableSize(ttf, O_prep), p); |
| } |
| |
| /** fpgm **/ |
| if ((p = getTable(ttf, O_fpgm)) != 0) { |
| fpgm = TrueTypeTableNew(T_fpgm, getTableSize(ttf, O_fpgm), p); |
| } |
| |
| /** glyf **/ |
| glyf = TrueTypeTableNew_glyf(); |
| sal_uInt16* gID = (sal_uInt16*)scalloc(nGlyphs, sizeof(sal_uInt32)); |
| |
| for (i = 0; i < nGlyphs; i++) { |
| gID[i] = (sal_uInt16)glyfAdd(glyf, GetTTRawGlyphData(ttf, glyphArray[i]), ttf); |
| } |
| |
| AddTable(ttcr, head); AddTable(ttcr, hhea); AddTable(ttcr, maxp); AddTable(ttcr, cvt); |
| AddTable(ttcr, prep); AddTable(ttcr, glyf); AddTable(ttcr, fpgm); |
| |
| if ((res = StreamToMemory(ttcr, &sfntP, &sfntLen)) != SF_OK) { |
| TrueTypeCreatorDispose(ttcr); |
| free(gID); |
| return res; |
| } |
| |
| fprintf(outf, "%%!PS-TrueTypeFont-%d.%d-%d.%d\n", (int)(ver>>16), (int)(ver & 0xFFFF), (int)(rev>>16), (int)(rev & 0xFFFF)); |
| fprintf(outf, "%%%%Creator: %s %s %s\n", modname, modver, modextra); |
| fprintf(outf, "%%- Font subset generated from a source font file: '%s'\n", ttf->fname); |
| fprintf(outf, "%%- Original font name: %s\n", ttf->psname); |
| fprintf(outf, "%%- Original font family: %s\n", ttf->family); |
| fprintf(outf, "%%- Original font sub-family: %s\n", ttf->subfamily); |
| fprintf(outf, "11 dict begin\n"); |
| fprintf(outf, "/FontName (%s) cvn def\n", psname); |
| fprintf(outf, "/PaintType 0 def\n"); |
| fprintf(outf, "/FontMatrix [1 0 0 1 0 0] def\n"); |
| fprintf(outf, "/FontBBox [%d %d %d %d] def\n", XUnits(UPEm, GetInt16(headP, 36, 1)), XUnits(UPEm, GetInt16(headP, 38, 1)), XUnits(UPEm, GetInt16(headP, 40, 1)), XUnits(UPEm, GetInt16(headP, 42, 1))); |
| fprintf(outf, "/FontType 42 def\n"); |
| fprintf(outf, "/Encoding 256 array def\n"); |
| fprintf(outf, " 0 1 255 {Encoding exch /.notdef put} for\n"); |
| |
| for (i = 1; i<nGlyphs; i++) { |
| fprintf(outf, "Encoding %d /glyph%d put\n", encoding[i], gID[i]); |
| } |
| fprintf(outf, "/XUID [103 0 1 16#%08X %d 16#%08X 16#%08X] def\n", (unsigned int)rtl_crc32(0, ttf->ptr, ttf->fsize), (unsigned int)nGlyphs, (unsigned int)rtl_crc32(0, glyphArray, nGlyphs * 2), (unsigned int)rtl_crc32(0, encoding, nGlyphs)); |
| |
| DumpSfnts(outf, sfntP); |
| |
| /* dump charstrings */ |
| fprintf(outf, "/CharStrings %d dict dup begin\n", nGlyphs); |
| fprintf(outf, "/.notdef 0 def\n"); |
| for (i = 1; i < (int)glyfCount(glyf); i++) { |
| fprintf(outf,"/glyph%d %d def\n", i, i); |
| } |
| fprintf(outf, "end readonly def\n"); |
| |
| fprintf(outf, "FontName currentdict end definefont pop\n"); |
| TrueTypeCreatorDispose(ttcr); |
| free(gID); |
| free(sfntP); |
| return SF_OK; |
| } |
| #endif |
| |
| |
| #ifndef NO_MAPPERS |
| int MapString(TrueTypeFont *ttf, sal_uInt16 *str, int nchars, sal_uInt16 *glyphArray, int bvertical) |
| { |
| int i; |
| sal_uInt16 *cp; |
| |
| if (ttf->cmapType == CMAP_NOT_USABLE ) return -1; |
| if (!nchars) return 0; |
| |
| if (glyphArray == 0) { |
| cp = str; |
| } else { |
| cp = glyphArray; |
| } |
| |
| switch (ttf->cmapType) { |
| case CMAP_MS_Symbol: |
| if( ttf->mapper == getGlyph0 ) { |
| sal_uInt16 aChar; |
| for( i = 0; i < nchars; i++ ) { |
| aChar = str[i]; |
| if( ( aChar & 0xf000 ) == 0xf000 ) |
| aChar &= 0x00ff; |
| cp[i] = aChar; |
| } |
| } |
| else if( glyphArray ) |
| memcpy(glyphArray, str, nchars * 2); |
| break; |
| |
| case CMAP_MS_Unicode: |
| if (glyphArray != 0) { |
| memcpy(glyphArray, str, nchars * 2); |
| } |
| break; |
| |
| case CMAP_MS_ShiftJIS: TranslateString12(str, cp, nchars); break; |
| case CMAP_MS_Big5: TranslateString13(str, cp, nchars); break; |
| case CMAP_MS_PRC: TranslateString14(str, cp, nchars); break; |
| case CMAP_MS_Wansung: TranslateString15(str, cp, nchars); break; |
| case CMAP_MS_Johab: TranslateString16(str, cp, nchars); break; |
| } |
| |
| for (i = 0; i < nchars; i++) { |
| cp[i] = (sal_uInt16)ttf->mapper(ttf->cmap, cp[i]); |
| if (cp[i]!=0 && bvertical!=0) |
| cp[i] = (sal_uInt16)UseGSUB(ttf,cp[i],bvertical); |
| } |
| return nchars; |
| } |
| |
| sal_uInt16 MapChar(TrueTypeFont *ttf, sal_uInt16 ch, int bvertical) |
| { |
| switch (ttf->cmapType) { |
| case CMAP_MS_Symbol: |
| |
| if( ttf->mapper == getGlyph0 && ( ch & 0xf000 ) == 0xf000 ) |
| ch &= 0x00ff; |
| return (sal_uInt16)ttf->mapper(ttf->cmap, ch ); |
| |
| case CMAP_MS_Unicode: break; |
| case CMAP_MS_ShiftJIS: ch = TranslateChar12(ch); break; |
| case CMAP_MS_Big5: ch = TranslateChar13(ch); break; |
| case CMAP_MS_PRC: ch = TranslateChar14(ch); break; |
| case CMAP_MS_Wansung: ch = TranslateChar15(ch); break; |
| case CMAP_MS_Johab: ch = TranslateChar16(ch); break; |
| default: return 0; |
| } |
| ch = (sal_uInt16)ttf->mapper(ttf->cmap, ch); |
| if (ch!=0 && bvertical!=0) |
| ch = (sal_uInt16)UseGSUB(ttf,ch,bvertical); |
| return ch; |
| } |
| |
| int DoesVerticalSubstitution( TrueTypeFont *ttf, int bvertical) |
| { |
| int nRet = 0; |
| if( bvertical) |
| nRet = HasVerticalGSUB( ttf); |
| return nRet; |
| } |
| |
| #endif |
| |
| int GetTTGlyphCount( TrueTypeFont* ttf ) |
| { |
| return ttf->nglyphs; |
| } |
| |
| bool GetSfntTable( TrueTypeFont* ttf, int nSubtableIndex, |
| const sal_uInt8** ppRawBytes, int* pRawLength ) |
| { |
| if( (nSubtableIndex < 0) || (nSubtableIndex >= NUM_TAGS) ) |
| return false; |
| *pRawLength = ttf->tlens[ nSubtableIndex ]; |
| *ppRawBytes = ttf->tables[ nSubtableIndex ]; |
| bool bOk = (*pRawLength > 0) && (ppRawBytes != NULL); |
| return bOk; |
| } |
| |
| TTSimpleGlyphMetrics *GetTTSimpleGlyphMetrics(TrueTypeFont *ttf, sal_uInt16 *glyphArray, int nGlyphs, int mode) |
| { |
| const sal_uInt8* pTable; |
| sal_uInt32 n; |
| int nTableSize; |
| |
| if (mode == 0) { |
| n = ttf->numberOfHMetrics; |
| pTable = getTable( ttf, O_hmtx ); |
| nTableSize = getTableSize( ttf, O_hmtx ); |
| } else { |
| n = ttf->numOfLongVerMetrics; |
| pTable = getTable( ttf, O_vmtx ); |
| nTableSize = getTableSize( ttf, O_vmtx ); |
| } |
| |
| if (!nGlyphs || !glyphArray) return 0; /* invalid parameters */ |
| if (!n || !pTable) return 0; /* the font does not contain the requested metrics */ |
| |
| TTSimpleGlyphMetrics* res = (TTSimpleGlyphMetrics*)calloc(nGlyphs, sizeof(TTSimpleGlyphMetrics)); |
| assert(res != 0); |
| |
| const int UPEm = ttf->unitsPerEm; |
| for( int i = 0; i < nGlyphs; ++i) { |
| int nAdvOffset, nLsbOffset; |
| sal_uInt16 glyphID = glyphArray[i]; |
| |
| if (glyphID < n) { |
| nAdvOffset = 4 * glyphID; |
| nLsbOffset = nAdvOffset + 2; |
| } else { |
| nAdvOffset = 4 * (n - 1); |
| if( glyphID < ttf->nglyphs ) |
| nLsbOffset = 4 * n + 2 * (glyphID - n); |
| else /* font is broken -> use lsb of last hmetrics */ |
| nLsbOffset = nAdvOffset + 2; |
| } |
| |
| if( nAdvOffset >= nTableSize) |
| res[i].adv = 0; /* better than a crash for buggy fonts */ |
| else |
| res[i].adv = static_cast<sal_uInt16>( |
| XUnits( UPEm, GetUInt16( pTable, nAdvOffset, 1) ) ); |
| |
| if( nLsbOffset >= nTableSize) |
| res[i].sb = 0; /* better than a crash for buggy fonts */ |
| else |
| res[i].sb = static_cast<sal_Int16>( |
| XUnits( UPEm, GetInt16( pTable, nLsbOffset, 1) ) ); |
| } |
| |
| return res; |
| } |
| |
| #ifndef NO_MAPPERS |
| TTSimpleGlyphMetrics *GetTTSimpleCharMetrics(TrueTypeFont * ttf, sal_uInt16 firstChar, int nChars, int mode) |
| { |
| TTSimpleGlyphMetrics *res = 0; |
| int i, n; |
| |
| sal_uInt16* str = (sal_uInt16*)malloc(nChars * 2); |
| assert(str != 0); |
| |
| for (i=0; i<nChars; i++) str[i] = (sal_uInt16)(firstChar + i); |
| if ((n = MapString(ttf, str, nChars, 0, mode)) != -1) { |
| res = GetTTSimpleGlyphMetrics(ttf, str, n, mode); |
| } |
| |
| free(str); |
| |
| return res; |
| } |
| #endif |
| |
| void GetTTGlobalFontInfo(TrueTypeFont *ttf, TTGlobalFontInfo *info) |
| { |
| int UPEm = ttf->unitsPerEm; |
| |
| memset(info, 0, sizeof(TTGlobalFontInfo)); |
| |
| info->family = ttf->family; |
| info->ufamily = ttf->ufamily; |
| info->subfamily = ttf->subfamily; |
| info->usubfamily = ttf->usubfamily; |
| info->psname = ttf->psname; |
| info->symbolEncoded = (ttf->cmapType == CMAP_MS_Symbol); |
| |
| const sal_uInt8* table = getTable(ttf, O_OS2); |
| if (table) { |
| info->weight = GetUInt16(table, 4, 1); |
| info->width = GetUInt16(table, 6, 1); |
| |
| /* There are 3 different versions of OS/2 table: original (68 bytes long), |
| * Microsoft old (78 bytes long) and Microsoft new (86 bytes long,) |
| * Apple's documentation recommends looking at the table length. |
| */ |
| if (getTableSize(ttf, O_OS2) > 68) { |
| info->typoAscender = XUnits(UPEm,GetInt16(table, 68, 1)); |
| info->typoDescender = XUnits(UPEm, GetInt16(table, 70, 1)); |
| info->typoLineGap = XUnits(UPEm, GetInt16(table, 72, 1)); |
| info->winAscent = XUnits(UPEm, GetUInt16(table, 74, 1)); |
| info->winDescent = XUnits(UPEm, GetUInt16(table, 76, 1)); |
| /* sanity check; some fonts treat winDescent as signed |
| * violating the standard */ |
| if( info->winDescent > 5*UPEm ) |
| info->winDescent = XUnits(UPEm, GetInt16(table, 76,1)); |
| } |
| if (ttf->cmapType == CMAP_MS_Unicode) { |
| info->rangeFlag = 1; |
| info->ur1 = GetUInt32(table, 42, 1); |
| info->ur2 = GetUInt32(table, 46, 1); |
| info->ur3 = GetUInt32(table, 50, 1); |
| info->ur4 = GetUInt32(table, 54, 1); |
| } |
| memcpy(info->panose, table + 32, 10); |
| info->typeFlags = GetUInt16( table, 8, 1 ); |
| if( getTable(ttf, O_CFF) ) |
| info->typeFlags |= TYPEFLAG_PS_OPENTYPE; |
| } |
| |
| table = getTable(ttf, O_post); |
| if (table && getTableSize(ttf, O_post) >= 12+sizeof(sal_uInt32)) { |
| info->pitch = GetUInt32(table, 12, 1); |
| info->italicAngle = GetInt32(table, 4, 1); |
| } |
| |
| table = getTable(ttf, O_head); /* 'head' tables is always there */ |
| info->xMin = XUnits(UPEm, GetInt16(table, 36, 1)); |
| info->yMin = XUnits(UPEm, GetInt16(table, 38, 1)); |
| info->xMax = XUnits(UPEm, GetInt16(table, 40, 1)); |
| info->yMax = XUnits(UPEm, GetInt16(table, 42, 1)); |
| info->macStyle = GetInt16(table, 44, 1); |
| |
| table = getTable(ttf, O_hhea); |
| if (table) { |
| info->ascender = XUnits(UPEm, GetInt16(table, 4, 1)); |
| info->descender = XUnits(UPEm, GetInt16(table, 6, 1)); |
| info->linegap = XUnits(UPEm, GetInt16(table, 8, 1)); |
| } |
| |
| table = getTable(ttf, O_vhea); |
| if (table) { |
| info->vascent = XUnits(UPEm, GetInt16(table, 4, 1)); |
| info->vdescent = XUnits(UPEm, GetInt16(table, 6, 1)); |
| } |
| } |
| |
| #ifdef TEST5 |
| void KernGlyphs(TrueTypeFont *ttf, sal_uInt16 *glyphs, int nglyphs, int wmode, KernData *kern) |
| { |
| int i; |
| |
| if (!nglyphs || !glyphs || !kern) return; |
| |
| for (i = 0; i < nglyphs-1; i++) kern[i].x = kern[i].y = 0; |
| |
| switch (ttf->kerntype) { |
| case KT_APPLE_NEW: KernGlyphsPrim1(ttf, glyphs, nglyphs, wmode, kern); return; |
| case KT_MICROSOFT: KernGlyphsPrim2(ttf, glyphs, nglyphs, wmode, kern); return; |
| default: return; |
| } |
| } |
| #endif |
| |
| GlyphData *GetTTRawGlyphData(TrueTypeFont *ttf, sal_uInt32 glyphID) |
| { |
| const sal_uInt8* glyf = getTable(ttf, O_glyf); |
| const sal_uInt8* hmtx = getTable(ttf, O_hmtx); |
| int i, n, m; |
| |
| if( glyphID >= ttf->nglyphs ) |
| return 0; |
| |
| /* #127161# check the glyph offsets */ |
| sal_uInt32 length = getTableSize( ttf, O_glyf ); |
| if( length < ttf->goffsets[ glyphID+1 ] ) |
| return 0; |
| |
| length = ttf->goffsets[glyphID+1] - ttf->goffsets[glyphID]; |
| |
| GlyphData* d = (GlyphData*)malloc(sizeof(GlyphData)); assert(d != 0); |
| |
| if (length > 0) { |
| const sal_uInt8* srcptr = glyf + ttf->goffsets[glyphID]; |
| d->ptr = (sal_uInt8*)malloc((length + 1) & ~1); assert(d->ptr != 0); |
| memcpy( d->ptr, srcptr, length ); |
| d->compflag = (GetInt16( srcptr, 0, 1 ) < 0); |
| } else { |
| d->ptr = 0; |
| d->compflag = 0; |
| } |
| |
| d->glyphID = glyphID; |
| d->nbytes = (sal_uInt16)((length + 1) & ~1); |
| |
| /* now calculate npoints and ncontours */ |
| ControlPoint *cp; |
| n = GetTTGlyphPoints(ttf, glyphID, &cp); |
| if( n > 0) { |
| m = 0; |
| for (i = 0; i < n; i++) { |
| if (cp[i].flags & 0x8000) m++; |
| } |
| d->npoints = (sal_uInt16)n; |
| d->ncontours = (sal_uInt16)m; |
| free(cp); |
| } else { |
| d->npoints = 0; |
| d->ncontours = 0; |
| } |
| |
| /* get advance width and left sidebearing */ |
| if (glyphID < ttf->numberOfHMetrics) { |
| d->aw = GetUInt16(hmtx, 4 * glyphID, 1); |
| d->lsb = GetInt16(hmtx, 4 * glyphID + 2, 1); |
| } else { |
| d->aw = GetUInt16(hmtx, 4 * (ttf->numberOfHMetrics - 1), 1); |
| d->lsb = GetInt16(hmtx + ttf->numberOfHMetrics * 4, (glyphID - ttf->numberOfHMetrics) * 2, 1); |
| } |
| |
| return d; |
| } |
| |
| int GetTTNameRecords(TrueTypeFont *ttf, NameRecord **nr) |
| { |
| const sal_uInt8* table = getTable(ttf, O_name); |
| int nTableSize = getTableSize(ttf, O_name ); |
| |
| if (nTableSize < 6) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf(stderr, "O_name table too small\n"); |
| #endif |
| return 0; |
| } |
| |
| sal_uInt16 n = GetUInt16(table, 2, 1); |
| int nStrBase = GetUInt16(table, 4, 1); |
| int i; |
| |
| *nr = 0; |
| if (n == 0) return 0; |
| |
| NameRecord* rec = (NameRecord*)calloc(n, sizeof(NameRecord)); |
| |
| for (i = 0; i < n; i++) { |
| int nStrOffset = GetUInt16(table + 6, 10 + 12 * i, 1); |
| rec[i].platformID = GetUInt16(table + 6, 12 * i, 1); |
| rec[i].encodingID = GetUInt16(table + 6, 2 + 12 * i, 1); |
| rec[i].languageID = GetUInt16(table + 6, 4 + 12 * i, 1); |
| rec[i].nameID = GetUInt16(table + 6, 6 + 12 * i, 1); |
| rec[i].slen = GetUInt16(table + 6, 8 + 12 * i, 1); |
| if (rec[i].slen) { |
| if( nStrBase+nStrOffset+rec[i].slen >= nTableSize ) { |
| rec[i].sptr = 0; |
| rec[i].slen = 0; |
| continue; |
| } |
| |
| const sal_uInt8* rec_string = table + nStrBase + nStrOffset; |
| // sanity check |
| if( rec_string > (sal_uInt8*)ttf->ptr && rec_string < ((sal_uInt8*)ttf->ptr + ttf->fsize - rec[i].slen ) ) |
| { |
| rec[i].sptr = (sal_uInt8 *) malloc(rec[i].slen); assert(rec[i].sptr != 0); |
| memcpy(rec[i].sptr, rec_string, rec[i].slen); |
| } |
| else |
| { |
| #ifdef DEBUG |
| fprintf( stderr, "found invalid name record %d with name id %d for file %s\n", |
| i, rec[i].nameID, ttf->fname ); |
| #endif |
| rec[i].sptr = 0; |
| rec[i].slen = 0; |
| } |
| } else { |
| rec[i].sptr = 0; |
| } |
| // some fonts have 3.0 names => fix them to 3.1 |
| if( (rec[i].platformID == 3) && (rec[i].encodingID == 0) ) |
| rec[i].encodingID = 1; |
| } |
| |
| *nr = rec; |
| return n; |
| } |
| |
| void DisposeNameRecords(NameRecord* nr, int n) |
| { |
| int i; |
| for (i = 0; i < n; i++) { |
| if (nr[i].sptr) free(nr[i].sptr); |
| } |
| free(nr); |
| } |
| |
| } // namespace vcl |
| |
| |
| #ifdef TEST1 |
| /* This example creates a subset of a TrueType font with two encoded characters */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| int r; |
| |
| /* Array of Unicode source characters */ |
| sal_uInt16 chars[2]; |
| |
| /* Encoding vector maps character encoding to the ordinal number |
| * of the glyph in the output file */ |
| sal_uInt8 encoding[2]; |
| |
| /* This array is for glyph IDs that source characters map to */ |
| sal_uInt16 g[2]; |
| |
| |
| if (ac < 2) return 0; |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| |
| /* We want to create the output file that only contains two Unicode characters: |
| * L'a' and L'A' */ |
| |
| chars[0] = L'a'; |
| chars[1] = L'A'; |
| |
| /* Figure out what glyphs do these characters map in our font */ |
| MapString(fnt, chars, 2, g); |
| |
| /* Encode the characters. Value of encoding[i] is the number 0..255 which maps to glyph i of the |
| * newly generated font */ |
| encoding[0] = chars[0]; |
| encoding[1] = chars[1]; |
| |
| |
| /* Generate a subset */ |
| CreateT3FromTTGlyphs(fnt, stdout, 0, g, encoding, 2, 0); |
| |
| /* Now call the dtor for the font */ |
| CloseTTFont(fnt); |
| return 0; |
| } |
| #endif |
| |
| #ifdef TEST2 |
| /* This example extracts first 224 glyphs from a TT fonts and encodes them starting at 32 */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| int i, r; |
| |
| /* Array of Unicode source characters */ |
| sal_uInt16 glyphs[224]; |
| |
| /* Encoding vector maps character encoding to the ordinal number |
| * of the glyph in the output file */ |
| sal_uInt8 encoding[224]; |
| |
| |
| |
| for (i=0; i<224; i++) { |
| glyphs[i] = i; |
| encoding[i] = 32 + i; |
| } |
| |
| if (ac < 2) return 0; |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| |
| /* Encode the characters. Value of encoding[i] is the number 0..255 which maps to glyph i of the |
| * newly generated font */ |
| |
| /* Generate a subset */ |
| CreateT3FromTTGlyphs(fnt, stdout, 0, glyphs, encoding, 224, 0); |
| |
| /* Now call the dtor for the font */ |
| CloseTTFont(fnt); |
| return 0; |
| } |
| #endif |
| |
| #ifdef TEST3 |
| /* Glyph metrics example */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| int i, r; |
| sal_uInt16 glyphs[224]; |
| TTSimpleGlyphMetrics *m; |
| |
| for (i=0; i<224; i++) { |
| glyphs[i] = i; |
| } |
| |
| if (ac < 2) return 0; |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| if ((m = GetTTSimpleGlyphMetrics(fnt, glyphs, 224, 0)) == 0) { |
| printf("Requested metrics is not available\n"); |
| } else { |
| for (i=0; i<224; i++) { |
| printf("%d. advWid: %5d, LSBear: %5d\n", i, m[i].adv, m[i].sb); |
| } |
| } |
| |
| /* Now call the dtor for the font */ |
| free(m); |
| CloseTTFont(fnt); |
| return 0; |
| } |
| #endif |
| |
| #ifdef TEST4 |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| TTGlobalFontInfo info; |
| int i, r; |
| |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| printf("Font file: %s\n", av[1]); |
| |
| #ifdef PRINT_KERN |
| switch (fnt->kerntype) { |
| case KT_MICROSOFT: |
| printf("\tkern: MICROSOFT, ntables: %d.", fnt->nkern); |
| if (fnt->nkern) { |
| printf(" ["); |
| for (i=0; i<fnt->nkern; i++) { |
| printf("%04X ", GetUInt16(fnt->kerntables[i], 4, 1)); |
| } |
| printf("]"); |
| } |
| printf("\n"); |
| break; |
| |
| case KT_APPLE_NEW: |
| printf("\tkern: APPLE_NEW, ntables: %d.", fnt->nkern); |
| if (fnt->nkern) { |
| printf(" ["); |
| for (i=0; i<fnt->nkern; i++) { |
| printf("%04X ", GetUInt16(fnt->kerntables[i], 4, 1)); |
| } |
| printf("]"); |
| } |
| printf("\n"); |
| break; |
| |
| case KT_NONE: |
| printf("\tkern: none.\n"); |
| break; |
| |
| default: |
| printf("\tkern: unrecoginzed.\n"); |
| break; |
| } |
| printf("\n"); |
| #endif |
| |
| GetTTGlobalFontInfo(fnt, &info); |
| printf("\tfamily name: `%s`\n", info.family); |
| printf("\tsubfamily name: `%s`\n", info.subfamily); |
| printf("\tpostscript name: `%s`\n", info.psname); |
| printf("\tweight: %d\n", info.weight); |
| printf("\twidth: %d\n", info.width); |
| printf("\tpitch: %d\n", info.pitch); |
| printf("\titalic angle: %d\n", info.italicAngle); |
| printf("\tbouding box: [%d %d %d %d]\n", info.xMin, info.yMin, info.xMax, info.yMax); |
| printf("\tascender: %d\n", info.ascender); |
| printf("\tdescender: %d\n", info.descender); |
| printf("\tlinegap: %d\n", info.linegap); |
| printf("\tvascent: %d\n", info.vascent); |
| printf("\tvdescent: %d\n", info.vdescent); |
| printf("\ttypoAscender: %d\n", info.typoAscender); |
| printf("\ttypoDescender: %d\n", info.typoDescender); |
| printf("\ttypoLineGap: %d\n", info.typoLineGap); |
| printf("\twinAscent: %d\n", info.winAscent); |
| printf("\twinDescent: %d\n", info.winDescent); |
| printf("\tUnicode ranges:\n"); |
| for (i = 0; i < 32; i++) { |
| if ((info.ur1 >> i) & 1) { |
| printf("\t\t\t%s\n", UnicodeRangeName(i)); |
| } |
| } |
| for (i = 0; i < 32; i++) { |
| if ((info.ur2 >> i) & 1) { |
| printf("\t\t\t%s\n", UnicodeRangeName(i+32)); |
| } |
| } |
| for (i = 0; i < 32; i++) { |
| if ((info.ur3 >> i) & 1) { |
| printf("\t\t\t%s\n", UnicodeRangeName(i+64)); |
| } |
| } |
| for (i = 0; i < 32; i++) { |
| if ((info.ur4 >> i) & 1) { |
| printf("\t\t\t%s\n", UnicodeRangeName(i+96)); |
| } |
| } |
| |
| CloseTTFont(fnt); |
| return 0; |
| } |
| #endif |
| |
| #ifdef TEST5 |
| /* Kerning example */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| sal_uInt16 g[224]; |
| KernData d[223]; |
| int r, i, k = 0; |
| |
| g[k++] = 11; |
| g[k++] = 36; |
| g[k++] = 11; |
| g[k++] = 98; |
| g[k++] = 11; |
| g[k++] = 144; |
| g[k++] = 41; |
| g[k++] = 171; |
| g[k++] = 51; |
| g[k++] = 15; |
| |
| if (ac < 2) return 0; |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| KernGlyphs(fnt, g, k, 0, d); |
| |
| for (i = 0; i < k-1; i++) { |
| printf("%3d %3d: [%3d %3d]\n", g[i], g[i+1], d[i].x, d[i].y); |
| } |
| |
| CloseTTFont(fnt); |
| return 0; |
| } |
| #endif |
| |
| |
| |
| #ifdef TEST6 |
| /* This example extracts a single glyph from a font */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| int r, i; |
| |
| sal_uInt16 glyphs[256]; |
| sal_uInt8 encoding[256]; |
| |
| for (i=0; i<256; i++) { |
| glyphs[i] = 512 + i; |
| encoding[i] = i; |
| } |
| |
| #if 0 |
| i=0; |
| glyphs[i++] = 2001; |
| glyphs[i++] = 2002; |
| glyphs[i++] = 2003; |
| glyphs[i++] = 2004; |
| glyphs[i++] = 2005; |
| glyphs[i++] = 2006; |
| glyphs[i++] = 2007; |
| glyphs[i++] = 2008; |
| glyphs[i++] = 2009; |
| glyphs[i++] = 2010; |
| glyphs[i++] = 2011; |
| glyphs[i++] = 2012; |
| glyphs[i++] = 2013; |
| glyphs[i++] = 2014; |
| glyphs[i++] = 2015; |
| glyphs[i++] = 2016; |
| glyphs[i++] = 2017; |
| glyphs[i++] = 2018; |
| glyphs[i++] = 2019; |
| glyphs[i++] = 2020; |
| |
| |
| r = 97; |
| i = 0; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| encoding[i++] = r++; |
| #endif |
| |
| if (ac < 2) return 0; |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| /* Generate a subset */ |
| CreateT3FromTTGlyphs(fnt, stdout, 0, glyphs, encoding, 256, 0); |
| |
| fprintf(stderr, "UnitsPerEm: %d.\n", fnt->unitsPerEm); |
| |
| /* Now call the dtor for the font */ |
| CloseTTFont(fnt); |
| return 0; |
| } |
| #endif |
| |
| #ifdef TEST7 |
| /* NameRecord extraction example */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| int r, i, j, n; |
| NameRecord *nr; |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| if ((n = GetTTNameRecords(fnt, &nr)) == 0) { |
| fprintf(stderr, "No name records in the font.\n"); |
| return 0; |
| } |
| |
| printf("Number of name records: %d.\n", n); |
| for (i = 0; i < n; i++) { |
| printf("%d %d %04X %d [", nr[i].platformID, nr[i].encodingID, nr[i].languageID, nr[i].nameID); |
| for (j=0; j<nr[i].slen; j++) { |
| printf("%c", isprint(nr[i].sptr[j]) ? nr[i].sptr[j] : '.'); |
| } |
| printf("]\n"); |
| } |
| |
| |
| DisposeNameRecords(nr, n); |
| CloseTTFont(fnt); |
| return 0; |
| } |
| #endif |
| |
| #ifdef TEST8 |
| /* TrueType -> TrueType subsetting */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| sal_uInt16 glyphArray[] = { 0, 98, 99, 22, 24, 25, 26, 27, 28, 29, 30, 31, 1270, 1289, 34}; |
| sal_uInt8 encoding[] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46}; |
| int r; |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| CreateTTFromTTGlyphs(fnt, "subfont.ttf", glyphArray, encoding, 15, 0, 0, TTCF_AutoName | TTCF_IncludeOS2); |
| |
| |
| CloseTTFont(fnt); |
| |
| return 0; |
| } |
| #endif |
| |
| #ifdef TEST9 |
| /* TrueType -> Type42 subsetting */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| /* |
| sal_uInt16 glyphArray[] = { 0, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34}; |
| sal_uInt8 encoding[] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46}; |
| */ |
| sal_uInt16 glyphArray[] = { 0, 6711, 6724, 11133, 11144, 14360, 26, 27, 28, 29, 30, 31, 1270, 1289, 34}; |
| sal_uInt8 encoding[] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46}; |
| int r; |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| CreateT42FromTTGlyphs(fnt, stdout, "testfont", glyphArray, encoding, 15); |
| |
| CloseTTFont(fnt); |
| |
| return 0; |
| } |
| #endif |
| |
| #ifdef TEST10 |
| /* Component glyph test */ |
| int main(int ac, char **av) |
| { |
| TrueTypeFont *fnt; |
| int r, i; |
| list glyphlist = listNewEmpty(); |
| |
| |
| if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) { |
| fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]); |
| return 0; |
| } |
| |
| for (i = 0; i < fnt->nglyphs; i++) { |
| r = GetTTGlyphComponents(fnt, i, glyphlist); |
| if (r > 1) { |
| printf("%d -> ", i); |
| listToFirst(glyphlist); |
| do { |
| printf("%d ", (int) listCurrent(glyphlist)); |
| } while (listNext(glyphlist)); |
| printf("\n"); |
| } else { |
| printf("%d: single glyph.\n", i); |
| } |
| listClear(glyphlist); |
| } |
| |
| CloseTTFont(fnt); |
| listDispose(glyphlist); |
| |
| return 0; |
| } |
| #endif |
| |
| |