b717c7af8b492359f445c0ce00b70dcea305dcb3
[pdfium.git] / core / src / fpdfapi / fpdf_font / ttgsubtable.h
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #ifndef CORE_SRC_FPDFAPI_FPDF_FONT_TTGSUBTABLE_H_
8 #define CORE_SRC_FPDFAPI_FPDF_FONT_TTGSUBTABLE_H_
9
10 #include "../../../include/fxge/fx_freetype.h"
11 #include "../../../include/fxcrt/fx_basic.h"
12 #include "common.h"
13
14 class CFX_GlyphMap {
15  public:
16   CFX_GlyphMap();
17   ~CFX_GlyphMap();
18   void SetAt(int key, int value);
19   FX_BOOL Lookup(int key, int& value);
20
21  protected:
22   CFX_BinaryBuf m_Buffer;
23 };
24 class CFX_CTTGSUBTable {
25  public:
26   CFX_CTTGSUBTable(void) : m_bFeautureMapLoad(FALSE), loaded(false){};
27   CFX_CTTGSUBTable(FT_Bytes gsub) : m_bFeautureMapLoad(FALSE), loaded(false) {
28     LoadGSUBTable(gsub);
29   }
30   virtual ~CFX_CTTGSUBTable() {}
31   bool IsOk(void) const { return loaded; }
32   bool LoadGSUBTable(FT_Bytes gsub);
33   bool GetVerticalGlyph(TT_uint32_t glyphnum, TT_uint32_t* vglyphnum);
34
35  private:
36   struct tt_gsub_header {
37     TT_uint32_t Version;
38     TT_uint16_t ScriptList;
39     TT_uint16_t FeatureList;
40     TT_uint16_t LookupList;
41   };
42   struct TLangSys {
43     TT_uint16_t LookupOrder;
44     TT_uint16_t ReqFeatureIndex;
45     TT_uint16_t FeatureCount;
46     TT_uint16_t* FeatureIndex;
47     TLangSys()
48         : LookupOrder(0),
49           ReqFeatureIndex(0),
50           FeatureCount(0),
51           FeatureIndex(NULL) {}
52     ~TLangSys() {
53       if (FeatureIndex) {
54         delete[] FeatureIndex;
55       }
56     }
57
58    private:
59     TLangSys(const TLangSys&);
60     TLangSys& operator=(const TLangSys&);
61   };
62   struct TLangSysRecord {
63     TT_uint32_t LangSysTag;
64     struct TLangSys LangSys;
65     TLangSysRecord() : LangSysTag(0) {}
66
67    private:
68     TLangSysRecord(const TLangSysRecord&);
69     TLangSysRecord& operator=(const TLangSysRecord&);
70   };
71   struct TScript {
72     TT_uint16_t DefaultLangSys;
73     TT_uint16_t LangSysCount;
74     struct TLangSysRecord* LangSysRecord;
75     TScript() : DefaultLangSys(0), LangSysCount(0), LangSysRecord(NULL) {}
76     ~TScript() {
77       if (LangSysRecord) {
78         delete[] LangSysRecord;
79       }
80     }
81
82    private:
83     TScript(const TScript&);
84     TScript& operator=(const TScript&);
85   };
86   struct TScriptRecord {
87     TT_uint32_t ScriptTag;
88     struct TScript Script;
89     TScriptRecord() : ScriptTag(0) {}
90
91    private:
92     TScriptRecord(const TScriptRecord&);
93     TScriptRecord& operator=(const TScriptRecord&);
94   };
95   struct TScriptList {
96     TT_uint16_t ScriptCount;
97     struct TScriptRecord* ScriptRecord;
98     TScriptList() : ScriptCount(0), ScriptRecord(NULL) {}
99     ~TScriptList() {
100       if (ScriptRecord) {
101         delete[] ScriptRecord;
102       }
103     }
104
105    private:
106     TScriptList(const TScriptList&);
107     TScriptList& operator=(const TScriptList&);
108   };
109   struct TFeature {
110     TT_uint16_t FeatureParams;
111     int LookupCount;
112     TT_uint16_t* LookupListIndex;
113     TFeature() : FeatureParams(0), LookupCount(0), LookupListIndex(NULL) {}
114     ~TFeature() {
115       if (LookupListIndex) {
116         delete[] LookupListIndex;
117       }
118     }
119
120    private:
121     TFeature(const TFeature&);
122     TFeature& operator=(const TFeature&);
123   };
124   struct TFeatureRecord {
125     TT_uint32_t FeatureTag;
126     struct TFeature Feature;
127     TFeatureRecord() : FeatureTag(0) {}
128
129    private:
130     TFeatureRecord(const TFeatureRecord&);
131     TFeatureRecord& operator=(const TFeatureRecord&);
132   };
133   struct TFeatureList {
134     int FeatureCount;
135     struct TFeatureRecord* FeatureRecord;
136     TFeatureList() : FeatureCount(0), FeatureRecord(NULL) {}
137     ~TFeatureList() {
138       if (FeatureRecord) {
139         delete[] FeatureRecord;
140       }
141     }
142
143    private:
144     TFeatureList(const TFeatureList&);
145     TFeatureList& operator=(const TFeatureList&);
146   };
147   enum TLookupFlag {
148     LOOKUPFLAG_RightToLeft = 0x0001,
149     LOOKUPFLAG_IgnoreBaseGlyphs = 0x0002,
150     LOOKUPFLAG_IgnoreLigatures = 0x0004,
151     LOOKUPFLAG_IgnoreMarks = 0x0008,
152     LOOKUPFLAG_Reserved = 0x00F0,
153     LOOKUPFLAG_MarkAttachmentType = 0xFF00,
154   };
155   struct TCoverageFormatBase {
156     TT_uint16_t CoverageFormat;
157     CFX_GlyphMap m_glyphMap;
158     TCoverageFormatBase() : CoverageFormat(0) {}
159     virtual ~TCoverageFormatBase() {}
160
161    private:
162     TCoverageFormatBase(const TCoverageFormatBase&);
163     TCoverageFormatBase& operator=(const TCoverageFormatBase&);
164   };
165   struct TCoverageFormat1 : public TCoverageFormatBase {
166     TT_uint16_t GlyphCount;
167     TT_uint16_t* GlyphArray;
168     TCoverageFormat1() : GlyphCount(0), GlyphArray(NULL) { CoverageFormat = 1; }
169     ~TCoverageFormat1() {
170       if (GlyphArray) {
171         delete[] GlyphArray;
172       }
173     }
174
175    private:
176     TCoverageFormat1(const TCoverageFormat1&);
177     TCoverageFormat1& operator=(const TCoverageFormat1&);
178   };
179   struct TRangeRecord {
180     TT_uint16_t Start;
181     TT_uint16_t End;
182     TT_uint16_t StartCoverageIndex;
183     TRangeRecord() : Start(0), End(0), StartCoverageIndex(0) {}
184     friend bool operator>(const TRangeRecord& r1, const TRangeRecord& r2) {
185       return r1.Start > r2.Start;
186     }
187
188    private:
189     TRangeRecord(const TRangeRecord&);
190   };
191   struct TCoverageFormat2 : public TCoverageFormatBase {
192     TT_uint16_t RangeCount;
193     struct TRangeRecord* RangeRecord;
194     TCoverageFormat2() : RangeCount(0), RangeRecord(NULL) {
195       CoverageFormat = 2;
196     }
197     ~TCoverageFormat2() {
198       if (RangeRecord) {
199         delete[] RangeRecord;
200       }
201     }
202
203    private:
204     TCoverageFormat2(const TCoverageFormat2&);
205     TCoverageFormat2& operator=(const TCoverageFormat2&);
206   };
207   struct TClassDefFormatBase {
208     TT_uint16_t ClassFormat;
209     TClassDefFormatBase() : ClassFormat(0) {}
210     virtual ~TClassDefFormatBase() {}
211
212    private:
213     TClassDefFormatBase(const TClassDefFormatBase&);
214     TClassDefFormatBase& operator=(const TClassDefFormatBase&);
215   };
216   struct TClassDefFormat1 : public TClassDefFormatBase {
217     TT_uint16_t StartGlyph;
218     TT_uint16_t GlyphCount;
219     TT_uint16_t* ClassValueArray;
220     TClassDefFormat1() : StartGlyph(0), GlyphCount(0), ClassValueArray(NULL) {
221       ClassFormat = 1;
222     }
223     ~TClassDefFormat1() {
224       if (ClassValueArray) {
225         delete[] ClassValueArray;
226       }
227     }
228
229    private:
230     TClassDefFormat1(const TClassDefFormat1&);
231     TClassDefFormat1& operator=(const TClassDefFormat1&);
232   };
233   struct TClassRangeRecord {
234     TT_uint16_t Start;
235     TT_uint16_t End;
236     TT_uint16_t Class;
237     TClassRangeRecord() : Start(0), End(0), Class(0) {}
238
239    private:
240     TClassRangeRecord(const TClassRangeRecord&);
241     TClassRangeRecord& operator=(const TClassRangeRecord&);
242   };
243   struct TClassDefFormat2 : public TClassDefFormatBase {
244     TT_uint16_t ClassRangeCount;
245     struct TClassRangeRecord* ClassRangeRecord;
246     TClassDefFormat2() : ClassRangeCount(0), ClassRangeRecord(NULL) {
247       ClassFormat = 2;
248     }
249     ~TClassDefFormat2() {
250       if (ClassRangeRecord) {
251         delete[] ClassRangeRecord;
252       }
253     }
254
255    private:
256     TClassDefFormat2(const TClassDefFormat2&);
257     TClassDefFormat2& operator=(const TClassDefFormat2&);
258   };
259   struct TDevice {
260     TT_uint16_t StartSize;
261     TT_uint16_t EndSize;
262     TT_uint16_t DeltaFormat;
263     TDevice() : StartSize(0), EndSize(0), DeltaFormat(0) {}
264
265    private:
266     TDevice(const TDevice&);
267     TDevice& operator=(const TDevice&);
268   };
269   struct TSubTableBase {
270     TT_uint16_t SubstFormat;
271     TSubTableBase() : SubstFormat(0) {}
272     virtual ~TSubTableBase() {}
273
274    private:
275     TSubTableBase(const TSubTableBase&);
276     TSubTableBase& operator=(const TSubTableBase&);
277   };
278   struct TSingleSubstFormat1 : public TSubTableBase {
279     TCoverageFormatBase* Coverage;
280     TT_int16_t DeltaGlyphID;
281     TSingleSubstFormat1() : Coverage(NULL), DeltaGlyphID(0) { SubstFormat = 1; }
282     ~TSingleSubstFormat1() { delete Coverage; }
283
284    private:
285     TSingleSubstFormat1(const TSingleSubstFormat1&);
286     TSingleSubstFormat1& operator=(const TSingleSubstFormat1&);
287   };
288   struct TSingleSubstFormat2 : public TSubTableBase {
289     TCoverageFormatBase* Coverage;
290     TT_uint16_t GlyphCount;
291     TT_uint16_t* Substitute;
292     TSingleSubstFormat2() : Coverage(NULL), GlyphCount(0), Substitute(NULL) {
293       SubstFormat = 2;
294     }
295     ~TSingleSubstFormat2() {
296       delete Coverage;
297       delete[] Substitute;
298     }
299
300    private:
301     TSingleSubstFormat2(const TSingleSubstFormat2&);
302     TSingleSubstFormat2& operator=(const TSingleSubstFormat2&);
303   };
304   struct TLookup {
305     TT_uint16_t LookupType;
306     TT_uint16_t LookupFlag;
307     TT_uint16_t SubTableCount;
308     struct TSubTableBase** SubTable;
309     TLookup()
310         : LookupType(0), LookupFlag(0), SubTableCount(0), SubTable(NULL) {}
311     ~TLookup() {
312       if (SubTableCount > 0 && SubTable != NULL) {
313         for (int i = 0; i < SubTableCount; i++) {
314           delete SubTable[i];
315         }
316         delete[] SubTable;
317       }
318     }
319
320    private:
321     TLookup(const TLookup&);
322     TLookup& operator=(const TLookup&);
323   };
324   struct TLookupList {
325     int LookupCount;
326     struct TLookup* Lookup;
327     TLookupList() : LookupCount(0), Lookup(NULL) {}
328     ~TLookupList() {
329       if (Lookup) {
330         delete[] Lookup;
331       }
332     }
333
334    private:
335     TLookupList(const TLookupList&);
336     TLookupList& operator=(const TLookupList&);
337   };
338   bool Parse(FT_Bytes scriptlist, FT_Bytes featurelist, FT_Bytes lookuplist);
339   void ParseScriptList(FT_Bytes raw, TScriptList* rec);
340   void ParseScript(FT_Bytes raw, TScript* rec);
341   void ParseLangSys(FT_Bytes raw, TLangSys* rec);
342   void ParseFeatureList(FT_Bytes raw, TFeatureList* rec);
343   void ParseFeature(FT_Bytes raw, TFeature* rec);
344   void ParseLookupList(FT_Bytes raw, TLookupList* rec);
345   void ParseLookup(FT_Bytes raw, TLookup* rec);
346   void ParseCoverage(FT_Bytes raw, TCoverageFormatBase** rec);
347   void ParseCoverageFormat1(FT_Bytes raw, TCoverageFormat1* rec);
348   void ParseCoverageFormat2(FT_Bytes raw, TCoverageFormat2* rec);
349   void ParseSingleSubst(FT_Bytes raw, TSubTableBase** rec);
350   void ParseSingleSubstFormat1(FT_Bytes raw, TSingleSubstFormat1* rec);
351   void ParseSingleSubstFormat2(FT_Bytes raw, TSingleSubstFormat2* rec);
352   bool GetVerticalGlyphSub(TT_uint32_t glyphnum,
353                            TT_uint32_t* vglyphnum,
354                            struct TFeature* Feature);
355   bool GetVerticalGlyphSub2(TT_uint32_t glyphnum,
356                             TT_uint32_t* vglyphnum,
357                             struct TLookup* Lookup);
358   int GetCoverageIndex(struct TCoverageFormatBase* Coverage, TT_uint32_t g);
359   TT_uint8_t GetUInt8(FT_Bytes& p) const {
360     TT_uint8_t ret = p[0];
361     p += 1;
362     return ret;
363   }
364   TT_int16_t GetInt16(FT_Bytes& p) const {
365     TT_uint16_t ret = p[0] << 8 | p[1];
366     p += 2;
367     return *(TT_int16_t*)&ret;
368   }
369   TT_uint16_t GetUInt16(FT_Bytes& p) const {
370     TT_uint16_t ret = p[0] << 8 | p[1];
371     p += 2;
372     return ret;
373   }
374   TT_int32_t GetInt32(FT_Bytes& p) const {
375     TT_uint32_t ret = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
376     p += 4;
377     return *(TT_int32_t*)&ret;
378   }
379   TT_uint32_t GetUInt32(FT_Bytes& p) const {
380     TT_uint32_t ret = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
381     p += 4;
382     return ret;
383   }
384   CFX_CMapDWordToDWord m_featureMap;
385   FX_BOOL m_bFeautureMapLoad;
386   bool loaded;
387   struct tt_gsub_header header;
388   struct TScriptList ScriptList;
389   struct TFeatureList FeatureList;
390   struct TLookupList LookupList;
391 };
392 class CFX_GSUBTable final : public IFX_GSUBTable {
393  public:
394   ~CFX_GSUBTable() override {}
395   virtual FX_BOOL GetVerticalGlyph(FX_DWORD glyphnum,
396                                    FX_DWORD* vglyphnum) override;
397
398   CFX_CTTGSUBTable m_GsubImp;
399 };
400
401 #endif  // CORE_SRC_FPDFAPI_FPDF_FONT_TTGSUBTABLE_H_