67cda371c11fff4dbb37e1376a8bbc60660b44b4
[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() { delete[] FeatureIndex; }
53
54    private:
55     TLangSys(const TLangSys&);
56     TLangSys& operator=(const TLangSys&);
57   };
58   struct TLangSysRecord {
59     TT_uint32_t LangSysTag;
60     struct TLangSys LangSys;
61     TLangSysRecord() : LangSysTag(0) {}
62
63    private:
64     TLangSysRecord(const TLangSysRecord&);
65     TLangSysRecord& operator=(const TLangSysRecord&);
66   };
67   struct TScript {
68     TT_uint16_t DefaultLangSys;
69     TT_uint16_t LangSysCount;
70     struct TLangSysRecord* LangSysRecord;
71     TScript() : DefaultLangSys(0), LangSysCount(0), LangSysRecord(NULL) {}
72     ~TScript() { delete[] LangSysRecord; }
73
74    private:
75     TScript(const TScript&);
76     TScript& operator=(const TScript&);
77   };
78   struct TScriptRecord {
79     TT_uint32_t ScriptTag;
80     struct TScript Script;
81     TScriptRecord() : ScriptTag(0) {}
82
83    private:
84     TScriptRecord(const TScriptRecord&);
85     TScriptRecord& operator=(const TScriptRecord&);
86   };
87   struct TScriptList {
88     TT_uint16_t ScriptCount;
89     struct TScriptRecord* ScriptRecord;
90     TScriptList() : ScriptCount(0), ScriptRecord(NULL) {}
91     ~TScriptList() { delete[] ScriptRecord; }
92
93    private:
94     TScriptList(const TScriptList&);
95     TScriptList& operator=(const TScriptList&);
96   };
97   struct TFeature {
98     TT_uint16_t FeatureParams;
99     int LookupCount;
100     TT_uint16_t* LookupListIndex;
101     TFeature() : FeatureParams(0), LookupCount(0), LookupListIndex(NULL) {}
102     ~TFeature() { delete[] LookupListIndex; }
103
104    private:
105     TFeature(const TFeature&);
106     TFeature& operator=(const TFeature&);
107   };
108   struct TFeatureRecord {
109     TT_uint32_t FeatureTag;
110     struct TFeature Feature;
111     TFeatureRecord() : FeatureTag(0) {}
112
113    private:
114     TFeatureRecord(const TFeatureRecord&);
115     TFeatureRecord& operator=(const TFeatureRecord&);
116   };
117   struct TFeatureList {
118     int FeatureCount;
119     struct TFeatureRecord* FeatureRecord;
120     TFeatureList() : FeatureCount(0), FeatureRecord(NULL) {}
121     ~TFeatureList() { delete[] FeatureRecord; }
122
123    private:
124     TFeatureList(const TFeatureList&);
125     TFeatureList& operator=(const TFeatureList&);
126   };
127   enum TLookupFlag {
128     LOOKUPFLAG_RightToLeft = 0x0001,
129     LOOKUPFLAG_IgnoreBaseGlyphs = 0x0002,
130     LOOKUPFLAG_IgnoreLigatures = 0x0004,
131     LOOKUPFLAG_IgnoreMarks = 0x0008,
132     LOOKUPFLAG_Reserved = 0x00F0,
133     LOOKUPFLAG_MarkAttachmentType = 0xFF00,
134   };
135   struct TCoverageFormatBase {
136     TT_uint16_t CoverageFormat;
137     CFX_GlyphMap m_glyphMap;
138     TCoverageFormatBase() : CoverageFormat(0) {}
139     virtual ~TCoverageFormatBase() {}
140
141    private:
142     TCoverageFormatBase(const TCoverageFormatBase&);
143     TCoverageFormatBase& operator=(const TCoverageFormatBase&);
144   };
145   struct TCoverageFormat1 : public TCoverageFormatBase {
146     TT_uint16_t GlyphCount;
147     TT_uint16_t* GlyphArray;
148     TCoverageFormat1() : GlyphCount(0), GlyphArray(NULL) { CoverageFormat = 1; }
149     ~TCoverageFormat1() override { delete[] GlyphArray; }
150
151    private:
152     TCoverageFormat1(const TCoverageFormat1&);
153     TCoverageFormat1& operator=(const TCoverageFormat1&);
154   };
155   struct TRangeRecord {
156     TT_uint16_t Start;
157     TT_uint16_t End;
158     TT_uint16_t StartCoverageIndex;
159     TRangeRecord() : Start(0), End(0), StartCoverageIndex(0) {}
160     friend bool operator>(const TRangeRecord& r1, const TRangeRecord& r2) {
161       return r1.Start > r2.Start;
162     }
163
164    private:
165     TRangeRecord(const TRangeRecord&);
166   };
167   struct TCoverageFormat2 : public TCoverageFormatBase {
168     TT_uint16_t RangeCount;
169     struct TRangeRecord* RangeRecord;
170     TCoverageFormat2() : RangeCount(0), RangeRecord(NULL) {
171       CoverageFormat = 2;
172     }
173     ~TCoverageFormat2() override { delete[] RangeRecord; }
174
175    private:
176     TCoverageFormat2(const TCoverageFormat2&);
177     TCoverageFormat2& operator=(const TCoverageFormat2&);
178   };
179   struct TClassDefFormatBase {
180     TT_uint16_t ClassFormat;
181     TClassDefFormatBase() : ClassFormat(0) {}
182     virtual ~TClassDefFormatBase() {}
183
184    private:
185     TClassDefFormatBase(const TClassDefFormatBase&);
186     TClassDefFormatBase& operator=(const TClassDefFormatBase&);
187   };
188   struct TClassDefFormat1 : public TClassDefFormatBase {
189     TT_uint16_t StartGlyph;
190     TT_uint16_t GlyphCount;
191     TT_uint16_t* ClassValueArray;
192     TClassDefFormat1() : StartGlyph(0), GlyphCount(0), ClassValueArray(NULL) {
193       ClassFormat = 1;
194     }
195     ~TClassDefFormat1() override { delete[] ClassValueArray; }
196
197    private:
198     TClassDefFormat1(const TClassDefFormat1&);
199     TClassDefFormat1& operator=(const TClassDefFormat1&);
200   };
201   struct TClassRangeRecord {
202     TT_uint16_t Start;
203     TT_uint16_t End;
204     TT_uint16_t Class;
205     TClassRangeRecord() : Start(0), End(0), Class(0) {}
206
207    private:
208     TClassRangeRecord(const TClassRangeRecord&);
209     TClassRangeRecord& operator=(const TClassRangeRecord&);
210   };
211   struct TClassDefFormat2 : public TClassDefFormatBase {
212     TT_uint16_t ClassRangeCount;
213     struct TClassRangeRecord* ClassRangeRecord;
214     TClassDefFormat2() : ClassRangeCount(0), ClassRangeRecord(NULL) {
215       ClassFormat = 2;
216     }
217     ~TClassDefFormat2() override { delete[] ClassRangeRecord; }
218
219    private:
220     TClassDefFormat2(const TClassDefFormat2&);
221     TClassDefFormat2& operator=(const TClassDefFormat2&);
222   };
223   struct TDevice {
224     TT_uint16_t StartSize;
225     TT_uint16_t EndSize;
226     TT_uint16_t DeltaFormat;
227     TDevice() : StartSize(0), EndSize(0), DeltaFormat(0) {}
228
229    private:
230     TDevice(const TDevice&);
231     TDevice& operator=(const TDevice&);
232   };
233   struct TSubTableBase {
234     TT_uint16_t SubstFormat;
235     TSubTableBase() : SubstFormat(0) {}
236     virtual ~TSubTableBase() {}
237
238    private:
239     TSubTableBase(const TSubTableBase&);
240     TSubTableBase& operator=(const TSubTableBase&);
241   };
242   struct TSingleSubstFormat1 : public TSubTableBase {
243     TCoverageFormatBase* Coverage;
244     TT_int16_t DeltaGlyphID;
245     TSingleSubstFormat1() : Coverage(NULL), DeltaGlyphID(0) { SubstFormat = 1; }
246     ~TSingleSubstFormat1() override { delete Coverage; }
247
248    private:
249     TSingleSubstFormat1(const TSingleSubstFormat1&);
250     TSingleSubstFormat1& operator=(const TSingleSubstFormat1&);
251   };
252   struct TSingleSubstFormat2 : public TSubTableBase {
253     TCoverageFormatBase* Coverage;
254     TT_uint16_t GlyphCount;
255     TT_uint16_t* Substitute;
256     TSingleSubstFormat2() : Coverage(NULL), GlyphCount(0), Substitute(NULL) {
257       SubstFormat = 2;
258     }
259     ~TSingleSubstFormat2() {
260       delete Coverage;
261       delete[] Substitute;
262     }
263
264    private:
265     TSingleSubstFormat2(const TSingleSubstFormat2&);
266     TSingleSubstFormat2& operator=(const TSingleSubstFormat2&);
267   };
268   struct TLookup {
269     TT_uint16_t LookupType;
270     TT_uint16_t LookupFlag;
271     TT_uint16_t SubTableCount;
272     struct TSubTableBase** SubTable;
273     TLookup()
274         : LookupType(0), LookupFlag(0), SubTableCount(0), SubTable(NULL) {}
275     ~TLookup() {
276       if (SubTableCount > 0 && SubTable != NULL) {
277         for (int i = 0; i < SubTableCount; i++) {
278           delete SubTable[i];
279         }
280         delete[] SubTable;
281       }
282     }
283
284    private:
285     TLookup(const TLookup&);
286     TLookup& operator=(const TLookup&);
287   };
288   struct TLookupList {
289     int LookupCount;
290     struct TLookup* Lookup;
291     TLookupList() : LookupCount(0), Lookup(NULL) {}
292     ~TLookupList() { delete[] Lookup; }
293
294    private:
295     TLookupList(const TLookupList&);
296     TLookupList& operator=(const TLookupList&);
297   };
298   bool Parse(FT_Bytes scriptlist, FT_Bytes featurelist, FT_Bytes lookuplist);
299   void ParseScriptList(FT_Bytes raw, TScriptList* rec);
300   void ParseScript(FT_Bytes raw, TScript* rec);
301   void ParseLangSys(FT_Bytes raw, TLangSys* rec);
302   void ParseFeatureList(FT_Bytes raw, TFeatureList* rec);
303   void ParseFeature(FT_Bytes raw, TFeature* rec);
304   void ParseLookupList(FT_Bytes raw, TLookupList* rec);
305   void ParseLookup(FT_Bytes raw, TLookup* rec);
306   void ParseCoverage(FT_Bytes raw, TCoverageFormatBase** rec);
307   void ParseCoverageFormat1(FT_Bytes raw, TCoverageFormat1* rec);
308   void ParseCoverageFormat2(FT_Bytes raw, TCoverageFormat2* rec);
309   void ParseSingleSubst(FT_Bytes raw, TSubTableBase** rec);
310   void ParseSingleSubstFormat1(FT_Bytes raw, TSingleSubstFormat1* rec);
311   void ParseSingleSubstFormat2(FT_Bytes raw, TSingleSubstFormat2* rec);
312   bool GetVerticalGlyphSub(TT_uint32_t glyphnum,
313                            TT_uint32_t* vglyphnum,
314                            struct TFeature* Feature);
315   bool GetVerticalGlyphSub2(TT_uint32_t glyphnum,
316                             TT_uint32_t* vglyphnum,
317                             struct TLookup* Lookup);
318   int GetCoverageIndex(struct TCoverageFormatBase* Coverage, TT_uint32_t g);
319   TT_uint8_t GetUInt8(FT_Bytes& p) const {
320     TT_uint8_t ret = p[0];
321     p += 1;
322     return ret;
323   }
324   TT_int16_t GetInt16(FT_Bytes& p) const {
325     TT_uint16_t ret = p[0] << 8 | p[1];
326     p += 2;
327     return *(TT_int16_t*)&ret;
328   }
329   TT_uint16_t GetUInt16(FT_Bytes& p) const {
330     TT_uint16_t ret = p[0] << 8 | p[1];
331     p += 2;
332     return ret;
333   }
334   TT_int32_t GetInt32(FT_Bytes& p) const {
335     TT_uint32_t ret = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
336     p += 4;
337     return *(TT_int32_t*)&ret;
338   }
339   TT_uint32_t GetUInt32(FT_Bytes& p) const {
340     TT_uint32_t ret = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
341     p += 4;
342     return ret;
343   }
344   CFX_CMapDWordToDWord m_featureMap;
345   FX_BOOL m_bFeautureMapLoad;
346   bool loaded;
347   struct tt_gsub_header header;
348   struct TScriptList ScriptList;
349   struct TFeatureList FeatureList;
350   struct TLookupList LookupList;
351 };
352 class CFX_GSUBTable final : public IFX_GSUBTable {
353  public:
354   ~CFX_GSUBTable() override {}
355   virtual FX_BOOL GetVerticalGlyph(FX_DWORD glyphnum,
356                                    FX_DWORD* vglyphnum) override;
357
358   CFX_CTTGSUBTable m_GsubImp;
359 };
360
361 #endif  // CORE_SRC_FPDFAPI_FPDF_FONT_TTGSUBTABLE_H_