| /* | |
| * Methods for dealing with opentype font tables | |
| * | |
| * Copyright 2014 Aric Stewart for CodeWeavers | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| */ | |
| #define COBJMACROS | |
| #define NONAMELESSUNION | |
| #include "dwrite_private.h" | |
| #include "winternl.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(dwrite); | |
| #define MS_HEAD_TAG DWRITE_MAKE_OPENTYPE_TAG('h','e','a','d') | |
| #define MS_HHEA_TAG DWRITE_MAKE_OPENTYPE_TAG('h','h','e','a') | |
| #define MS_OTTO_TAG DWRITE_MAKE_OPENTYPE_TAG('O','T','T','O') | |
| #define MS_OS2_TAG DWRITE_MAKE_OPENTYPE_TAG('O','S','/','2') | |
| #define MS_POST_TAG DWRITE_MAKE_OPENTYPE_TAG('p','o','s','t') | |
| #define MS_TTCF_TAG DWRITE_MAKE_OPENTYPE_TAG('t','t','c','f') | |
| #define MS_GPOS_TAG DWRITE_MAKE_OPENTYPE_TAG('G','P','O','S') | |
| #define MS_GSUB_TAG DWRITE_MAKE_OPENTYPE_TAG('G','S','U','B') | |
| #define MS_NAME_TAG DWRITE_MAKE_OPENTYPE_TAG('n','a','m','e') | |
| #define MS_GLYF_TAG DWRITE_MAKE_OPENTYPE_TAG('g','l','y','f') | |
| #define MS_CFF__TAG DWRITE_MAKE_OPENTYPE_TAG('C','F','F',' ') | |
| #define MS_CFF2_TAG DWRITE_MAKE_OPENTYPE_TAG('C','F','F','2') | |
| #define MS_COLR_TAG DWRITE_MAKE_OPENTYPE_TAG('C','O','L','R') | |
| #define MS_SVG__TAG DWRITE_MAKE_OPENTYPE_TAG('S','V','G',' ') | |
| #define MS_SBIX_TAG DWRITE_MAKE_OPENTYPE_TAG('s','b','i','x') | |
| #define MS_MAXP_TAG DWRITE_MAKE_OPENTYPE_TAG('m','a','x','p') | |
| #define MS_CBLC_TAG DWRITE_MAKE_OPENTYPE_TAG('C','B','L','C') | |
| /* 'sbix' formats */ | |
| #define MS_PNG__TAG DWRITE_MAKE_OPENTYPE_TAG('p','n','g',' ') | |
| #define MS_JPG__TAG DWRITE_MAKE_OPENTYPE_TAG('j','p','g',' ') | |
| #define MS_TIFF_TAG DWRITE_MAKE_OPENTYPE_TAG('t','i','f','f') | |
| #define MS_WOFF_TAG DWRITE_MAKE_OPENTYPE_TAG('w','O','F','F') | |
| #define MS_WOF2_TAG DWRITE_MAKE_OPENTYPE_TAG('w','O','F','2') | |
| #ifdef WORDS_BIGENDIAN | |
| #define GET_BE_WORD(x) (x) | |
| #define GET_BE_DWORD(x) (x) | |
| #else | |
| #define GET_BE_WORD(x) RtlUshortByteSwap(x) | |
| #define GET_BE_DWORD(x) RtlUlongByteSwap(x) | |
| #endif | |
| typedef struct { | |
| CHAR TTCTag[4]; | |
| DWORD Version; | |
| DWORD numFonts; | |
| DWORD OffsetTable[1]; | |
| } TTC_Header_V1; | |
| typedef struct { | |
| DWORD version; | |
| WORD numTables; | |
| WORD searchRange; | |
| WORD entrySelector; | |
| WORD rangeShift; | |
| } TTC_SFNT_V1; | |
| typedef struct { | |
| DWORD tag; | |
| DWORD checkSum; | |
| DWORD offset; | |
| DWORD length; | |
| } TT_TableRecord; | |
| typedef struct { | |
| WORD platformID; | |
| WORD encodingID; | |
| DWORD offset; | |
| } CMAP_EncodingRecord; | |
| typedef struct { | |
| WORD version; | |
| WORD numTables; | |
| CMAP_EncodingRecord tables[1]; | |
| } CMAP_Header; | |
| typedef struct { | |
| DWORD startCharCode; | |
| DWORD endCharCode; | |
| DWORD startGlyphID; | |
| } CMAP_SegmentedCoverage_group; | |
| typedef struct { | |
| WORD format; | |
| WORD reserved; | |
| DWORD length; | |
| DWORD language; | |
| DWORD nGroups; | |
| CMAP_SegmentedCoverage_group groups[1]; | |
| } CMAP_SegmentedCoverage; | |
| typedef struct { | |
| WORD format; | |
| WORD length; | |
| WORD language; | |
| WORD segCountX2; | |
| WORD searchRange; | |
| WORD entrySelector; | |
| WORD rangeShift; | |
| WORD endCode[1]; | |
| } CMAP_SegmentMapping_0; | |
| enum OPENTYPE_CMAP_TABLE_FORMAT | |
| { | |
| OPENTYPE_CMAP_TABLE_SEGMENT_MAPPING = 4, | |
| OPENTYPE_CMAP_TABLE_SEGMENTED_COVERAGE = 12 | |
| }; | |
| /* PANOSE is 10 bytes in size, need to pack the structure properly */ | |
| #include "pshpack2.h" | |
| typedef struct | |
| { | |
| USHORT majorVersion; | |
| USHORT minorVersion; | |
| ULONG revision; | |
| ULONG checksumadj; | |
| ULONG magic; | |
| USHORT flags; | |
| USHORT unitsPerEm; | |
| ULONGLONG created; | |
| ULONGLONG modified; | |
| SHORT xMin; | |
| SHORT yMin; | |
| SHORT xMax; | |
| SHORT yMax; | |
| USHORT macStyle; | |
| USHORT lowestRecPPEM; | |
| SHORT direction_hint; | |
| SHORT index_format; | |
| SHORT glyphdata_format; | |
| } TT_HEAD; | |
| enum TT_HEAD_MACSTYLE | |
| { | |
| TT_HEAD_MACSTYLE_BOLD = 1 << 0, | |
| TT_HEAD_MACSTYLE_ITALIC = 1 << 1, | |
| TT_HEAD_MACSTYLE_UNDERLINE = 1 << 2, | |
| TT_HEAD_MACSTYLE_OUTLINE = 1 << 3, | |
| TT_HEAD_MACSTYLE_SHADOW = 1 << 4, | |
| TT_HEAD_MACSTYLE_CONDENSED = 1 << 5, | |
| TT_HEAD_MACSTYLE_EXTENDED = 1 << 6, | |
| }; | |
| typedef struct | |
| { | |
| ULONG Version; | |
| ULONG italicAngle; | |
| SHORT underlinePosition; | |
| SHORT underlineThickness; | |
| ULONG fixed_pitch; | |
| ULONG minmemType42; | |
| ULONG maxmemType42; | |
| ULONG minmemType1; | |
| ULONG maxmemType1; | |
| } TT_POST; | |
| typedef struct | |
| { | |
| USHORT version; | |
| SHORT xAvgCharWidth; | |
| USHORT usWeightClass; | |
| USHORT usWidthClass; | |
| SHORT fsType; | |
| SHORT ySubscriptXSize; | |
| SHORT ySubscriptYSize; | |
| SHORT ySubscriptXOffset; | |
| SHORT ySubscriptYOffset; | |
| SHORT ySuperscriptXSize; | |
| SHORT ySuperscriptYSize; | |
| SHORT ySuperscriptXOffset; | |
| SHORT ySuperscriptYOffset; | |
| SHORT yStrikeoutSize; | |
| SHORT yStrikeoutPosition; | |
| SHORT sFamilyClass; | |
| PANOSE panose; | |
| ULONG ulUnicodeRange1; | |
| ULONG ulUnicodeRange2; | |
| ULONG ulUnicodeRange3; | |
| ULONG ulUnicodeRange4; | |
| CHAR achVendID[4]; | |
| USHORT fsSelection; | |
| USHORT usFirstCharIndex; | |
| USHORT usLastCharIndex; | |
| /* According to the Apple spec, original version didn't have the below fields, | |
| * version numbers were taken from the OpenType spec. | |
| */ | |
| /* version 0 (TrueType 1.5) */ | |
| USHORT sTypoAscender; | |
| USHORT sTypoDescender; | |
| USHORT sTypoLineGap; | |
| USHORT usWinAscent; | |
| USHORT usWinDescent; | |
| /* version 1 (TrueType 1.66) */ | |
| ULONG ulCodePageRange1; | |
| ULONG ulCodePageRange2; | |
| /* version 2 (OpenType 1.2) */ | |
| SHORT sxHeight; | |
| SHORT sCapHeight; | |
| USHORT usDefaultChar; | |
| USHORT usBreakChar; | |
| USHORT usMaxContext; | |
| } TT_OS2_V2; | |
| typedef struct { | |
| USHORT majorVersion; | |
| USHORT minorVersion; | |
| SHORT ascender; | |
| SHORT descender; | |
| SHORT linegap; | |
| USHORT advanceWidthMax; | |
| SHORT minLeftSideBearing; | |
| SHORT minRightSideBearing; | |
| SHORT xMaxExtent; | |
| SHORT caretSlopeRise; | |
| SHORT caretSlopeRun; | |
| SHORT caretOffset; | |
| SHORT reserved[4]; | |
| SHORT metricDataFormat; | |
| USHORT numberOfHMetrics; | |
| } TT_HHEA; | |
| typedef struct { | |
| WORD version; | |
| WORD flags; | |
| DWORD numStrikes; | |
| DWORD strikeOffset[1]; | |
| } sbix_header; | |
| typedef struct { | |
| WORD ppem; | |
| WORD ppi; | |
| DWORD glyphDataOffsets[1]; | |
| } sbix_strike; | |
| typedef struct { | |
| WORD originOffsetX; | |
| WORD originOffsetY; | |
| DWORD graphicType; | |
| BYTE data[1]; | |
| } sbix_glyph_data; | |
| typedef struct { | |
| DWORD version; | |
| WORD numGlyphs; | |
| } maxp; | |
| typedef struct { | |
| WORD majorVersion; | |
| WORD minorVersion; | |
| DWORD numSizes; | |
| } CBLCHeader; | |
| typedef struct { | |
| BYTE res[12]; | |
| } sbitLineMetrics; | |
| typedef struct { | |
| DWORD indexSubTableArrayOffset; | |
| DWORD indexTablesSize; | |
| DWORD numberofIndexSubTables; | |
| DWORD colorRef; | |
| sbitLineMetrics hori; | |
| sbitLineMetrics vert; | |
| WORD startGlyphIndex; | |
| WORD endGlyphIndex; | |
| BYTE ppemX; | |
| BYTE ppemY; | |
| BYTE bitDepth; | |
| BYTE flags; | |
| } CBLCBitmapSizeTable; | |
| #include "poppack.h" | |
| enum OS2_FSSELECTION { | |
| OS2_FSSELECTION_ITALIC = 1 << 0, | |
| OS2_FSSELECTION_UNDERSCORE = 1 << 1, | |
| OS2_FSSELECTION_NEGATIVE = 1 << 2, | |
| OS2_FSSELECTION_OUTLINED = 1 << 3, | |
| OS2_FSSELECTION_STRIKEOUT = 1 << 4, | |
| OS2_FSSELECTION_BOLD = 1 << 5, | |
| OS2_FSSELECTION_REGULAR = 1 << 6, | |
| OS2_FSSELECTION_USE_TYPO_METRICS = 1 << 7, | |
| OS2_FSSELECTION_WWS = 1 << 8, | |
| OS2_FSSELECTION_OBLIQUE = 1 << 9 | |
| }; | |
| typedef struct { | |
| WORD platformID; | |
| WORD encodingID; | |
| WORD languageID; | |
| WORD nameID; | |
| WORD length; | |
| WORD offset; | |
| } TT_NameRecord; | |
| typedef struct { | |
| WORD format; | |
| WORD count; | |
| WORD stringOffset; | |
| TT_NameRecord nameRecord[1]; | |
| } TT_NAME_V0; | |
| struct VDMX_Header | |
| { | |
| WORD version; | |
| WORD numRecs; | |
| WORD numRatios; | |
| }; | |
| struct VDMX_Ratio | |
| { | |
| BYTE bCharSet; | |
| BYTE xRatio; | |
| BYTE yStartRatio; | |
| BYTE yEndRatio; | |
| }; | |
| struct VDMX_group | |
| { | |
| WORD recs; | |
| BYTE startsz; | |
| BYTE endsz; | |
| }; | |
| struct VDMX_vTable | |
| { | |
| WORD yPelHeight; | |
| SHORT yMax; | |
| SHORT yMin; | |
| }; | |
| typedef struct { | |
| CHAR FeatureTag[4]; | |
| WORD Feature; | |
| } OT_FeatureRecord; | |
| typedef struct { | |
| WORD FeatureCount; | |
| OT_FeatureRecord FeatureRecord[1]; | |
| } OT_FeatureList; | |
| typedef struct { | |
| WORD LookupOrder; /* Reserved */ | |
| WORD ReqFeatureIndex; | |
| WORD FeatureCount; | |
| WORD FeatureIndex[1]; | |
| } OT_LangSys; | |
| typedef struct { | |
| CHAR LangSysTag[4]; | |
| WORD LangSys; | |
| } OT_LangSysRecord; | |
| typedef struct { | |
| WORD DefaultLangSys; | |
| WORD LangSysCount; | |
| OT_LangSysRecord LangSysRecord[1]; | |
| } OT_Script; | |
| typedef struct { | |
| CHAR ScriptTag[4]; | |
| WORD Script; | |
| } OT_ScriptRecord; | |
| typedef struct { | |
| WORD ScriptCount; | |
| OT_ScriptRecord ScriptRecord[1]; | |
| } OT_ScriptList; | |
| typedef struct { | |
| DWORD version; | |
| WORD ScriptList; | |
| WORD FeatureList; | |
| WORD LookupList; | |
| } GPOS_GSUB_Header; | |
| enum OPENTYPE_PLATFORM_ID | |
| { | |
| OPENTYPE_PLATFORM_UNICODE = 0, | |
| OPENTYPE_PLATFORM_MAC, | |
| OPENTYPE_PLATFORM_ISO, | |
| OPENTYPE_PLATFORM_WIN, | |
| OPENTYPE_PLATFORM_CUSTOM | |
| }; | |
| typedef struct { | |
| WORD FeatureParams; | |
| WORD LookupCount; | |
| WORD LookupListIndex[1]; | |
| } OT_Feature; | |
| typedef struct { | |
| WORD LookupCount; | |
| WORD Lookup[1]; | |
| } OT_LookupList; | |
| typedef struct { | |
| WORD LookupType; | |
| WORD LookupFlag; | |
| WORD SubTableCount; | |
| WORD SubTable[1]; | |
| } OT_LookupTable; | |
| typedef struct { | |
| WORD SubstFormat; | |
| WORD Coverage; | |
| WORD DeltaGlyphID; | |
| } GSUB_SingleSubstFormat1; | |
| typedef struct { | |
| WORD SubstFormat; | |
| WORD Coverage; | |
| WORD GlyphCount; | |
| WORD Substitute[1]; | |
| } GSUB_SingleSubstFormat2; | |
| typedef struct { | |
| WORD SubstFormat; | |
| WORD ExtensionLookupType; | |
| DWORD ExtensionOffset; | |
| } GSUB_ExtensionPosFormat1; | |
| enum OPENTYPE_GPOS_LOOKUPS | |
| { | |
| OPENTYPE_GPOS_SINGLE_SUBST = 1, | |
| OPENTYPE_GPOS_EXTENSION_SUBST = 7 | |
| }; | |
| enum TT_NAME_WINDOWS_ENCODING_ID | |
| { | |
| TT_NAME_WINDOWS_ENCODING_SYMBOL = 0, | |
| TT_NAME_WINDOWS_ENCODING_UCS2, | |
| TT_NAME_WINDOWS_ENCODING_SJIS, | |
| TT_NAME_WINDOWS_ENCODING_PRC, | |
| TT_NAME_WINDOWS_ENCODING_BIG5, | |
| TT_NAME_WINDOWS_ENCODING_WANSUNG, | |
| TT_NAME_WINDOWS_ENCODING_JOHAB, | |
| TT_NAME_WINDOWS_ENCODING_RESERVED1, | |
| TT_NAME_WINDOWS_ENCODING_RESERVED2, | |
| TT_NAME_WINDOWS_ENCODING_RESERVED3, | |
| TT_NAME_WINDOWS_ENCODING_UCS4 | |
| }; | |
| enum TT_NAME_MAC_ENCODING_ID | |
| { | |
| TT_NAME_MAC_ENCODING_ROMAN = 0, | |
| TT_NAME_MAC_ENCODING_JAPANESE, | |
| TT_NAME_MAC_ENCODING_TRAD_CHINESE, | |
| TT_NAME_MAC_ENCODING_KOREAN, | |
| TT_NAME_MAC_ENCODING_ARABIC, | |
| TT_NAME_MAC_ENCODING_HEBREW, | |
| TT_NAME_MAC_ENCODING_GREEK, | |
| TT_NAME_MAC_ENCODING_RUSSIAN, | |
| TT_NAME_MAC_ENCODING_RSYMBOL, | |
| TT_NAME_MAC_ENCODING_DEVANAGARI, | |
| TT_NAME_MAC_ENCODING_GURMUKHI, | |
| TT_NAME_MAC_ENCODING_GUJARATI, | |
| TT_NAME_MAC_ENCODING_ORIYA, | |
| TT_NAME_MAC_ENCODING_BENGALI, | |
| TT_NAME_MAC_ENCODING_TAMIL, | |
| TT_NAME_MAC_ENCODING_TELUGU, | |
| TT_NAME_MAC_ENCODING_KANNADA, | |
| TT_NAME_MAC_ENCODING_MALAYALAM, | |
| TT_NAME_MAC_ENCODING_SINHALESE, | |
| TT_NAME_MAC_ENCODING_BURMESE, | |
| TT_NAME_MAC_ENCODING_KHMER, | |
| TT_NAME_MAC_ENCODING_THAI, | |
| TT_NAME_MAC_ENCODING_LAOTIAN, | |
| TT_NAME_MAC_ENCODING_GEORGIAN, | |
| TT_NAME_MAC_ENCODING_ARMENIAN, | |
| TT_NAME_MAC_ENCODING_SIMPL_CHINESE, | |
| TT_NAME_MAC_ENCODING_TIBETAN, | |
| TT_NAME_MAC_ENCODING_MONGOLIAN, | |
| TT_NAME_MAC_ENCODING_GEEZ, | |
| TT_NAME_MAC_ENCODING_SLAVIC, | |
| TT_NAME_MAC_ENCODING_VIETNAMESE, | |
| TT_NAME_MAC_ENCODING_SINDHI, | |
| TT_NAME_MAC_ENCODING_UNINTERPRETED | |
| }; | |
| enum TT_NAME_MAC_LANGUAGE_ID | |
| { | |
| TT_NAME_MAC_LANGID_ENGLISH = 0, | |
| TT_NAME_MAC_LANGID_FRENCH, | |
| TT_NAME_MAC_LANGID_GERMAN, | |
| TT_NAME_MAC_LANGID_ITALIAN, | |
| TT_NAME_MAC_LANGID_DUTCH, | |
| TT_NAME_MAC_LANGID_SWEDISH, | |
| TT_NAME_MAC_LANGID_SPANISH, | |
| TT_NAME_MAC_LANGID_DANISH, | |
| TT_NAME_MAC_LANGID_PORTUGUESE, | |
| TT_NAME_MAC_LANGID_NORWEGIAN, | |
| TT_NAME_MAC_LANGID_HEBREW, | |
| TT_NAME_MAC_LANGID_JAPANESE, | |
| TT_NAME_MAC_LANGID_ARABIC, | |
| TT_NAME_MAC_LANGID_FINNISH, | |
| TT_NAME_MAC_LANGID_GREEK, | |
| TT_NAME_MAC_LANGID_ICELANDIC, | |
| TT_NAME_MAC_LANGID_MALTESE, | |
| TT_NAME_MAC_LANGID_TURKISH, | |
| TT_NAME_MAC_LANGID_CROATIAN, | |
| TT_NAME_MAC_LANGID_TRAD_CHINESE, | |
| TT_NAME_MAC_LANGID_URDU, | |
| TT_NAME_MAC_LANGID_HINDI, | |
| TT_NAME_MAC_LANGID_THAI, | |
| TT_NAME_MAC_LANGID_KOREAN, | |
| TT_NAME_MAC_LANGID_LITHUANIAN, | |
| TT_NAME_MAC_LANGID_POLISH, | |
| TT_NAME_MAC_LANGID_HUNGARIAN, | |
| TT_NAME_MAC_LANGID_ESTONIAN, | |
| TT_NAME_MAC_LANGID_LATVIAN, | |
| TT_NAME_MAC_LANGID_SAMI, | |
| TT_NAME_MAC_LANGID_FAROESE, | |
| TT_NAME_MAC_LANGID_FARSI, | |
| TT_NAME_MAC_LANGID_RUSSIAN, | |
| TT_NAME_MAC_LANGID_SIMPL_CHINESE, | |
| TT_NAME_MAC_LANGID_FLEMISH, | |
| TT_NAME_MAC_LANGID_GAELIC, | |
| TT_NAME_MAC_LANGID_ALBANIAN, | |
| TT_NAME_MAC_LANGID_ROMANIAN, | |
| TT_NAME_MAC_LANGID_CZECH, | |
| TT_NAME_MAC_LANGID_SLOVAK, | |
| TT_NAME_MAC_LANGID_SLOVENIAN, | |
| TT_NAME_MAC_LANGID_YIDDISH, | |
| TT_NAME_MAC_LANGID_SERBIAN, | |
| TT_NAME_MAC_LANGID_MACEDONIAN, | |
| TT_NAME_MAC_LANGID_BULGARIAN, | |
| TT_NAME_MAC_LANGID_UKRAINIAN, | |
| TT_NAME_MAC_LANGID_BYELORUSSIAN, | |
| TT_NAME_MAC_LANGID_UZBEK, | |
| TT_NAME_MAC_LANGID_KAZAKH, | |
| TT_NAME_MAC_LANGID_AZERB_CYR, | |
| TT_NAME_MAC_LANGID_AZERB_ARABIC, | |
| TT_NAME_MAC_LANGID_ARMENIAN, | |
| TT_NAME_MAC_LANGID_GEORGIAN, | |
| TT_NAME_MAC_LANGID_MOLDAVIAN, | |
| TT_NAME_MAC_LANGID_KIRGHIZ, | |
| TT_NAME_MAC_LANGID_TAJIKI, | |
| TT_NAME_MAC_LANGID_TURKMEN, | |
| TT_NAME_MAC_LANGID_MONGOLIAN, | |
| TT_NAME_MAC_LANGID_MONGOLIAN_CYR, | |
| TT_NAME_MAC_LANGID_PASHTO, | |
| TT_NAME_MAC_LANGID_KURDISH, | |
| TT_NAME_MAC_LANGID_KASHMIRI, | |
| TT_NAME_MAC_LANGID_SINDHI, | |
| TT_NAME_MAC_LANGID_TIBETAN, | |
| TT_NAME_MAC_LANGID_NEPALI, | |
| TT_NAME_MAC_LANGID_SANSKRIT, | |
| TT_NAME_MAC_LANGID_MARATHI, | |
| TT_NAME_MAC_LANGID_BENGALI, | |
| TT_NAME_MAC_LANGID_ASSAMESE, | |
| TT_NAME_MAC_LANGID_GUJARATI, | |
| TT_NAME_MAC_LANGID_PUNJABI, | |
| TT_NAME_MAC_LANGID_ORIYA, | |
| TT_NAME_MAC_LANGID_MALAYALAM, | |
| TT_NAME_MAC_LANGID_KANNADA, | |
| TT_NAME_MAC_LANGID_TAMIL, | |
| TT_NAME_MAC_LANGID_TELUGU, | |
| TT_NAME_MAC_LANGID_SINHALESE, | |
| TT_NAME_MAC_LANGID_BURMESE, | |
| TT_NAME_MAC_LANGID_KHMER, | |
| TT_NAME_MAC_LANGID_LAO, | |
| TT_NAME_MAC_LANGID_VIETNAMESE, | |
| TT_NAME_MAC_LANGID_INDONESIAN, | |
| TT_NAME_MAC_LANGID_TAGALOG, | |
| TT_NAME_MAC_LANGID_MALAY_ROMAN, | |
| TT_NAME_MAC_LANGID_MALAY_ARABIC, | |
| TT_NAME_MAC_LANGID_AMHARIC, | |
| TT_NAME_MAC_LANGID_TIGRINYA, | |
| TT_NAME_MAC_LANGID_GALLA, | |
| TT_NAME_MAC_LANGID_SOMALI, | |
| TT_NAME_MAC_LANGID_SWAHILI, | |
| TT_NAME_MAC_LANGID_KINYARWANDA, | |
| TT_NAME_MAC_LANGID_RUNDI, | |
| TT_NAME_MAC_LANGID_NYANJA, | |
| TT_NAME_MAC_LANGID_MALAGASY, | |
| TT_NAME_MAC_LANGID_ESPERANTO, | |
| TT_NAME_MAC_LANGID_WELSH = 128, | |
| TT_NAME_MAC_LANGID_BASQUE, | |
| TT_NAME_MAC_LANGID_CATALAN, | |
| TT_NAME_MAC_LANGID_LATIN, | |
| TT_NAME_MAC_LANGID_QUECHUA, | |
| TT_NAME_MAC_LANGID_GUARANI, | |
| TT_NAME_MAC_LANGID_AYMARA, | |
| TT_NAME_MAC_LANGID_TATAR, | |
| TT_NAME_MAC_LANGID_UIGHUR, | |
| TT_NAME_MAC_LANGID_DZONGKHA, | |
| TT_NAME_MAC_LANGID_JAVANESE, | |
| TT_NAME_MAC_LANGID_SUNDANESE, | |
| TT_NAME_MAC_LANGID_GALICIAN, | |
| TT_NAME_MAC_LANGID_AFRIKAANS, | |
| TT_NAME_MAC_LANGID_BRETON, | |
| TT_NAME_MAC_LANGID_INUKTITUT, | |
| TT_NAME_MAC_LANGID_SCOTTISH_GAELIC, | |
| TT_NAME_MAC_LANGID_MANX_GAELIC, | |
| TT_NAME_MAC_LANGID_IRISH_GAELIC, | |
| TT_NAME_MAC_LANGID_TONGAN, | |
| TT_NAME_MAC_LANGID_GREEK_POLYTONIC, | |
| TT_NAME_MAC_LANGID_GREENLANDIC, | |
| TT_NAME_MAC_LANGID_AZER_ROMAN | |
| }; | |
| /* Names are indexed with TT_NAME_MAC_LANGUAGE_ID values */ | |
| static const char name_mac_langid_to_locale[][10] = { | |
| "en-US", | |
| "fr-FR", | |
| "de-DE", | |
| "it-IT", | |
| "nl-NL", | |
| "sv-SE", | |
| "es-ES", | |
| "da-DA", | |
| "pt-PT", | |
| "no-NO", | |
| "he-IL", | |
| "ja-JP", | |
| "ar-AR", | |
| "fi-FI", | |
| "el-GR", | |
| "is-IS", | |
| "mt-MT", | |
| "tr-TR", | |
| "hr-HR", | |
| "zh-HK", | |
| "ur-PK", | |
| "hi-IN", | |
| "th-TH", | |
| "ko-KR", | |
| "lt-LT", | |
| "pl-PL", | |
| "hu-HU", | |
| "et-EE", | |
| "lv-LV", | |
| "se-NO", | |
| "fo-FO", | |
| "fa-IR", | |
| "ru-RU", | |
| "zh-CN", | |
| "nl-BE", | |
| "gd-GB", | |
| "sq-AL", | |
| "ro-RO", | |
| "cs-CZ", | |
| "sk-SK", | |
| "sl-SI", | |
| "", | |
| "sr-Latn", | |
| "mk-MK", | |
| "bg-BG", | |
| "uk-UA", | |
| "be-BY", | |
| "uz-Latn", | |
| "kk-KZ", | |
| "az-Cyrl-AZ", | |
| "az-AZ", | |
| "hy-AM", | |
| "ka-GE", | |
| "", | |
| "", | |
| "tg-TJ", | |
| "tk-TM", | |
| "mn-Mong", | |
| "mn-MN", | |
| "ps-AF", | |
| "ku-Arab", | |
| "", | |
| "sd-Arab", | |
| "bo-CN", | |
| "ne-NP", | |
| "sa-IN", | |
| "mr-IN", | |
| "bn-IN", | |
| "as-IN", | |
| "gu-IN", | |
| "pa-Arab", | |
| "or-IN", | |
| "ml-IN", | |
| "kn-IN", | |
| "ta-LK", | |
| "te-IN", | |
| "si-LK", | |
| "", | |
| "km-KH", | |
| "lo-LA", | |
| "vi-VN", | |
| "id-ID", | |
| "", | |
| "ms-MY", | |
| "ms-Arab", | |
| "am-ET", | |
| "ti-ET", | |
| "", | |
| "", | |
| "sw-KE", | |
| "rw-RW", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "cy-GB", | |
| "eu-ES", | |
| "ca-ES", | |
| "", | |
| "", | |
| "", | |
| "", | |
| "tt-RU", | |
| "ug-CN", | |
| "", | |
| "", | |
| "", | |
| "gl-ES", | |
| "af-ZA", | |
| "br-FR", | |
| "iu-Latn-CA", | |
| "gd-GB", | |
| "", | |
| "ga-IE", | |
| "", | |
| "", | |
| "kl-GL", | |
| "az-Latn" | |
| }; | |
| enum OPENTYPE_STRING_ID | |
| { | |
| OPENTYPE_STRING_COPYRIGHT_NOTICE = 0, | |
| OPENTYPE_STRING_FAMILY_NAME, | |
| OPENTYPE_STRING_SUBFAMILY_NAME, | |
| OPENTYPE_STRING_UNIQUE_IDENTIFIER, | |
| OPENTYPE_STRING_FULL_FONTNAME, | |
| OPENTYPE_STRING_VERSION_STRING, | |
| OPENTYPE_STRING_POSTSCRIPT_FONTNAME, | |
| OPENTYPE_STRING_TRADEMARK, | |
| OPENTYPE_STRING_MANUFACTURER, | |
| OPENTYPE_STRING_DESIGNER, | |
| OPENTYPE_STRING_DESCRIPTION, | |
| OPENTYPE_STRING_VENDOR_URL, | |
| OPENTYPE_STRING_DESIGNER_URL, | |
| OPENTYPE_STRING_LICENSE_DESCRIPTION, | |
| OPENTYPE_STRING_LICENSE_INFO_URL, | |
| OPENTYPE_STRING_RESERVED_ID15, | |
| OPENTYPE_STRING_PREFERRED_FAMILY_NAME, | |
| OPENTYPE_STRING_PREFERRED_SUBFAMILY_NAME, | |
| OPENTYPE_STRING_COMPATIBLE_FULLNAME, | |
| OPENTYPE_STRING_SAMPLE_TEXT, | |
| OPENTYPE_STRING_POSTSCRIPT_CID_NAME, | |
| OPENTYPE_STRING_WWS_FAMILY_NAME, | |
| OPENTYPE_STRING_WWS_SUBFAMILY_NAME | |
| }; | |
| static const UINT16 dwriteid_to_opentypeid[DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_CID_NAME+1] = | |
| { | |
| (UINT16)-1, /* DWRITE_INFORMATIONAL_STRING_NONE is not used */ | |
| OPENTYPE_STRING_COPYRIGHT_NOTICE, | |
| OPENTYPE_STRING_VERSION_STRING, | |
| OPENTYPE_STRING_TRADEMARK, | |
| OPENTYPE_STRING_MANUFACTURER, | |
| OPENTYPE_STRING_DESIGNER, | |
| OPENTYPE_STRING_DESIGNER_URL, | |
| OPENTYPE_STRING_DESCRIPTION, | |
| OPENTYPE_STRING_VENDOR_URL, | |
| OPENTYPE_STRING_LICENSE_DESCRIPTION, | |
| OPENTYPE_STRING_LICENSE_INFO_URL, | |
| OPENTYPE_STRING_FAMILY_NAME, | |
| OPENTYPE_STRING_SUBFAMILY_NAME, | |
| OPENTYPE_STRING_PREFERRED_FAMILY_NAME, | |
| OPENTYPE_STRING_PREFERRED_SUBFAMILY_NAME, | |
| OPENTYPE_STRING_SAMPLE_TEXT, | |
| OPENTYPE_STRING_FULL_FONTNAME, | |
| OPENTYPE_STRING_POSTSCRIPT_FONTNAME, | |
| OPENTYPE_STRING_POSTSCRIPT_CID_NAME | |
| }; | |
| /* CPAL table */ | |
| struct CPAL_Header_0 | |
| { | |
| USHORT version; | |
| USHORT numPaletteEntries; | |
| USHORT numPalette; | |
| USHORT numColorRecords; | |
| ULONG offsetFirstColorRecord; | |
| USHORT colorRecordIndices[1]; | |
| }; | |
| /* for version == 1, this comes after full CPAL_Header_0 */ | |
| struct CPAL_SubHeader_1 | |
| { | |
| ULONG offsetPaletteTypeArray; | |
| ULONG offsetPaletteLabelArray; | |
| ULONG offsetPaletteEntryLabelArray; | |
| }; | |
| struct CPAL_ColorRecord | |
| { | |
| BYTE blue; | |
| BYTE green; | |
| BYTE red; | |
| BYTE alpha; | |
| }; | |
| /* COLR table */ | |
| struct COLR_Header | |
| { | |
| USHORT version; | |
| USHORT numBaseGlyphRecords; | |
| ULONG offsetBaseGlyphRecord; | |
| ULONG offsetLayerRecord; | |
| USHORT numLayerRecords; | |
| }; | |
| struct COLR_BaseGlyphRecord | |
| { | |
| USHORT GID; | |
| USHORT firstLayerIndex; | |
| USHORT numLayers; | |
| }; | |
| struct COLR_LayerRecord | |
| { | |
| USHORT GID; | |
| USHORT paletteIndex; | |
| }; | |
| BOOL is_face_type_supported(DWRITE_FONT_FACE_TYPE type) | |
| { | |
| return (type == DWRITE_FONT_FACE_TYPE_CFF) || | |
| (type == DWRITE_FONT_FACE_TYPE_TRUETYPE) || | |
| (type == DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION) || | |
| (type == DWRITE_FONT_FACE_TYPE_RAW_CFF); | |
| } | |
| typedef HRESULT (*dwrite_fontfile_analyzer)(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type, | |
| DWRITE_FONT_FACE_TYPE *face_type); | |
| static HRESULT opentype_ttc_analyzer(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type, | |
| DWRITE_FONT_FACE_TYPE *face_type) | |
| { | |
| static const DWORD ttctag = MS_TTCF_TAG; | |
| const TTC_Header_V1 *header; | |
| void *context; | |
| HRESULT hr; | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&header, 0, sizeof(header), &context); | |
| if (FAILED(hr)) | |
| return hr; | |
| if (!memcmp(header->TTCTag, &ttctag, sizeof(ttctag))) { | |
| *font_count = GET_BE_DWORD(header->numFonts); | |
| *file_type = DWRITE_FONT_FILE_TYPE_OPENTYPE_COLLECTION; | |
| *face_type = DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION; | |
| } | |
| IDWriteFontFileStream_ReleaseFileFragment(stream, context); | |
| return *file_type != DWRITE_FONT_FILE_TYPE_UNKNOWN ? S_OK : S_FALSE; | |
| } | |
| static HRESULT opentype_ttf_analyzer(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type, | |
| DWRITE_FONT_FACE_TYPE *face_type) | |
| { | |
| const DWORD *header; | |
| void *context; | |
| HRESULT hr; | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&header, 0, sizeof(*header), &context); | |
| if (FAILED(hr)) | |
| return hr; | |
| if (GET_BE_DWORD(*header) == 0x10000) { | |
| *font_count = 1; | |
| *file_type = DWRITE_FONT_FILE_TYPE_TRUETYPE; | |
| *face_type = DWRITE_FONT_FACE_TYPE_TRUETYPE; | |
| } | |
| IDWriteFontFileStream_ReleaseFileFragment(stream, context); | |
| return *file_type != DWRITE_FONT_FILE_TYPE_UNKNOWN ? S_OK : S_FALSE; | |
| } | |
| static HRESULT opentype_otf_analyzer(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type, | |
| DWRITE_FONT_FACE_TYPE *face_type) | |
| { | |
| const DWORD *header; | |
| void *context; | |
| HRESULT hr; | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&header, 0, sizeof(*header), &context); | |
| if (FAILED(hr)) | |
| return hr; | |
| if (GET_BE_DWORD(*header) == MS_OTTO_TAG) { | |
| *font_count = 1; | |
| *file_type = DWRITE_FONT_FILE_TYPE_CFF; | |
| *face_type = DWRITE_FONT_FACE_TYPE_CFF; | |
| } | |
| IDWriteFontFileStream_ReleaseFileFragment(stream, context); | |
| return *file_type != DWRITE_FONT_FILE_TYPE_UNKNOWN ? S_OK : S_FALSE; | |
| } | |
| static HRESULT opentype_type1_analyzer(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type, | |
| DWRITE_FONT_FACE_TYPE *face_type) | |
| { | |
| #include "pshpack1.h" | |
| /* Specified in Adobe TechNote #5178 */ | |
| struct pfm_header { | |
| WORD dfVersion; | |
| DWORD dfSize; | |
| char data0[95]; | |
| DWORD dfDevice; | |
| char data1[12]; | |
| }; | |
| #include "poppack.h" | |
| struct type1_header { | |
| WORD tag; | |
| char data[14]; | |
| }; | |
| const struct type1_header *header; | |
| void *context; | |
| HRESULT hr; | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&header, 0, sizeof(*header), &context); | |
| if (FAILED(hr)) | |
| return hr; | |
| /* tag is followed by plain text section */ | |
| if (header->tag == 0x8001 && | |
| (!memcmp(header->data, "%!PS-AdobeFont", 14) || | |
| !memcmp(header->data, "%!FontType", 10))) { | |
| *font_count = 1; | |
| *file_type = DWRITE_FONT_FILE_TYPE_TYPE1_PFB; | |
| *face_type = DWRITE_FONT_FACE_TYPE_TYPE1; | |
| } | |
| IDWriteFontFileStream_ReleaseFileFragment(stream, context); | |
| /* let's see if it's a .pfm metrics file */ | |
| if (*file_type == DWRITE_FONT_FILE_TYPE_UNKNOWN) { | |
| const struct pfm_header *pfm_header; | |
| UINT64 filesize; | |
| DWORD offset; | |
| BOOL header_checked; | |
| hr = IDWriteFontFileStream_GetFileSize(stream, &filesize); | |
| if (FAILED(hr)) | |
| return hr; | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&pfm_header, 0, sizeof(*pfm_header), &context); | |
| if (FAILED(hr)) | |
| return hr; | |
| offset = pfm_header->dfDevice; | |
| header_checked = pfm_header->dfVersion == 0x100 && pfm_header->dfSize == filesize; | |
| IDWriteFontFileStream_ReleaseFileFragment(stream, context); | |
| /* as a last test check static string in PostScript information section */ | |
| if (header_checked) { | |
| static const char postscript[] = "PostScript"; | |
| char *devtype_name; | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&devtype_name, offset, sizeof(postscript), &context); | |
| if (FAILED(hr)) | |
| return hr; | |
| if (!memcmp(devtype_name, postscript, sizeof(postscript))) { | |
| *font_count = 1; | |
| *file_type = DWRITE_FONT_FILE_TYPE_TYPE1_PFM; | |
| *face_type = DWRITE_FONT_FACE_TYPE_TYPE1; | |
| } | |
| IDWriteFontFileStream_ReleaseFileFragment(stream, context); | |
| } | |
| } | |
| return *file_type != DWRITE_FONT_FILE_TYPE_UNKNOWN ? S_OK : S_FALSE; | |
| } | |
| HRESULT opentype_analyze_font(IDWriteFontFileStream *stream, UINT32* font_count, DWRITE_FONT_FILE_TYPE *file_type, DWRITE_FONT_FACE_TYPE *face_type, BOOL *supported) | |
| { | |
| static dwrite_fontfile_analyzer fontfile_analyzers[] = { | |
| opentype_ttf_analyzer, | |
| opentype_otf_analyzer, | |
| opentype_ttc_analyzer, | |
| opentype_type1_analyzer, | |
| NULL | |
| }; | |
| dwrite_fontfile_analyzer *analyzer = fontfile_analyzers; | |
| DWRITE_FONT_FACE_TYPE face; | |
| HRESULT hr; | |
| if (!face_type) | |
| face_type = &face; | |
| *file_type = DWRITE_FONT_FILE_TYPE_UNKNOWN; | |
| *face_type = DWRITE_FONT_FACE_TYPE_UNKNOWN; | |
| *font_count = 0; | |
| while (*analyzer) { | |
| hr = (*analyzer)(stream, font_count, file_type, face_type); | |
| if (FAILED(hr)) | |
| return hr; | |
| if (hr == S_OK) | |
| break; | |
| analyzer++; | |
| } | |
| *supported = is_face_type_supported(*face_type); | |
| return S_OK; | |
| } | |
| HRESULT opentype_get_font_table(struct file_stream_desc *stream_desc, UINT32 tag, const void **table_data, | |
| void **table_context, UINT32 *table_size, BOOL *found) | |
| { | |
| void *table_directory_context, *sfnt_context; | |
| TT_TableRecord *table_record = NULL; | |
| TTC_SFNT_V1 *font_header = NULL; | |
| UINT32 table_offset = 0; | |
| UINT16 table_count; | |
| HRESULT hr; | |
| if (found) *found = FALSE; | |
| if (table_size) *table_size = 0; | |
| *table_data = NULL; | |
| *table_context = NULL; | |
| if (stream_desc->face_type == DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION) { | |
| const TTC_Header_V1 *ttc_header; | |
| void * ttc_context; | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void**)&ttc_header, 0, sizeof(*ttc_header), &ttc_context); | |
| if (SUCCEEDED(hr)) { | |
| if (stream_desc->face_index >= GET_BE_DWORD(ttc_header->numFonts)) | |
| hr = E_INVALIDARG; | |
| else { | |
| table_offset = GET_BE_DWORD(ttc_header->OffsetTable[stream_desc->face_index]); | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void**)&font_header, table_offset, sizeof(*font_header), &sfnt_context); | |
| } | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, ttc_context); | |
| } | |
| } | |
| else | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void**)&font_header, 0, sizeof(*font_header), &sfnt_context); | |
| if (FAILED(hr)) | |
| return hr; | |
| table_count = GET_BE_WORD(font_header->numTables); | |
| table_offset += sizeof(*font_header); | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, sfnt_context); | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void **)&table_record, table_offset, | |
| table_count * sizeof(*table_record), &table_directory_context); | |
| if (hr == S_OK) { | |
| UINT16 i; | |
| for (i = 0; i < table_count; i++) { | |
| if (table_record->tag == tag) { | |
| UINT32 offset = GET_BE_DWORD(table_record->offset); | |
| UINT32 length = GET_BE_DWORD(table_record->length); | |
| if (found) | |
| *found = TRUE; | |
| if (table_size) | |
| *table_size = length; | |
| hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, table_data, offset, | |
| length, table_context); | |
| break; | |
| } | |
| table_record++; | |
| } | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, table_directory_context); | |
| } | |
| return hr; | |
| } | |
| /********** | |
| * CMAP | |
| **********/ | |
| static UINT32 opentype_cmap_get_unicode_ranges_count(const CMAP_Header *CMAP_Table) | |
| { | |
| UINT32 count = 0; | |
| int i; | |
| for (i = 0; i < GET_BE_WORD(CMAP_Table->numTables); i++) { | |
| WORD type; | |
| WORD *table; | |
| if (GET_BE_WORD(CMAP_Table->tables[i].platformID) != 3) | |
| continue; | |
| table = (WORD*)(((BYTE*)CMAP_Table) + GET_BE_DWORD(CMAP_Table->tables[i].offset)); | |
| type = GET_BE_WORD(*table); | |
| TRACE("table type %i\n", type); | |
| switch (type) | |
| { | |
| case OPENTYPE_CMAP_TABLE_SEGMENT_MAPPING: | |
| { | |
| CMAP_SegmentMapping_0 *format = (CMAP_SegmentMapping_0*)table; | |
| count += GET_BE_WORD(format->segCountX2)/2; | |
| break; | |
| } | |
| case OPENTYPE_CMAP_TABLE_SEGMENTED_COVERAGE: | |
| { | |
| CMAP_SegmentedCoverage *format = (CMAP_SegmentedCoverage*)table; | |
| count += GET_BE_DWORD(format->nGroups); | |
| break; | |
| } | |
| default: | |
| FIXME("table type %i unhandled.\n", type); | |
| } | |
| } | |
| return count; | |
| } | |
| HRESULT opentype_cmap_get_unicode_ranges(void *data, UINT32 max_count, DWRITE_UNICODE_RANGE *ranges, UINT32 *count) | |
| { | |
| CMAP_Header *CMAP_Table = data; | |
| int i, k = 0; | |
| if (!CMAP_Table) | |
| return E_FAIL; | |
| *count = opentype_cmap_get_unicode_ranges_count(CMAP_Table); | |
| for (i = 0; i < GET_BE_WORD(CMAP_Table->numTables) && k < max_count; i++) | |
| { | |
| WORD type; | |
| WORD *table; | |
| int j; | |
| if (GET_BE_WORD(CMAP_Table->tables[i].platformID) != 3) | |
| continue; | |
| table = (WORD*)(((BYTE*)CMAP_Table) + GET_BE_DWORD(CMAP_Table->tables[i].offset)); | |
| type = GET_BE_WORD(*table); | |
| TRACE("table type %i\n", type); | |
| switch (type) | |
| { | |
| case OPENTYPE_CMAP_TABLE_SEGMENT_MAPPING: | |
| { | |
| CMAP_SegmentMapping_0 *format = (CMAP_SegmentMapping_0*)table; | |
| UINT16 segment_count = GET_BE_WORD(format->segCountX2)/2; | |
| UINT16 *startCode = (WORD*)((BYTE*)format + sizeof(CMAP_SegmentMapping_0) + (sizeof(WORD) * segment_count)); | |
| for (j = 0; j < segment_count && GET_BE_WORD(format->endCode[j]) < 0xffff && k < max_count; j++, k++) { | |
| ranges[k].first = GET_BE_WORD(startCode[j]); | |
| ranges[k].last = GET_BE_WORD(format->endCode[j]); | |
| } | |
| break; | |
| } | |
| case OPENTYPE_CMAP_TABLE_SEGMENTED_COVERAGE: | |
| { | |
| CMAP_SegmentedCoverage *format = (CMAP_SegmentedCoverage*)table; | |
| for (j = 0; j < GET_BE_DWORD(format->nGroups) && k < max_count; j++, k++) { | |
| ranges[k].first = GET_BE_DWORD(format->groups[j].startCharCode); | |
| ranges[k].last = GET_BE_DWORD(format->groups[j].endCharCode); | |
| } | |
| break; | |
| } | |
| default: | |
| FIXME("table type %i unhandled.\n", type); | |
| } | |
| } | |
| return *count > max_count ? E_NOT_SUFFICIENT_BUFFER : S_OK; | |
| } | |
| void opentype_get_font_metrics(struct file_stream_desc *stream_desc, DWRITE_FONT_METRICS1 *metrics, DWRITE_CARET_METRICS *caret) | |
| { | |
| void *os2_context, *head_context, *post_context, *hhea_context; | |
| const TT_OS2_V2 *tt_os2; | |
| const TT_HEAD *tt_head; | |
| const TT_POST *tt_post; | |
| const TT_HHEA *tt_hhea; | |
| memset(metrics, 0, sizeof(*metrics)); | |
| opentype_get_font_table(stream_desc, MS_OS2_TAG, (const void**)&tt_os2, &os2_context, NULL, NULL); | |
| opentype_get_font_table(stream_desc, MS_HEAD_TAG, (const void**)&tt_head, &head_context, NULL, NULL); | |
| opentype_get_font_table(stream_desc, MS_POST_TAG, (const void**)&tt_post, &post_context, NULL, NULL); | |
| opentype_get_font_table(stream_desc, MS_HHEA_TAG, (const void**)&tt_hhea, &hhea_context, NULL, NULL); | |
| if (tt_head) { | |
| metrics->designUnitsPerEm = GET_BE_WORD(tt_head->unitsPerEm); | |
| metrics->glyphBoxLeft = GET_BE_WORD(tt_head->xMin); | |
| metrics->glyphBoxTop = GET_BE_WORD(tt_head->yMax); | |
| metrics->glyphBoxRight = GET_BE_WORD(tt_head->xMax); | |
| metrics->glyphBoxBottom = GET_BE_WORD(tt_head->yMin); | |
| } | |
| if (caret) { | |
| if (tt_hhea) { | |
| caret->slopeRise = GET_BE_WORD(tt_hhea->caretSlopeRise); | |
| caret->slopeRun = GET_BE_WORD(tt_hhea->caretSlopeRun); | |
| caret->offset = GET_BE_WORD(tt_hhea->caretOffset); | |
| } | |
| else { | |
| caret->slopeRise = 0; | |
| caret->slopeRun = 0; | |
| caret->offset = 0; | |
| } | |
| } | |
| if (tt_os2) { | |
| USHORT version = GET_BE_WORD(tt_os2->version); | |
| metrics->ascent = GET_BE_WORD(tt_os2->usWinAscent); | |
| /* Some fonts have usWinDescent value stored as signed short, which could be wrongly | |
| interpreted as large unsigned value. */ | |
| metrics->descent = abs((SHORT)GET_BE_WORD(tt_os2->usWinDescent)); | |
| /* line gap is estimated using two sets of ascender/descender values and 'hhea' line gap */ | |
| if (tt_hhea) { | |
| SHORT descender = (SHORT)GET_BE_WORD(tt_hhea->descender); | |
| INT32 linegap; | |
| linegap = GET_BE_WORD(tt_hhea->ascender) + abs(descender) + GET_BE_WORD(tt_hhea->linegap) - | |
| metrics->ascent - metrics->descent; | |
| metrics->lineGap = linegap > 0 ? linegap : 0; | |
| } | |
| metrics->strikethroughPosition = GET_BE_WORD(tt_os2->yStrikeoutPosition); | |
| metrics->strikethroughThickness = GET_BE_WORD(tt_os2->yStrikeoutSize); | |
| metrics->subscriptPositionX = GET_BE_WORD(tt_os2->ySubscriptXOffset); | |
| /* Y offset is stored as positive offset below baseline */ | |
| metrics->subscriptPositionY = -GET_BE_WORD(tt_os2->ySubscriptYOffset); | |
| metrics->subscriptSizeX = GET_BE_WORD(tt_os2->ySubscriptXSize); | |
| metrics->subscriptSizeY = GET_BE_WORD(tt_os2->ySubscriptYSize); | |
| metrics->superscriptPositionX = GET_BE_WORD(tt_os2->ySuperscriptXOffset); | |
| metrics->superscriptPositionY = GET_BE_WORD(tt_os2->ySuperscriptYOffset); | |
| metrics->superscriptSizeX = GET_BE_WORD(tt_os2->ySuperscriptXSize); | |
| metrics->superscriptSizeY = GET_BE_WORD(tt_os2->ySuperscriptYSize); | |
| /* version 2 fields */ | |
| if (version >= 2) { | |
| metrics->capHeight = GET_BE_WORD(tt_os2->sCapHeight); | |
| metrics->xHeight = GET_BE_WORD(tt_os2->sxHeight); | |
| } | |
| if (GET_BE_WORD(tt_os2->fsSelection) & OS2_FSSELECTION_USE_TYPO_METRICS) { | |
| SHORT descent = GET_BE_WORD(tt_os2->sTypoDescender); | |
| metrics->ascent = GET_BE_WORD(tt_os2->sTypoAscender); | |
| metrics->descent = descent < 0 ? -descent : 0; | |
| metrics->lineGap = GET_BE_WORD(tt_os2->sTypoLineGap); | |
| metrics->hasTypographicMetrics = TRUE; | |
| } | |
| } | |
| if (tt_post) { | |
| metrics->underlinePosition = GET_BE_WORD(tt_post->underlinePosition); | |
| metrics->underlineThickness = GET_BE_WORD(tt_post->underlineThickness); | |
| } | |
| if (metrics->underlineThickness == 0) | |
| metrics->underlineThickness = metrics->designUnitsPerEm / 14; | |
| if (metrics->strikethroughThickness == 0) | |
| metrics->strikethroughThickness = metrics->underlineThickness; | |
| /* estimate missing metrics */ | |
| if (metrics->xHeight == 0) | |
| metrics->xHeight = metrics->designUnitsPerEm / 2; | |
| if (metrics->capHeight == 0) | |
| metrics->capHeight = metrics->designUnitsPerEm * 7 / 10; | |
| if (tt_os2) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2_context); | |
| if (tt_head) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, head_context); | |
| if (tt_post) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, post_context); | |
| if (tt_hhea) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, hhea_context); | |
| } | |
| void opentype_get_font_properties(struct file_stream_desc *stream_desc, struct dwrite_font_props *props) | |
| { | |
| void *os2_context, *head_context; | |
| const TT_OS2_V2 *tt_os2; | |
| const TT_HEAD *tt_head; | |
| opentype_get_font_table(stream_desc, MS_OS2_TAG, (const void**)&tt_os2, &os2_context, NULL, NULL); | |
| opentype_get_font_table(stream_desc, MS_HEAD_TAG, (const void**)&tt_head, &head_context, NULL, NULL); | |
| /* default stretch, weight and style to normal */ | |
| props->stretch = DWRITE_FONT_STRETCH_NORMAL; | |
| props->weight = DWRITE_FONT_WEIGHT_NORMAL; | |
| props->style = DWRITE_FONT_STYLE_NORMAL; | |
| memset(&props->panose, 0, sizeof(props->panose)); | |
| memset(&props->fontsig, 0, sizeof(props->fontsig)); | |
| memset(&props->lf, 0, sizeof(props->lf)); | |
| /* DWRITE_FONT_STRETCH enumeration values directly match font data values */ | |
| if (tt_os2) { | |
| USHORT version = GET_BE_WORD(tt_os2->version); | |
| USHORT fsSelection = GET_BE_WORD(tt_os2->fsSelection); | |
| USHORT usWeightClass = GET_BE_WORD(tt_os2->usWeightClass); | |
| USHORT usWidthClass = GET_BE_WORD(tt_os2->usWidthClass); | |
| if (usWidthClass > DWRITE_FONT_STRETCH_UNDEFINED && usWidthClass <= DWRITE_FONT_STRETCH_ULTRA_EXPANDED) | |
| props->stretch = usWidthClass; | |
| if (usWeightClass >= 1 && usWeightClass <= 9) | |
| usWeightClass *= 100; | |
| if (usWeightClass > DWRITE_FONT_WEIGHT_ULTRA_BLACK) | |
| props->weight = DWRITE_FONT_WEIGHT_ULTRA_BLACK; | |
| else if (usWeightClass > 0) | |
| props->weight = usWeightClass; | |
| if (version >= 4 && (fsSelection & OS2_FSSELECTION_OBLIQUE)) | |
| props->style = DWRITE_FONT_STYLE_OBLIQUE; | |
| else if (fsSelection & OS2_FSSELECTION_ITALIC) | |
| props->style = DWRITE_FONT_STYLE_ITALIC; | |
| memcpy(&props->panose, &tt_os2->panose, sizeof(props->panose)); | |
| /* FONTSIGNATURE */ | |
| props->fontsig.fsUsb[0] = GET_BE_DWORD(tt_os2->ulUnicodeRange1); | |
| props->fontsig.fsUsb[1] = GET_BE_DWORD(tt_os2->ulUnicodeRange2); | |
| props->fontsig.fsUsb[2] = GET_BE_DWORD(tt_os2->ulUnicodeRange3); | |
| props->fontsig.fsUsb[3] = GET_BE_DWORD(tt_os2->ulUnicodeRange4); | |
| if (GET_BE_WORD(tt_os2->version) == 0) { | |
| props->fontsig.fsCsb[0] = 0; | |
| props->fontsig.fsCsb[1] = 0; | |
| } | |
| else { | |
| props->fontsig.fsCsb[0] = GET_BE_DWORD(tt_os2->ulCodePageRange1); | |
| props->fontsig.fsCsb[1] = GET_BE_DWORD(tt_os2->ulCodePageRange2); | |
| } | |
| } | |
| else if (tt_head) { | |
| USHORT macStyle = GET_BE_WORD(tt_head->macStyle); | |
| if (macStyle & TT_HEAD_MACSTYLE_CONDENSED) | |
| props->stretch = DWRITE_FONT_STRETCH_CONDENSED; | |
| else if (macStyle & TT_HEAD_MACSTYLE_EXTENDED) | |
| props->stretch = DWRITE_FONT_STRETCH_EXPANDED; | |
| if (macStyle & TT_HEAD_MACSTYLE_BOLD) | |
| props->weight = DWRITE_FONT_WEIGHT_BOLD; | |
| if (macStyle & TT_HEAD_MACSTYLE_ITALIC) | |
| props->style = DWRITE_FONT_STYLE_ITALIC; | |
| } | |
| props->lf.lfWeight = props->weight; | |
| props->lf.lfItalic = props->style == DWRITE_FONT_STYLE_ITALIC; | |
| TRACE("stretch=%d, weight=%d, style %d\n", props->stretch, props->weight, props->style); | |
| if (tt_os2) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2_context); | |
| if (tt_head) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, head_context); | |
| } | |
| static UINT get_name_record_codepage(enum OPENTYPE_PLATFORM_ID platform, USHORT encoding) | |
| { | |
| UINT codepage = 0; | |
| switch (platform) { | |
| case OPENTYPE_PLATFORM_UNICODE: | |
| break; | |
| case OPENTYPE_PLATFORM_MAC: | |
| switch (encoding) | |
| { | |
| case TT_NAME_MAC_ENCODING_ROMAN: | |
| codepage = 10000; | |
| break; | |
| case TT_NAME_MAC_ENCODING_JAPANESE: | |
| codepage = 10001; | |
| break; | |
| case TT_NAME_MAC_ENCODING_TRAD_CHINESE: | |
| codepage = 10002; | |
| break; | |
| case TT_NAME_MAC_ENCODING_KOREAN: | |
| codepage = 10003; | |
| break; | |
| case TT_NAME_MAC_ENCODING_ARABIC: | |
| codepage = 10004; | |
| break; | |
| case TT_NAME_MAC_ENCODING_HEBREW: | |
| codepage = 10005; | |
| break; | |
| case TT_NAME_MAC_ENCODING_GREEK: | |
| codepage = 10006; | |
| break; | |
| case TT_NAME_MAC_ENCODING_RUSSIAN: | |
| codepage = 10007; | |
| break; | |
| case TT_NAME_MAC_ENCODING_SIMPL_CHINESE: | |
| codepage = 10008; | |
| break; | |
| case TT_NAME_MAC_ENCODING_THAI: | |
| codepage = 10021; | |
| break; | |
| default: | |
| FIXME("encoding %u not handled, platform %d.\n", encoding, platform); | |
| break; | |
| } | |
| break; | |
| case OPENTYPE_PLATFORM_WIN: | |
| switch (encoding) | |
| { | |
| case TT_NAME_WINDOWS_ENCODING_SYMBOL: | |
| case TT_NAME_WINDOWS_ENCODING_UCS2: | |
| break; | |
| case TT_NAME_WINDOWS_ENCODING_SJIS: | |
| codepage = 932; | |
| break; | |
| case TT_NAME_WINDOWS_ENCODING_PRC: | |
| codepage = 936; | |
| break; | |
| case TT_NAME_WINDOWS_ENCODING_BIG5: | |
| codepage = 950; | |
| break; | |
| case TT_NAME_WINDOWS_ENCODING_WANSUNG: | |
| codepage = 20949; | |
| break; | |
| case TT_NAME_WINDOWS_ENCODING_JOHAB: | |
| codepage = 1361; | |
| break; | |
| default: | |
| FIXME("encoding %u not handled, platform %d.\n", encoding, platform); | |
| break; | |
| } | |
| break; | |
| default: | |
| FIXME("unknown platform %d\n", platform); | |
| } | |
| return codepage; | |
| } | |
| static void get_name_record_locale(enum OPENTYPE_PLATFORM_ID platform, USHORT lang_id, WCHAR *locale, USHORT locale_len) | |
| { | |
| static const WCHAR enusW[] = {'e','n','-','U','S',0}; | |
| switch (platform) { | |
| case OPENTYPE_PLATFORM_MAC: | |
| { | |
| const char *locale_name = NULL; | |
| if (lang_id > TT_NAME_MAC_LANGID_AZER_ROMAN) | |
| WARN("invalid mac lang id %d\n", lang_id); | |
| else if (!name_mac_langid_to_locale[lang_id][0]) | |
| FIXME("failed to map mac lang id %d to locale name\n", lang_id); | |
| else | |
| locale_name = name_mac_langid_to_locale[lang_id]; | |
| if (locale_name) | |
| MultiByteToWideChar(CP_ACP, 0, name_mac_langid_to_locale[lang_id], -1, locale, locale_len); | |
| else | |
| strcpyW(locale, enusW); | |
| break; | |
| } | |
| case OPENTYPE_PLATFORM_WIN: | |
| if (!LCIDToLocaleName(MAKELCID(lang_id, SORT_DEFAULT), locale, locale_len, 0)) { | |
| FIXME("failed to get locale name for lcid=0x%08x\n", MAKELCID(lang_id, SORT_DEFAULT)); | |
| strcpyW(locale, enusW); | |
| } | |
| break; | |
| case OPENTYPE_PLATFORM_UNICODE: | |
| strcpyW(locale, enusW); | |
| break; | |
| default: | |
| FIXME("unknown platform %d\n", platform); | |
| } | |
| } | |
| static BOOL opentype_decode_namerecord(const TT_NAME_V0 *header, BYTE *storage_area, USHORT recid, IDWriteLocalizedStrings *strings) | |
| { | |
| const TT_NameRecord *record = &header->nameRecord[recid]; | |
| USHORT lang_id, length, offset, encoding, platform; | |
| BOOL ret = FALSE; | |
| platform = GET_BE_WORD(record->platformID); | |
| lang_id = GET_BE_WORD(record->languageID); | |
| length = GET_BE_WORD(record->length); | |
| offset = GET_BE_WORD(record->offset); | |
| encoding = GET_BE_WORD(record->encodingID); | |
| if (lang_id < 0x8000) { | |
| WCHAR locale[LOCALE_NAME_MAX_LENGTH]; | |
| WCHAR *name_string; | |
| UINT codepage; | |
| codepage = get_name_record_codepage(platform, encoding); | |
| get_name_record_locale(platform, lang_id, locale, sizeof(locale)/sizeof(WCHAR)); | |
| if (codepage) { | |
| DWORD len = MultiByteToWideChar(codepage, 0, (LPSTR)(storage_area + offset), length, NULL, 0); | |
| name_string = heap_alloc(sizeof(WCHAR) * (len+1)); | |
| MultiByteToWideChar(codepage, 0, (LPSTR)(storage_area + offset), length, name_string, len); | |
| name_string[len] = 0; | |
| } | |
| else { | |
| int i; | |
| length /= sizeof(WCHAR); | |
| name_string = heap_strdupnW((LPWSTR)(storage_area + offset), length); | |
| for (i = 0; i < length; i++) | |
| name_string[i] = GET_BE_WORD(name_string[i]); | |
| } | |
| TRACE("string %s for locale %s found\n", debugstr_w(name_string), debugstr_w(locale)); | |
| add_localizedstring(strings, locale, name_string); | |
| heap_free(name_string); | |
| ret = TRUE; | |
| } | |
| else | |
| FIXME("handle NAME format 1\n"); | |
| return ret; | |
| } | |
| static HRESULT opentype_get_font_strings_from_id(const void *table_data, enum OPENTYPE_STRING_ID id, IDWriteLocalizedStrings **strings) | |
| { | |
| const TT_NAME_V0 *header; | |
| BYTE *storage_area = 0; | |
| USHORT count = 0; | |
| int i, candidate; | |
| WORD format; | |
| BOOL exists; | |
| HRESULT hr; | |
| if (!table_data) | |
| return E_FAIL; | |
| hr = create_localizedstrings(strings); | |
| if (FAILED(hr)) return hr; | |
| header = table_data; | |
| format = GET_BE_WORD(header->format); | |
| switch (format) { | |
| case 0: | |
| case 1: | |
| break; | |
| default: | |
| FIXME("unsupported NAME format %d\n", format); | |
| } | |
| storage_area = (LPBYTE)table_data + GET_BE_WORD(header->stringOffset); | |
| count = GET_BE_WORD(header->count); | |
| exists = FALSE; | |
| candidate = -1; | |
| for (i = 0; i < count; i++) { | |
| const TT_NameRecord *record = &header->nameRecord[i]; | |
| USHORT platform; | |
| if (GET_BE_WORD(record->nameID) != id) | |
| continue; | |
| /* Right now only accept unicode and windows encoded fonts */ | |
| platform = GET_BE_WORD(record->platformID); | |
| if (platform != OPENTYPE_PLATFORM_UNICODE && | |
| platform != OPENTYPE_PLATFORM_MAC && | |
| platform != OPENTYPE_PLATFORM_WIN) | |
| { | |
| FIXME("platform %i not supported\n", platform); | |
| continue; | |
| } | |
| /* Skip such entries for now, fonts tend to duplicate those strings as | |
| WIN platform entries. If font does not have WIN or MAC entry for this id, we will | |
| use this Unicode platform entry while assuming en-US locale. */ | |
| if (platform == OPENTYPE_PLATFORM_UNICODE) { | |
| candidate = i; | |
| continue; | |
| } | |
| if (!opentype_decode_namerecord(header, storage_area, i, *strings)) | |
| continue; | |
| exists = TRUE; | |
| } | |
| if (!exists) { | |
| if (candidate != -1) | |
| exists = opentype_decode_namerecord(header, storage_area, candidate, *strings); | |
| else { | |
| IDWriteLocalizedStrings_Release(*strings); | |
| *strings = NULL; | |
| } | |
| } | |
| return exists ? S_OK : E_FAIL; | |
| } | |
| /* Provides a conversion from DWRITE to OpenType name ids, input id should be valid, it's not checked. */ | |
| HRESULT opentype_get_font_info_strings(const void *table_data, DWRITE_INFORMATIONAL_STRING_ID id, IDWriteLocalizedStrings **strings) | |
| { | |
| return opentype_get_font_strings_from_id(table_data, dwriteid_to_opentypeid[id], strings); | |
| } | |
| /* FamilyName locating order is WWS Family Name -> Preferred Family Name -> Family Name. If font claims to | |
| have 'Preferred Family Name' in WWS format, then WWS name is not used. */ | |
| HRESULT opentype_get_font_familyname(struct file_stream_desc *stream_desc, IDWriteLocalizedStrings **names) | |
| { | |
| const TT_OS2_V2 *tt_os2; | |
| void *os2_context, *name_context; | |
| const void *name_table; | |
| HRESULT hr; | |
| opentype_get_font_table(stream_desc, MS_OS2_TAG, (const void**)&tt_os2, &os2_context, NULL, NULL); | |
| opentype_get_font_table(stream_desc, MS_NAME_TAG, &name_table, &name_context, NULL, NULL); | |
| *names = NULL; | |
| /* if Preferred Family doesn't conform to WWS model try WWS name */ | |
| if (tt_os2 && !(GET_BE_WORD(tt_os2->fsSelection) & OS2_FSSELECTION_WWS)) | |
| hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_WWS_FAMILY_NAME, names); | |
| else | |
| hr = E_FAIL; | |
| if (FAILED(hr)) | |
| hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_PREFERRED_FAMILY_NAME, names); | |
| if (FAILED(hr)) | |
| hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_FAMILY_NAME, names); | |
| if (tt_os2) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2_context); | |
| if (name_context) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, name_context); | |
| return hr; | |
| } | |
| /* FaceName locating order is WWS Face Name -> Preferred Face Name -> Face Name. If font claims to | |
| have 'Preferred Face Name' in WWS format, then WWS name is not used. */ | |
| HRESULT opentype_get_font_facename(struct file_stream_desc *stream_desc, WCHAR *lfname, IDWriteLocalizedStrings **names) | |
| { | |
| IDWriteLocalizedStrings *lfnames; | |
| void *os2_context, *name_context; | |
| const TT_OS2_V2 *tt_os2; | |
| const void *name_table; | |
| HRESULT hr; | |
| opentype_get_font_table(stream_desc, MS_OS2_TAG, (const void**)&tt_os2, &os2_context, NULL, NULL); | |
| opentype_get_font_table(stream_desc, MS_NAME_TAG, &name_table, &name_context, NULL, NULL); | |
| *names = NULL; | |
| /* if Preferred Family doesn't conform to WWS model try WWS name */ | |
| if (tt_os2 && !(GET_BE_WORD(tt_os2->fsSelection) & OS2_FSSELECTION_WWS)) | |
| hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_WWS_SUBFAMILY_NAME, names); | |
| else | |
| hr = E_FAIL; | |
| if (FAILED(hr)) | |
| hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_PREFERRED_SUBFAMILY_NAME, names); | |
| if (FAILED(hr)) | |
| hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_SUBFAMILY_NAME, names); | |
| /* User locale is preferred, with fallback to en-us. */ | |
| *lfname = 0; | |
| if (SUCCEEDED(opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_FAMILY_NAME, &lfnames))) { | |
| static const WCHAR enusW[] = {'e','n','-','u','s',0}; | |
| WCHAR localeW[LOCALE_NAME_MAX_LENGTH]; | |
| UINT32 index; | |
| BOOL exists; | |
| exists = FALSE; | |
| if (GetSystemDefaultLocaleName(localeW, sizeof(localeW)/sizeof(WCHAR))) | |
| IDWriteLocalizedStrings_FindLocaleName(lfnames, localeW, &index, &exists); | |
| if (!exists) | |
| IDWriteLocalizedStrings_FindLocaleName(lfnames, enusW, &index, &exists); | |
| if (exists) | |
| IDWriteLocalizedStrings_GetString(lfnames, index, lfname, LF_FACESIZE); | |
| IDWriteLocalizedStrings_Release(lfnames); | |
| } | |
| if (tt_os2) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2_context); | |
| if (name_context) | |
| IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, name_context); | |
| return hr; | |
| } | |
| static inline const OT_Script *opentype_get_script(const OT_ScriptList *scriptlist, UINT32 scripttag) | |
| { | |
| UINT16 j; | |
| for (j = 0; j < GET_BE_WORD(scriptlist->ScriptCount); j++) { | |
| const char *tag = scriptlist->ScriptRecord[j].ScriptTag; | |
| if (scripttag == DWRITE_MAKE_OPENTYPE_TAG(tag[0], tag[1], tag[2], tag[3])) | |
| return (OT_Script*)((BYTE*)scriptlist + GET_BE_WORD(scriptlist->ScriptRecord[j].Script)); | |
| } | |
| return NULL; | |
| } | |
| static inline const OT_LangSys *opentype_get_langsys(const OT_Script *script, UINT32 languagetag) | |
| { | |
| UINT16 j; | |
| for (j = 0; j < GET_BE_WORD(script->LangSysCount); j++) { | |
| const char *tag = script->LangSysRecord[j].LangSysTag; | |
| if (languagetag == DWRITE_MAKE_OPENTYPE_TAG(tag[0], tag[1], tag[2], tag[3])) | |
| return (OT_LangSys*)((BYTE*)script + GET_BE_WORD(script->LangSysRecord[j].LangSys)); | |
| } | |
| return NULL; | |
| } | |
| static void opentype_add_font_features(const GPOS_GSUB_Header *header, const OT_LangSys *langsys, | |
| UINT32 max_tagcount, UINT32 *count, DWRITE_FONT_FEATURE_TAG *tags) | |
| { | |
| const OT_FeatureList *features = (const OT_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList)); | |
| UINT16 j; | |
| for (j = 0; j < GET_BE_WORD(langsys->FeatureCount); j++) { | |
| const OT_FeatureRecord *feature = &features->FeatureRecord[langsys->FeatureIndex[j]]; | |
| const char *tag = feature->FeatureTag; | |
| if (*count < max_tagcount) | |
| tags[*count] = DWRITE_MAKE_OPENTYPE_TAG(tag[0], tag[1], tag[2], tag[3]); | |
| (*count)++; | |
| } | |
| } | |
| HRESULT opentype_get_typographic_features(IDWriteFontFace *fontface, UINT32 scripttag, UINT32 languagetag, UINT32 max_tagcount, | |
| UINT32 *count, DWRITE_FONT_FEATURE_TAG *tags) | |
| { | |
| UINT32 tables[2] = { MS_GSUB_TAG, MS_GPOS_TAG }; | |
| HRESULT hr; | |
| UINT8 i; | |
| *count = 0; | |
| for (i = 0; i < sizeof(tables)/sizeof(tables[0]); i++) { | |
| const OT_ScriptList *scriptlist; | |
| const GPOS_GSUB_Header *header; | |
| const OT_Script *script; | |
| const void *ptr; | |
| void *context; | |
| UINT32 size; | |
| BOOL exists; | |
| exists = FALSE; | |
| hr = IDWriteFontFace_TryGetFontTable(fontface, tables[i], &ptr, &size, &context, &exists); | |
| if (FAILED(hr)) | |
| return hr; | |
| if (!exists) | |
| continue; | |
| header = (const GPOS_GSUB_Header*)ptr; | |
| scriptlist = (const OT_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList)); | |
| script = opentype_get_script(scriptlist, scripttag); | |
| if (script) { | |
| const OT_LangSys *langsys = opentype_get_langsys(script, languagetag); | |
| if (langsys) | |
| opentype_add_font_features(header, langsys, max_tagcount, count, tags); | |
| } | |
| IDWriteFontFace_ReleaseFontTable(fontface, context); | |
| } | |
| return *count > max_tagcount ? E_NOT_SUFFICIENT_BUFFER : S_OK; | |
| } | |
| static const struct VDMX_group *find_vdmx_group(const struct VDMX_Header *hdr) | |
| { | |
| WORD num_ratios, i, group_offset = 0; | |
| struct VDMX_Ratio *ratios = (struct VDMX_Ratio*)(hdr + 1); | |
| BYTE dev_x_ratio = 1, dev_y_ratio = 1; | |
| num_ratios = GET_BE_WORD(hdr->numRatios); | |
| for (i = 0; i < num_ratios; i++) { | |
| if (!ratios[i].bCharSet) continue; | |
| if ((ratios[i].xRatio == 0 && ratios[i].yStartRatio == 0 && | |
| ratios[i].yEndRatio == 0) || | |
| (ratios[i].xRatio == dev_x_ratio && ratios[i].yStartRatio <= dev_y_ratio && | |
| ratios[i].yEndRatio >= dev_y_ratio)) | |
| { | |
| group_offset = GET_BE_WORD(*((WORD *)(ratios + num_ratios) + i)); | |
| break; | |
| } | |
| } | |
| if (group_offset) | |
| return (const struct VDMX_group *)((BYTE *)hdr + group_offset); | |
| return NULL; | |
| } | |
| BOOL opentype_get_vdmx_size(const void *data, INT emsize, UINT16 *ascent, UINT16 *descent) | |
| { | |
| const struct VDMX_Header *hdr = (const struct VDMX_Header*)data; | |
| const struct VDMX_group *group; | |
| const struct VDMX_vTable *tables; | |
| WORD recs, i; | |
| if (!data) | |
| return FALSE; | |
| group = find_vdmx_group(hdr); | |
| if (!group) | |
| return FALSE; | |
| recs = GET_BE_WORD(group->recs); | |
| if (emsize < group->startsz || emsize >= group->endsz) return FALSE; | |
| tables = (const struct VDMX_vTable *)(group + 1); | |
| for (i = 0; i < recs; i++) { | |
| WORD ppem = GET_BE_WORD(tables[i].yPelHeight); | |
| if (ppem > emsize) { | |
| FIXME("interpolate %d\n", emsize); | |
| return FALSE; | |
| } | |
| if (ppem == emsize) { | |
| *ascent = (SHORT)GET_BE_WORD(tables[i].yMax); | |
| *descent = -(SHORT)GET_BE_WORD(tables[i].yMin); | |
| return TRUE; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| WORD opentype_get_gasp_flags(const WORD *ptr, UINT32 size, INT emsize) | |
| { | |
| WORD num_recs, version; | |
| WORD flags = 0; | |
| if (!ptr) | |
| return 0; | |
| version = GET_BE_WORD( *ptr++ ); | |
| num_recs = GET_BE_WORD( *ptr++ ); | |
| if (version > 1 || size < (num_recs * 2 + 2) * sizeof(WORD)) { | |
| ERR("unsupported gasp table: ver %d size %d recs %d\n", version, size, num_recs); | |
| goto done; | |
| } | |
| while (num_recs--) { | |
| flags = GET_BE_WORD( *(ptr + 1) ); | |
| if (emsize <= GET_BE_WORD( *ptr )) break; | |
| ptr += 2; | |
| } | |
| done: | |
| return flags; | |
| } | |
| UINT32 opentype_get_cpal_palettecount(const void *cpal) | |
| { | |
| const struct CPAL_Header_0 *header = (const struct CPAL_Header_0*)cpal; | |
| return header ? GET_BE_WORD(header->numPalette) : 0; | |
| } | |
| UINT32 opentype_get_cpal_paletteentrycount(const void *cpal) | |
| { | |
| const struct CPAL_Header_0 *header = (const struct CPAL_Header_0*)cpal; | |
| return header ? GET_BE_WORD(header->numPaletteEntries) : 0; | |
| } | |
| HRESULT opentype_get_cpal_entries(const void *cpal, UINT32 palette, UINT32 first_entry_index, UINT32 entry_count, | |
| DWRITE_COLOR_F *entries) | |
| { | |
| const struct CPAL_Header_0 *header = (const struct CPAL_Header_0*)cpal; | |
| const struct CPAL_ColorRecord *records; | |
| UINT32 palettecount, entrycount, i; | |
| if (!header) return DWRITE_E_NOCOLOR; | |
| palettecount = GET_BE_WORD(header->numPalette); | |
| if (palette >= palettecount) | |
| return DWRITE_E_NOCOLOR; | |
| entrycount = GET_BE_WORD(header->numPaletteEntries); | |
| if (first_entry_index + entry_count > entrycount) | |
| return E_INVALIDARG; | |
| records = (const struct CPAL_ColorRecord*)((BYTE*)cpal + GET_BE_DWORD(header->offsetFirstColorRecord)); | |
| first_entry_index += GET_BE_WORD(header->colorRecordIndices[palette]); | |
| for (i = 0; i < entry_count; i++) { | |
| entries[i].u1.r = records[first_entry_index + i].red / 255.0f; | |
| entries[i].u2.g = records[first_entry_index + i].green / 255.0f; | |
| entries[i].u3.b = records[first_entry_index + i].blue / 255.0f; | |
| entries[i].u4.a = records[first_entry_index + i].alpha / 255.0f; | |
| } | |
| return S_OK; | |
| } | |
| static int colr_compare_gid(const void *g, const void *r) | |
| { | |
| const struct COLR_BaseGlyphRecord *record = r; | |
| UINT16 glyph = *(UINT16*)g, GID = GET_BE_WORD(record->GID); | |
| int ret = 0; | |
| if (glyph > GID) | |
| ret = 1; | |
| else if (glyph < GID) | |
| ret = -1; | |
| return ret; | |
| } | |
| HRESULT opentype_get_colr_glyph(const void *colr, UINT16 glyph, struct dwrite_colorglyph *ret) | |
| { | |
| const struct COLR_BaseGlyphRecord *record; | |
| const struct COLR_Header *header = colr; | |
| const struct COLR_LayerRecord *layer; | |
| DWORD layerrecordoffset = GET_BE_DWORD(header->offsetLayerRecord); | |
| DWORD baserecordoffset = GET_BE_DWORD(header->offsetBaseGlyphRecord); | |
| WORD numbaserecords = GET_BE_WORD(header->numBaseGlyphRecords); | |
| record = bsearch(&glyph, (BYTE*)colr + baserecordoffset, numbaserecords, sizeof(struct COLR_BaseGlyphRecord), | |
| colr_compare_gid); | |
| if (!record) { | |
| ret->layer = 0; | |
| ret->first_layer = 0; | |
| ret->num_layers = 0; | |
| ret->glyph = glyph; | |
| ret->palette_index = 0xffff; | |
| return S_FALSE; | |
| } | |
| ret->layer = 0; | |
| ret->first_layer = GET_BE_WORD(record->firstLayerIndex); | |
| ret->num_layers = GET_BE_WORD(record->numLayers); | |
| layer = (struct COLR_LayerRecord*)((BYTE*)colr + layerrecordoffset) + ret->first_layer + ret->layer; | |
| ret->glyph = GET_BE_WORD(layer->GID); | |
| ret->palette_index = GET_BE_WORD(layer->paletteIndex); | |
| return S_OK; | |
| } | |
| void opentype_colr_next_glyph(const void *colr, struct dwrite_colorglyph *glyph) | |
| { | |
| const struct COLR_Header *header = colr; | |
| const struct COLR_LayerRecord *layer; | |
| DWORD layerrecordoffset = GET_BE_DWORD(header->offsetLayerRecord); | |
| /* iterated all the way through */ | |
| if (glyph->layer == glyph->num_layers) | |
| return; | |
| glyph->layer++; | |
| layer = (struct COLR_LayerRecord*)((BYTE*)colr + layerrecordoffset) + glyph->first_layer + glyph->layer; | |
| glyph->glyph = GET_BE_WORD(layer->GID); | |
| glyph->palette_index = GET_BE_WORD(layer->paletteIndex); | |
| } | |
| BOOL opentype_has_vertical_variants(IDWriteFontFace4 *fontface) | |
| { | |
| const OT_FeatureList *featurelist; | |
| const OT_LookupList *lookup_list; | |
| BOOL exists = FALSE, ret = FALSE; | |
| const GPOS_GSUB_Header *header; | |
| const void *data; | |
| void *context; | |
| UINT32 size; | |
| HRESULT hr; | |
| UINT16 i; | |
| hr = IDWriteFontFace4_TryGetFontTable(fontface, MS_GSUB_TAG, &data, &size, &context, &exists); | |
| if (FAILED(hr) || !exists) | |
| return FALSE; | |
| header = data; | |
| featurelist = (OT_FeatureList*)((BYTE*)header + GET_BE_WORD(header->FeatureList)); | |
| lookup_list = (const OT_LookupList*)((BYTE*)header + GET_BE_WORD(header->LookupList)); | |
| for (i = 0; i < GET_BE_WORD(featurelist->FeatureCount); i++) { | |
| if (*(UINT32*)featurelist->FeatureRecord[i].FeatureTag == DWRITE_FONT_FEATURE_TAG_VERTICAL_WRITING) { | |
| const OT_Feature *feature = (const OT_Feature*)((BYTE*)featurelist + GET_BE_WORD(featurelist->FeatureRecord[i].Feature)); | |
| UINT16 lookup_count = GET_BE_WORD(feature->LookupCount), i, index, count, type; | |
| const GSUB_SingleSubstFormat2 *subst2; | |
| const OT_LookupTable *lookup_table; | |
| UINT32 offset; | |
| if (lookup_count == 0) | |
| continue; | |
| for (i = 0; i < lookup_count; i++) { | |
| /* check if lookup is empty */ | |
| index = GET_BE_WORD(feature->LookupListIndex[i]); | |
| lookup_table = (const OT_LookupTable*)((BYTE*)lookup_list + GET_BE_WORD(lookup_list->Lookup[index])); | |
| type = GET_BE_WORD(lookup_table->LookupType); | |
| if (type != OPENTYPE_GPOS_SINGLE_SUBST && type != OPENTYPE_GPOS_EXTENSION_SUBST) | |
| continue; | |
| count = GET_BE_WORD(lookup_table->SubTableCount); | |
| if (count == 0) | |
| continue; | |
| offset = GET_BE_WORD(lookup_table->SubTable[0]); | |
| if (type == OPENTYPE_GPOS_EXTENSION_SUBST) { | |
| const GSUB_ExtensionPosFormat1 *ext = (const GSUB_ExtensionPosFormat1 *)((const BYTE *)lookup_table + offset); | |
| if (GET_BE_WORD(ext->SubstFormat) == 1) | |
| offset += GET_BE_DWORD(ext->ExtensionOffset); | |
| else | |
| FIXME("Unhandled Extension Substitution Format %u\n", GET_BE_WORD(ext->SubstFormat)); | |
| } | |
| subst2 = (const GSUB_SingleSubstFormat2*)((BYTE*)lookup_table + offset); | |
| index = GET_BE_WORD(subst2->SubstFormat); | |
| if (index == 1) | |
| FIXME("Validate Single Substitution Format 1\n"); | |
| else if (index == 2) { | |
| /* SimSun-ExtB has 0 glyph count for this substitution */ | |
| if (GET_BE_WORD(subst2->GlyphCount) > 0) { | |
| ret = TRUE; | |
| break; | |
| } | |
| } | |
| else | |
| WARN("Unknown Single Substitution Format, %u\n", index); | |
| } | |
| } | |
| } | |
| IDWriteFontFace4_ReleaseFontTable(fontface, context); | |
| return ret; | |
| } | |
| static BOOL opentype_has_font_table(IDWriteFontFace4 *fontface, UINT32 tag) | |
| { | |
| BOOL exists = FALSE; | |
| const void *data; | |
| void *context; | |
| UINT32 size; | |
| HRESULT hr; | |
| hr = IDWriteFontFace4_TryGetFontTable(fontface, tag, &data, &size, &context, &exists); | |
| if (FAILED(hr)) | |
| return FALSE; | |
| if (exists) | |
| IDWriteFontFace4_ReleaseFontTable(fontface, context); | |
| return exists; | |
| } | |
| static DWORD opentype_get_sbix_formats(IDWriteFontFace4 *fontface) | |
| { | |
| UINT32 size, s, num_strikes; | |
| const sbix_header *header; | |
| UINT16 g, num_glyphs; | |
| BOOL exists = FALSE; | |
| const maxp *maxp; | |
| const void *data; | |
| DWORD ret = 0; | |
| void *context; | |
| HRESULT hr; | |
| hr = IDWriteFontFace4_TryGetFontTable(fontface, MS_MAXP_TAG, &data, &size, &context, &exists); | |
| if (FAILED(hr) || !exists) | |
| return 0; | |
| maxp = data; | |
| num_glyphs = GET_BE_WORD(maxp->numGlyphs); | |
| IDWriteFontFace4_ReleaseFontTable(fontface, context); | |
| if (FAILED(IDWriteFontFace4_TryGetFontTable(fontface, MS_SBIX_TAG, &data, &size, &context, &exists))) { | |
| WARN("Failed to get 'sbix' table, %#x\n", hr); | |
| return 0; | |
| } | |
| header = data; | |
| num_strikes = GET_BE_DWORD(header->numStrikes); | |
| for (s = 0; s < num_strikes; s++) { | |
| sbix_strike *strike = (sbix_strike *)((BYTE *)header + GET_BE_DWORD(header->strikeOffset[s])); | |
| for (g = 0; g < num_glyphs; g++) { | |
| DWORD offset = GET_BE_DWORD(strike->glyphDataOffsets[g]); | |
| DWORD offset_next = GET_BE_DWORD(strike->glyphDataOffsets[g + 1]); | |
| sbix_glyph_data *glyph_data; | |
| DWORD format; | |
| if (offset == offset_next) | |
| continue; | |
| glyph_data = (sbix_glyph_data *)((BYTE *)strike + offset); | |
| switch (format = glyph_data->graphicType) | |
| { | |
| case MS_PNG__TAG: | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_PNG; | |
| break; | |
| case MS_JPG__TAG: | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_JPEG; | |
| break; | |
| case MS_TIFF_TAG: | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_TIFF; | |
| break; | |
| default: | |
| format = GET_BE_DWORD(format); | |
| FIXME("unexpected bitmap format %s\n", debugstr_an((char *)&format, 4)); | |
| } | |
| } | |
| } | |
| IDWriteFontFace4_ReleaseFontTable(fontface, context); | |
| return ret; | |
| } | |
| static UINT32 opentype_get_cblc_formats(IDWriteFontFace4 *fontface) | |
| { | |
| CBLCBitmapSizeTable *sizes; | |
| UINT32 num_sizes, size, s; | |
| BOOL exists = FALSE; | |
| CBLCHeader *header; | |
| UINT32 ret = 0; | |
| void *context; | |
| HRESULT hr; | |
| if (FAILED(hr = IDWriteFontFace4_TryGetFontTable(fontface, MS_CBLC_TAG, (const void **)&header, &size, | |
| &context, &exists))) | |
| return 0; | |
| if (!exists) | |
| return 0; | |
| num_sizes = GET_BE_DWORD(header->numSizes); | |
| sizes = (CBLCBitmapSizeTable *)(header + 1); | |
| for (s = 0; s < num_sizes; s++) { | |
| BYTE bpp = sizes->bitDepth; | |
| if (bpp == 1 || bpp == 2 || bpp == 4 || bpp == 8) | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_PNG; | |
| else if (bpp == 32) | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8; | |
| } | |
| IDWriteFontFace4_ReleaseFontTable(fontface, context); | |
| return ret; | |
| } | |
| UINT32 opentype_get_glyph_image_formats(IDWriteFontFace4 *fontface) | |
| { | |
| UINT32 ret = DWRITE_GLYPH_IMAGE_FORMATS_NONE; | |
| if (opentype_has_font_table(fontface, MS_GLYF_TAG)) | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_TRUETYPE; | |
| if (opentype_has_font_table(fontface, MS_CFF__TAG) || | |
| opentype_has_font_table(fontface, MS_CFF2_TAG)) | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_CFF; | |
| if (opentype_has_font_table(fontface, MS_COLR_TAG)) | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_COLR; | |
| if (opentype_has_font_table(fontface, MS_SVG__TAG)) | |
| ret |= DWRITE_GLYPH_IMAGE_FORMATS_SVG; | |
| if (opentype_has_font_table(fontface, MS_SBIX_TAG)) | |
| ret |= opentype_get_sbix_formats(fontface); | |
| if (opentype_has_font_table(fontface, MS_CBLC_TAG)) | |
| ret |= opentype_get_cblc_formats(fontface); | |
| return ret; | |
| } | |
| DWRITE_CONTAINER_TYPE opentype_analyze_container_type(void const *data, UINT32 data_size) | |
| { | |
| DWORD signature; | |
| if (data_size < sizeof(DWORD)) | |
| return DWRITE_CONTAINER_TYPE_UNKNOWN; | |
| /* Both WOFF and WOFF2 start with 4 bytes signature. */ | |
| signature = *(DWORD *)data; | |
| switch (signature) | |
| { | |
| case MS_WOFF_TAG: | |
| return DWRITE_CONTAINER_TYPE_WOFF; | |
| case MS_WOF2_TAG: | |
| return DWRITE_CONTAINER_TYPE_WOFF2; | |
| default: | |
| return DWRITE_CONTAINER_TYPE_UNKNOWN; | |
| } | |
| } |