a1717a9fd4df1e9a44f341bfb81a03423fcad4c9
[pdfium.git] / core / src / fpdfapi / fpdf_font / ttgsubtable.cpp
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 #include "../../../../third_party/base/nonstd_unique_ptr.h"
8 #include "../../../include/fxge/fx_ge.h"
9 #include "../../../include/fxge/fx_freetype.h"
10 #include "ttgsubtable.h"
11
12 CFX_GlyphMap::CFX_GlyphMap() {}
13 CFX_GlyphMap::~CFX_GlyphMap() {}
14 extern "C" {
15 static int _CompareInt(const void* p1, const void* p2) {
16   return (*(FX_DWORD*)p1) - (*(FX_DWORD*)p2);
17 }
18 };
19 struct _IntPair {
20   int32_t key;
21   int32_t value;
22 };
23 void CFX_GlyphMap::SetAt(int key, int value) {
24   FX_DWORD count = m_Buffer.GetSize() / sizeof(_IntPair);
25   _IntPair* buf = (_IntPair*)m_Buffer.GetBuffer();
26   _IntPair pair = {key, value};
27   if (count == 0 || key > buf[count - 1].key) {
28     m_Buffer.AppendBlock(&pair, sizeof(_IntPair));
29     return;
30   }
31   int low = 0, high = count - 1;
32   while (low <= high) {
33     int mid = (low + high) / 2;
34     if (buf[mid].key < key) {
35       low = mid + 1;
36     } else if (buf[mid].key > key) {
37       high = mid - 1;
38     } else {
39       buf[mid].value = value;
40       return;
41     }
42   }
43   m_Buffer.InsertBlock(low * sizeof(_IntPair), &pair, sizeof(_IntPair));
44 }
45 FX_BOOL CFX_GlyphMap::Lookup(int key, int& value) {
46   void* pResult = FXSYS_bsearch(&key, m_Buffer.GetBuffer(),
47                                 m_Buffer.GetSize() / sizeof(_IntPair),
48                                 sizeof(_IntPair), _CompareInt);
49   if (pResult == NULL) {
50     return FALSE;
51   }
52   value = ((FX_DWORD*)pResult)[1];
53   return TRUE;
54 }
55 bool CFX_CTTGSUBTable::LoadGSUBTable(FT_Bytes gsub) {
56   header.Version = gsub[0] << 24 | gsub[1] << 16 | gsub[2] << 8 | gsub[3];
57   if (header.Version != 0x00010000) {
58     return false;
59   }
60   header.ScriptList = gsub[4] << 8 | gsub[5];
61   header.FeatureList = gsub[6] << 8 | gsub[7];
62   header.LookupList = gsub[8] << 8 | gsub[9];
63   return Parse(&gsub[header.ScriptList], &gsub[header.FeatureList],
64                &gsub[header.LookupList]);
65 }
66 bool CFX_CTTGSUBTable::GetVerticalGlyph(TT_uint32_t glyphnum,
67                                         TT_uint32_t* vglyphnum) {
68   TT_uint32_t tag[] = {
69       (TT_uint8_t)'v' << 24 | (TT_uint8_t)'r' << 16 | (TT_uint8_t)'t' << 8 |
70           (TT_uint8_t)'2',
71       (TT_uint8_t)'v' << 24 | (TT_uint8_t)'e' << 16 | (TT_uint8_t)'r' << 8 |
72           (TT_uint8_t)'t',
73   };
74   if (!m_bFeautureMapLoad) {
75     for (int i = 0; i < ScriptList.ScriptCount; i++) {
76       for (int j = 0; j < (ScriptList.ScriptRecord + i)->Script.LangSysCount;
77            ++j) {
78         for (int k = 0;
79              k < ((ScriptList.ScriptRecord + i)->Script.LangSysRecord + j)
80                      ->LangSys.FeatureCount;
81              ++k) {
82           FX_DWORD index =
83               *(((ScriptList.ScriptRecord + i)->Script.LangSysRecord + j)
84                     ->LangSys.FeatureIndex +
85                 k);
86           if (FeatureList.FeatureRecord[index].FeatureTag == tag[0] ||
87               FeatureList.FeatureRecord[index].FeatureTag == tag[1]) {
88             FX_DWORD value;
89             if (!m_featureMap.Lookup(index, value)) {
90               m_featureMap.SetAt(index, index);
91             }
92           }
93         }
94       }
95     }
96     if (!m_featureMap.GetStartPosition()) {
97       for (int i = 0; i < FeatureList.FeatureCount; i++) {
98         if (FeatureList.FeatureRecord[i].FeatureTag == tag[0] ||
99             FeatureList.FeatureRecord[i].FeatureTag == tag[1]) {
100           FX_DWORD value;
101           if (!m_featureMap.Lookup(i, value)) {
102             m_featureMap.SetAt(i, i);
103           }
104         }
105       }
106     }
107     m_bFeautureMapLoad = TRUE;
108   }
109   FX_POSITION pos = m_featureMap.GetStartPosition();
110   while (pos) {
111     FX_DWORD index, value;
112     m_featureMap.GetNextAssoc(pos, index, value);
113     if (GetVerticalGlyphSub(glyphnum, vglyphnum,
114                             &FeatureList.FeatureRecord[value].Feature)) {
115       return true;
116     }
117   }
118   return false;
119 }
120 bool CFX_CTTGSUBTable::GetVerticalGlyphSub(TT_uint32_t glyphnum,
121                                            TT_uint32_t* vglyphnum,
122                                            struct TFeature* Feature) {
123   for (int i = 0; i < Feature->LookupCount; i++) {
124     int index = Feature->LookupListIndex[i];
125     if (index < 0 || LookupList.LookupCount < index) {
126       continue;
127     }
128     if (LookupList.Lookup[index].LookupType == 1) {
129       if (GetVerticalGlyphSub2(glyphnum, vglyphnum,
130                                &LookupList.Lookup[index])) {
131         return true;
132       }
133     }
134   }
135   return false;
136 }
137 bool CFX_CTTGSUBTable::GetVerticalGlyphSub2(TT_uint32_t glyphnum,
138                                             TT_uint32_t* vglyphnum,
139                                             struct TLookup* Lookup) {
140   for (int i = 0; i < Lookup->SubTableCount; i++) {
141     switch (Lookup->SubTable[i]->SubstFormat) {
142       case 1: {
143         TSingleSubstFormat1* tbl1 = (TSingleSubstFormat1*)Lookup->SubTable[i];
144         if (GetCoverageIndex(tbl1->Coverage, glyphnum) >= 0) {
145           *vglyphnum = glyphnum + tbl1->DeltaGlyphID;
146           return true;
147         }
148         break;
149       }
150       case 2: {
151         TSingleSubstFormat2* tbl2 = (TSingleSubstFormat2*)Lookup->SubTable[i];
152         int index = -1;
153         index = GetCoverageIndex(tbl2->Coverage, glyphnum);
154         if (0 <= index && index < tbl2->GlyphCount) {
155           *vglyphnum = tbl2->Substitute[index];
156           return true;
157         }
158         break;
159       }
160     }
161   }
162   return false;
163 }
164 int CFX_CTTGSUBTable::GetCoverageIndex(struct TCoverageFormatBase* Coverage,
165                                        TT_uint32_t g) {
166   int i = 0;
167   if (Coverage == NULL) {
168     return -1;
169   }
170   switch (Coverage->CoverageFormat) {
171     case 1: {
172       TCoverageFormat1* c1 = (TCoverageFormat1*)Coverage;
173       for (i = 0; i < c1->GlyphCount; i++) {
174         if ((TT_uint32_t)c1->GlyphArray[i] == g) {
175           return i;
176         }
177       }
178       return -1;
179     }
180     case 2: {
181       TCoverageFormat2* c2 = (TCoverageFormat2*)Coverage;
182       for (i = 0; i < c2->RangeCount; i++) {
183         TT_uint32_t s = c2->RangeRecord[i].Start;
184         TT_uint32_t e = c2->RangeRecord[i].End;
185         TT_uint32_t si = c2->RangeRecord[i].StartCoverageIndex;
186         if (s <= g && g <= e) {
187           return si + g - s;
188         }
189       }
190       return -1;
191     }
192   }
193   return -1;
194 }
195 bool CFX_CTTGSUBTable::Parse(FT_Bytes scriptlist,
196                              FT_Bytes featurelist,
197                              FT_Bytes lookuplist) {
198   ParseScriptList(scriptlist, &ScriptList);
199   ParseFeatureList(featurelist, &FeatureList);
200   ParseLookupList(lookuplist, &LookupList);
201   return true;
202 }
203 void CFX_CTTGSUBTable::ParseScriptList(FT_Bytes raw, struct TScriptList* rec) {
204   int i;
205   FT_Bytes sp = raw;
206   rec->ScriptCount = GetUInt16(sp);
207   if (rec->ScriptCount <= 0) {
208     return;
209   }
210   rec->ScriptRecord = new struct TScriptRecord[rec->ScriptCount];
211   for (i = 0; i < rec->ScriptCount; i++) {
212     rec->ScriptRecord[i].ScriptTag = GetUInt32(sp);
213     TT_uint16_t offset = GetUInt16(sp);
214     ParseScript(&raw[offset], &rec->ScriptRecord[i].Script);
215   }
216 }
217 void CFX_CTTGSUBTable::ParseScript(FT_Bytes raw, struct TScript* rec) {
218   int i;
219   FT_Bytes sp = raw;
220   rec->DefaultLangSys = GetUInt16(sp);
221   rec->LangSysCount = GetUInt16(sp);
222   if (rec->LangSysCount <= 0) {
223     return;
224   }
225   rec->LangSysRecord = new struct TLangSysRecord[rec->LangSysCount];
226   for (i = 0; i < rec->LangSysCount; i++) {
227     rec->LangSysRecord[i].LangSysTag = GetUInt32(sp);
228     TT_uint16_t offset = GetUInt16(sp);
229     ParseLangSys(&raw[offset], &rec->LangSysRecord[i].LangSys);
230   }
231 }
232 void CFX_CTTGSUBTable::ParseLangSys(FT_Bytes raw, struct TLangSys* rec) {
233   FT_Bytes sp = raw;
234   rec->LookupOrder = GetUInt16(sp);
235   rec->ReqFeatureIndex = GetUInt16(sp);
236   rec->FeatureCount = GetUInt16(sp);
237   if (rec->FeatureCount <= 0) {
238     return;
239   }
240   rec->FeatureIndex = new TT_uint16_t[rec->FeatureCount];
241   FXSYS_memset(rec->FeatureIndex, 0, sizeof(TT_uint16_t) * rec->FeatureCount);
242   for (int i = 0; i < rec->FeatureCount; ++i) {
243     rec->FeatureIndex[i] = GetUInt16(sp);
244   }
245 }
246 void CFX_CTTGSUBTable::ParseFeatureList(FT_Bytes raw, TFeatureList* rec) {
247   int i;
248   FT_Bytes sp = raw;
249   rec->FeatureCount = GetUInt16(sp);
250   if (rec->FeatureCount <= 0) {
251     return;
252   }
253   rec->FeatureRecord = new struct TFeatureRecord[rec->FeatureCount];
254   for (i = 0; i < rec->FeatureCount; i++) {
255     rec->FeatureRecord[i].FeatureTag = GetUInt32(sp);
256     TT_uint16_t offset = GetUInt16(sp);
257     ParseFeature(&raw[offset], &rec->FeatureRecord[i].Feature);
258   }
259 }
260 void CFX_CTTGSUBTable::ParseFeature(FT_Bytes raw, TFeature* rec) {
261   int i;
262   FT_Bytes sp = raw;
263   rec->FeatureParams = GetUInt16(sp);
264   rec->LookupCount = GetUInt16(sp);
265   if (rec->LookupCount <= 0) {
266     return;
267   }
268   rec->LookupListIndex = new TT_uint16_t[rec->LookupCount];
269   for (i = 0; i < rec->LookupCount; i++) {
270     rec->LookupListIndex[i] = GetUInt16(sp);
271   }
272 }
273 void CFX_CTTGSUBTable::ParseLookupList(FT_Bytes raw, TLookupList* rec) {
274   int i;
275   FT_Bytes sp = raw;
276   rec->LookupCount = GetUInt16(sp);
277   if (rec->LookupCount <= 0) {
278     return;
279   }
280   rec->Lookup = new struct TLookup[rec->LookupCount];
281   for (i = 0; i < rec->LookupCount; i++) {
282     TT_uint16_t offset = GetUInt16(sp);
283     ParseLookup(&raw[offset], &rec->Lookup[i]);
284   }
285 }
286 void CFX_CTTGSUBTable::ParseLookup(FT_Bytes raw, TLookup* rec) {
287   int i;
288   FT_Bytes sp = raw;
289   rec->LookupType = GetUInt16(sp);
290   rec->LookupFlag = GetUInt16(sp);
291   rec->SubTableCount = GetUInt16(sp);
292   if (rec->SubTableCount <= 0) {
293     return;
294   }
295   rec->SubTable = new struct TSubTableBase*[rec->SubTableCount];
296   for (i = 0; i < rec->SubTableCount; i++) {
297     rec->SubTable[i] = NULL;
298   }
299   if (rec->LookupType != 1) {
300     return;
301   }
302   for (i = 0; i < rec->SubTableCount; i++) {
303     TT_uint16_t offset = GetUInt16(sp);
304     ParseSingleSubst(&raw[offset], &rec->SubTable[i]);
305   }
306 }
307 void CFX_CTTGSUBTable::ParseCoverage(FT_Bytes raw, TCoverageFormatBase** rec) {
308   FT_Bytes sp = raw;
309   TT_uint16_t Format = GetUInt16(sp);
310   switch (Format) {
311     case 1:
312       *rec = new TCoverageFormat1();
313       ParseCoverageFormat1(raw, (TCoverageFormat1*)*rec);
314       break;
315     case 2:
316       *rec = new TCoverageFormat2();
317       ParseCoverageFormat2(raw, (TCoverageFormat2*)*rec);
318       break;
319   }
320 }
321 void CFX_CTTGSUBTable::ParseCoverageFormat1(FT_Bytes raw,
322                                             TCoverageFormat1* rec) {
323   int i;
324   FT_Bytes sp = raw;
325   GetUInt16(sp);
326   rec->GlyphCount = GetUInt16(sp);
327   if (rec->GlyphCount <= 0) {
328     return;
329   }
330   rec->GlyphArray = new TT_uint16_t[rec->GlyphCount];
331   for (i = 0; i < rec->GlyphCount; i++) {
332     rec->GlyphArray[i] = GetUInt16(sp);
333   }
334 }
335 void CFX_CTTGSUBTable::ParseCoverageFormat2(FT_Bytes raw,
336                                             TCoverageFormat2* rec) {
337   int i;
338   FT_Bytes sp = raw;
339   GetUInt16(sp);
340   rec->RangeCount = GetUInt16(sp);
341   if (rec->RangeCount <= 0) {
342     return;
343   }
344   rec->RangeRecord = new TRangeRecord[rec->RangeCount];
345   for (i = 0; i < rec->RangeCount; i++) {
346     rec->RangeRecord[i].Start = GetUInt16(sp);
347     rec->RangeRecord[i].End = GetUInt16(sp);
348     rec->RangeRecord[i].StartCoverageIndex = GetUInt16(sp);
349   }
350 }
351 void CFX_CTTGSUBTable::ParseSingleSubst(FT_Bytes raw, TSubTableBase** rec) {
352   FT_Bytes sp = raw;
353   TT_uint16_t Format = GetUInt16(sp);
354   switch (Format) {
355     case 1:
356       *rec = new TSingleSubstFormat1();
357       ParseSingleSubstFormat1(raw, (TSingleSubstFormat1*)*rec);
358       break;
359     case 2:
360       *rec = new TSingleSubstFormat2();
361       ParseSingleSubstFormat2(raw, (TSingleSubstFormat2*)*rec);
362       break;
363   }
364 }
365 void CFX_CTTGSUBTable::ParseSingleSubstFormat1(FT_Bytes raw,
366                                                TSingleSubstFormat1* rec) {
367   FT_Bytes sp = raw;
368   GetUInt16(sp);
369   TT_uint16_t offset = GetUInt16(sp);
370   ParseCoverage(&raw[offset], &rec->Coverage);
371   rec->DeltaGlyphID = GetInt16(sp);
372 }
373 void CFX_CTTGSUBTable::ParseSingleSubstFormat2(FT_Bytes raw,
374                                                TSingleSubstFormat2* rec) {
375   int i;
376   FT_Bytes sp = raw;
377   GetUInt16(sp);
378   TT_uint16_t offset = GetUInt16(sp);
379   ParseCoverage(&raw[offset], &rec->Coverage);
380   rec->GlyphCount = GetUInt16(sp);
381   if (rec->GlyphCount <= 0) {
382     return;
383   }
384   rec->Substitute = new TT_uint16_t[rec->GlyphCount];
385   for (i = 0; i < rec->GlyphCount; i++) {
386     rec->Substitute[i] = GetUInt16(sp);
387   }
388 }
389 FX_BOOL CFX_GSUBTable::GetVerticalGlyph(FX_DWORD glyphnum,
390                                         FX_DWORD* vglyphnum) {
391   return m_GsubImp.GetVerticalGlyph(glyphnum, vglyphnum);
392 }
393 // static
394 IFX_GSUBTable* IFX_GSUBTable::Create(CFX_Font* pFont) {
395   if (!pFont) {
396     return NULL;
397   }
398   if (NULL == pFont->m_pGsubData) {
399     unsigned long length = 0;
400     int error = FXFT_Load_Sfnt_Table(
401         pFont->m_Face, FT_MAKE_TAG('G', 'S', 'U', 'B'), 0, NULL, &length);
402     if (!error) {
403       pFont->m_pGsubData = (unsigned char*)FX_Alloc(uint8_t, length);
404     }
405     if (!pFont->m_pGsubData) {
406       return NULL;
407     }
408   }
409   int error =
410       FXFT_Load_Sfnt_Table(pFont->m_Face, FT_MAKE_TAG('G', 'S', 'U', 'B'), 0,
411                            pFont->m_pGsubData, NULL);
412   if (!error && pFont->m_pGsubData) {
413     nonstd::unique_ptr<CFX_GSUBTable> pGsubTable(new CFX_GSUBTable);
414     if (pGsubTable->m_GsubImp.LoadGSUBTable((FT_Bytes)pFont->m_pGsubData)) {
415       return pGsubTable.release();
416     }
417   }
418   return NULL;
419 }