dlls/usp10/opentype.c

   1 /*
   2  * Opentype font interfaces for the Uniscribe Script Processor (usp10.dll)
   3  *
   4  * Copyright 2012 CodeWeavers, Aric Stewart
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21 #include <stdarg.h>
  22 #include <stdlib.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "winnls.h"
  29 #include "usp10.h"
  30 #include "winternl.h"
  31
  32 #include "usp10_internal.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
  37
  38 #ifdef WORDS_BIGENDIAN
  39 #define GET_BE_WORD(x) (x)
  40 #define GET_BE_DWORD(x) (x)
  41 #else
  42 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
  43 #define GET_BE_DWORD(x) RtlUlongByteSwap(x)
  44 #endif
  45
  46 /* These are all structures needed for the cmap format 12 table */
  47 #define CMAP_TAG MS_MAKE_TAG('c', 'm', 'a', 'p')
  48
  49 typedef struct {
  50     WORD platformID;
  51     WORD encodingID;
  52     DWORD offset;
  53 } CMAP_EncodingRecord;
  54
  55 typedef struct {
  56     WORD version;
  57     WORD numTables;
  58     CMAP_EncodingRecord tables[1];
  59 } CMAP_Header;
  60
  61 typedef struct {
  62     DWORD startCharCode;
  63     DWORD endCharCode;
  64     DWORD startGlyphID;
  65 } CMAP_SegmentedCoverage_group;
  66
  67 typedef struct {
  68     WORD format;
  69     WORD reserved;
  70     DWORD length;
  71     DWORD language;
  72     DWORD nGroups;
  73     CMAP_SegmentedCoverage_group groups[1];
  74 } CMAP_SegmentedCoverage;
  75
  76 /* These are all structures needed for the GDEF table */
  77 #define GDEF_TAG MS_MAKE_TAG('G', 'D', 'E', 'F')
  78
  79 enum {BaseGlyph=1, LigatureGlyph, MarkGlyph, ComponentGlyph};
  80
  81 typedef struct {
  82     DWORD Version;
  83     WORD GlyphClassDef;
  84     WORD AttachList;
  85     WORD LigCaretList;
  86     WORD MarkAttachClassDef;
  87 } GDEF_Header;
  88
  89 typedef struct {
  90     WORD ClassFormat;
  91     WORD StartGlyph;
  92     WORD GlyphCount;
  93     WORD ClassValueArray[1];
  94 } GDEF_ClassDefFormat1;
  95
  96 typedef struct {
  97     WORD Start;
  98     WORD End;
  99     WORD Class;
 100 } GDEF_ClassRangeRecord;
 101
 102 typedef struct {
 103     WORD ClassFormat;
 104     WORD ClassRangeCount;
 105     GDEF_ClassRangeRecord ClassRangeRecord[1];
 106 } GDEF_ClassDefFormat2;
 107
 108 /* These are all structures needed for the GSUB table */
 109
 110 typedef struct {
 111     DWORD version;
 112     WORD ScriptList;
 113     WORD FeatureList;
 114     WORD LookupList;
 115 } GSUB_Header;
 116
 117 typedef struct {
 118     CHAR ScriptTag[4];
 119     WORD Script;
 120 } OT_ScriptRecord;
 121
 122 typedef struct {
 123     WORD ScriptCount;
 124     OT_ScriptRecord ScriptRecord[1];
 125 } OT_ScriptList;
 126
 127 typedef struct {
 128     CHAR LangSysTag[4];
 129     WORD LangSys;
 130 } OT_LangSysRecord;
 131
 132 typedef struct {
 133     WORD DefaultLangSys;
 134     WORD LangSysCount;
 135     OT_LangSysRecord LangSysRecord[1];
 136 } OT_Script;
 137
 138 typedef struct {
 139     WORD LookupOrder; /* Reserved */
 140     WORD ReqFeatureIndex;
 141     WORD FeatureCount;
 142     WORD FeatureIndex[1];
 143 } OT_LangSys;
 144
 145 typedef struct {
 146     CHAR FeatureTag[4];
 147     WORD Feature;
 148 } OT_FeatureRecord;
 149
 150 typedef struct {
 151     WORD FeatureCount;
 152     OT_FeatureRecord FeatureRecord[1];
 153 } OT_FeatureList;
 154
 155 typedef struct {
 156     WORD FeatureParams; /* Reserved */
 157     WORD LookupCount;
 158     WORD LookupListIndex[1];
 159 } OT_Feature;
 160
 161 typedef struct {
 162     WORD LookupCount;
 163     WORD Lookup[1];
 164 } OT_LookupList;
 165
 166 typedef struct {
 167     WORD LookupType;
 168     WORD LookupFlag;
 169     WORD SubTableCount;
 170     WORD SubTable[1];
 171 } OT_LookupTable;
 172
 173 typedef struct {
 174     WORD CoverageFormat;
 175     WORD GlyphCount;
 176     WORD GlyphArray[1];
 177 } OT_CoverageFormat1;
 178
 179 typedef struct {
 180     WORD Start;
 181     WORD End;
 182     WORD StartCoverageIndex;
 183 } OT_RangeRecord;
 184
 185 typedef struct {
 186     WORD CoverageFormat;
 187     WORD RangeCount;
 188     OT_RangeRecord RangeRecord[1];
 189 } OT_CoverageFormat2;
 190
 191 typedef struct {
 192     WORD SubstFormat; /* = 1 */
 193     WORD Coverage;
 194     WORD DeltaGlyphID;
 195 } GSUB_SingleSubstFormat1;
 196
 197 typedef struct {
 198     WORD SubstFormat; /* = 2 */
 199     WORD Coverage;
 200     WORD GlyphCount;
 201     WORD Substitute[1];
 202 }GSUB_SingleSubstFormat2;
 203
 204 typedef struct {
 205     WORD SubstFormat; /* = 1 */
 206     WORD Coverage;
 207     WORD SequenceCount;
 208     WORD Sequence[1];
 209 }GSUB_MultipleSubstFormat1;
 210
 211 typedef struct {
 212     WORD GlyphCount;
 213     WORD Substitute[1];
 214 }GSUB_Sequence;
 215
 216 typedef struct {
 217     WORD SubstFormat; /* = 1 */
 218     WORD Coverage;
 219     WORD LigSetCount;
 220     WORD LigatureSet[1];
 221 }GSUB_LigatureSubstFormat1;
 222
 223 typedef struct {
 224     WORD LigatureCount;
 225     WORD Ligature[1];
 226 }GSUB_LigatureSet;
 227
 228 typedef struct{
 229     WORD LigGlyph;
 230     WORD CompCount;
 231     WORD Component[1];
 232 }GSUB_Ligature;
 233
 234 typedef struct{
 235     WORD SequenceIndex;
 236     WORD LookupListIndex;
 237
 238 }GSUB_SubstLookupRecord;
 239
 240 typedef struct{
 241     WORD SubstFormat; /* = 1 */
 242     WORD Coverage;
 243     WORD ChainSubRuleSetCount;
 244     WORD ChainSubRuleSet[1];
 245 }GSUB_ChainContextSubstFormat1;
 246
 247 typedef struct {
 248     WORD SubstFormat; /* = 3 */
 249     WORD BacktrackGlyphCount;
 250     WORD Coverage[1];
 251 }GSUB_ChainContextSubstFormat3_1;
 252
 253 typedef struct{
 254     WORD InputGlyphCount;
 255     WORD Coverage[1];
 256 }GSUB_ChainContextSubstFormat3_2;
 257
 258 typedef struct{
 259     WORD LookaheadGlyphCount;
 260     WORD Coverage[1];
 261 }GSUB_ChainContextSubstFormat3_3;
 262
 263 typedef struct{
 264     WORD SubstCount;
 265     GSUB_SubstLookupRecord SubstLookupRecord[1];
 266 }GSUB_ChainContextSubstFormat3_4;
 267
 268 typedef struct {
 269     WORD SubstFormat; /* = 1 */
 270     WORD Coverage;
 271     WORD AlternateSetCount;
 272     WORD AlternateSet[1];
 273 } GSUB_AlternateSubstFormat1;
 274
 275 typedef struct{
 276     WORD GlyphCount;
 277     WORD Alternate[1];
 278 } GSUB_AlternateSet;
 279
 280 /* These are all structures needed for the GPOS table */
 281
 282 typedef struct {
 283     DWORD version;
 284     WORD ScriptList;
 285     WORD FeatureList;
 286     WORD LookupList;
 287 } GPOS_Header;
 288
 289 typedef struct {
 290     WORD StartSize;
 291     WORD EndSize;
 292     WORD DeltaFormat;
 293     WORD DeltaValue[1];
 294 } OT_DeviceTable;
 295
 296 typedef struct {
 297     WORD AnchorFormat;
 298     WORD XCoordinate;
 299     WORD YCoordinate;
 300 } GPOS_AnchorFormat1;
 301
 302 typedef struct {
 303     WORD AnchorFormat;
 304     WORD XCoordinate;
 305     WORD YCoordinate;
 306     WORD AnchorPoint;
 307 } GPOS_AnchorFormat2;
 308
 309 typedef struct {
 310     WORD AnchorFormat;
 311     WORD XCoordinate;
 312     WORD YCoordinate;
 313     WORD XDeviceTable;
 314     WORD YDeviceTable;
 315 } GPOS_AnchorFormat3;
 316
 317 /**********
 318  * CMAP
 319  **********/
 320
 321 static VOID *load_CMAP_format12_table(HDC hdc, ScriptCache *psc)
 322 {
 323     CMAP_Header *CMAP_Table = NULL;
 324     int length;
 325     int i;
 326
 327     if (!psc->CMAP_Table)
 328     {
 329         length = GetFontData(hdc, CMAP_TAG , 0, NULL, 0);
 330         if (length != GDI_ERROR)
 331         {
 332             psc->CMAP_Table = HeapAlloc(GetProcessHeap(),0,length);
 333             GetFontData(hdc, CMAP_TAG , 0, psc->CMAP_Table, length);
 334             TRACE("Loaded cmap table of %i bytes\n",length);
 335         }
 336         else
 337             return NULL;
 338     }
 339
 340     CMAP_Table = psc->CMAP_Table;
 341
 342     for (i = 0; i < GET_BE_WORD(CMAP_Table->numTables); i++)
 343     {
 344         if ( (GET_BE_WORD(CMAP_Table->tables[i].platformID) == 3) &&
 345              (GET_BE_WORD(CMAP_Table->tables[i].encodingID) == 10) )
 346         {
 347             CMAP_SegmentedCoverage *format = (CMAP_SegmentedCoverage*)(((BYTE*)CMAP_Table) + GET_BE_DWORD(CMAP_Table->tables[i].offset));
 348             if (GET_BE_WORD(format->format) == 12)
 349                 return format;
 350         }
 351     }
 352     return NULL;
 353 }
 354
 355 static int compare_group(const void *a, const void* b)
 356 {
 357     const DWORD *chr = a;
 358     const CMAP_SegmentedCoverage_group *group = b;
 359
 360     if (*chr < GET_BE_DWORD(group->startCharCode))
 361         return -1;
 362     if (*chr > GET_BE_DWORD(group->endCharCode))
 363         return 1;
 364     return 0;
 365 }
 366
 367 DWORD OpenType_CMAP_GetGlyphIndex(HDC hdc, ScriptCache *psc, DWORD utf32c, LPWORD pgi, DWORD flags)
 368 {
 369     /* BMP: use gdi32 for ease */
 370     if (utf32c < 0x10000)
 371     {
 372         WCHAR ch = utf32c;
 373         return GetGlyphIndicesW(hdc,&ch, 1, pgi, flags);
 374     }
 375
 376     if (!psc->CMAP_format12_Table)
 377         psc->CMAP_format12_Table = load_CMAP_format12_table(hdc, psc);
 378
 379     if (flags & GGI_MARK_NONEXISTING_GLYPHS)
 380         *pgi = 0xffff;
 381     else
 382         *pgi = 0;
 383
 384     if (psc->CMAP_format12_Table)
 385     {
 386         CMAP_SegmentedCoverage *format = NULL;
 387         CMAP_SegmentedCoverage_group *group = NULL;
 388
 389         format = (CMAP_SegmentedCoverage *)psc->CMAP_format12_Table;
 390
 391         group = bsearch(&utf32c, format->groups, GET_BE_DWORD(format->nGroups),
 392                         sizeof(CMAP_SegmentedCoverage_group), compare_group);
 393
 394         if (group)
 395         {
 396             DWORD offset = utf32c - GET_BE_DWORD(group->startCharCode);
 397             *pgi = GET_BE_DWORD(group->startGlyphID) + offset;
 398             return 0;
 399         }
 400     }
 401     return 0;
 402 }
 403
 404 /**********
 405  * GDEF
 406  **********/
 407
 408 static WORD GDEF_get_glyph_class(const GDEF_Header *header, WORD glyph)
 409 {
 410     int offset;
 411     WORD class = 0;
 412     const GDEF_ClassDefFormat1 *cf1;
 413
 414     if (!header)
 415         return 0;
 416
 417     offset = GET_BE_WORD(header->GlyphClassDef);
 418     if (!offset)
 419         return 0;
 420
 421     cf1 = (GDEF_ClassDefFormat1*)(((BYTE*)header)+offset);
 422     if (GET_BE_WORD(cf1->ClassFormat) == 1)
 423     {
 424         if (glyph >= GET_BE_WORD(cf1->StartGlyph))
 425         {
 426             int index = glyph - GET_BE_WORD(cf1->StartGlyph);
 427             if (index < GET_BE_WORD(cf1->GlyphCount))
 428                 class = GET_BE_WORD(cf1->ClassValueArray[index]);
 429         }
 430     }
 431     else if (GET_BE_WORD(cf1->ClassFormat) == 2)
 432     {
 433         const GDEF_ClassDefFormat2 *cf2 = (GDEF_ClassDefFormat2*)cf1;
 434         int i, top;
 435         top = GET_BE_WORD(cf2->ClassRangeCount);
 436         for (i = 0; i < top; i++)
 437         {
 438             if (glyph >= GET_BE_WORD(cf2->ClassRangeRecord[i].Start) &&
 439                 glyph <= GET_BE_WORD(cf2->ClassRangeRecord[i].End))
 440             {
 441                 class = GET_BE_WORD(cf2->ClassRangeRecord[i].Class);
 442                 break;
 443             }
 444         }
 445     }
 446     else
 447         ERR("Unknown Class Format %i\n",GET_BE_WORD(cf1->ClassFormat));
 448
 449     return class;
 450 }
 451
 452 static VOID *load_gdef_table(HDC hdc)
 453 {
 454     VOID* GDEF_Table = NULL;
 455     int length = GetFontData(hdc, GDEF_TAG , 0, NULL, 0);
 456     if (length != GDI_ERROR)
 457     {
 458         GDEF_Table = HeapAlloc(GetProcessHeap(),0,length);
 459         GetFontData(hdc, GDEF_TAG , 0, GDEF_Table, length);
 460         TRACE("Loaded GDEF table of %i bytes\n",length);
 461     }
 462     return GDEF_Table;
 463 }
 464
 465 void OpenType_GDEF_UpdateGlyphProps(HDC hdc, ScriptCache *psc, const WORD *pwGlyphs, const WORD cGlyphs, WORD* pwLogClust, const WORD cChars, SCRIPT_GLYPHPROP *pGlyphProp)
 466 {
 467     int i;
 468
 469     if (!psc->GDEF_Table)
 470         psc->GDEF_Table = load_gdef_table(hdc);
 471
 472     for (i = 0; i < cGlyphs; i++)
 473     {
 474         WORD class;
 475         int char_count = 0;
 476         int k;
 477
 478         k = USP10_FindGlyphInLogClust(pwLogClust, cChars, i);
 479         if (k >= 0)
 480         {
 481             for (; k < cChars && pwLogClust[k] == i; k++)
 482                 char_count++;
 483         }
 484
 485         class = GDEF_get_glyph_class(psc->GDEF_Table, pwGlyphs[i]);
 486
 487         switch (class)
 488         {
 489             case 0:
 490             case BaseGlyph:
 491                 pGlyphProp[i].sva.fClusterStart = 1;
 492                 pGlyphProp[i].sva.fDiacritic = 0;
 493                 pGlyphProp[i].sva.fZeroWidth = 0;
 494                 break;
 495             case LigatureGlyph:
 496                 pGlyphProp[i].sva.fClusterStart = 1;
 497                 pGlyphProp[i].sva.fDiacritic = 0;
 498                 pGlyphProp[i].sva.fZeroWidth = 0;
 499                 break;
 500             case MarkGlyph:
 501                 pGlyphProp[i].sva.fClusterStart = 0;
 502                 pGlyphProp[i].sva.fDiacritic = 1;
 503                 pGlyphProp[i].sva.fZeroWidth = 1;
 504                 break;
 505             case ComponentGlyph:
 506                 pGlyphProp[i].sva.fClusterStart = 0;
 507                 pGlyphProp[i].sva.fDiacritic = 0;
 508                 pGlyphProp[i].sva.fZeroWidth = 0;
 509                 break;
 510             default:
 511                 ERR("Unknown glyph class %i\n",class);
 512                 pGlyphProp[i].sva.fClusterStart = 1;
 513                 pGlyphProp[i].sva.fDiacritic = 0;
 514                 pGlyphProp[i].sva.fZeroWidth = 0;
 515         }
 516
 517         if (char_count == 0)
 518             pGlyphProp[i].sva.fClusterStart = 0;
 519     }
 520 }
 521
 522 /**********
 523  * GSUB
 524  **********/
 525 static INT GSUB_apply_lookup(const OT_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count);
 526
 527 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
 528 {
 529     const OT_CoverageFormat1* cf1;
 530
 531     cf1 = table;
 532
 533     if (GET_BE_WORD(cf1->CoverageFormat) == 1)
 534     {
 535         int count = GET_BE_WORD(cf1->GlyphCount);
 536         int i;
 537         TRACE("Coverage Format 1, %i glyphs\n",count);
 538         for (i = 0; i < count; i++)
 539             if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
 540                 return i;
 541         return -1;
 542     }
 543     else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
 544     {
 545         const OT_CoverageFormat2* cf2;
 546         int i;
 547         int count;
 548         cf2 = (const OT_CoverageFormat2*)cf1;
 549
 550         count = GET_BE_WORD(cf2->RangeCount);
 551         TRACE("Coverage Format 2, %i ranges\n",count);
 552         for (i = 0; i < count; i++)
 553         {
 554             if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
 555                 return -1;
 556             if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
 557                 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
 558             {
 559                 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
 560                     glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
 561             }
 562         }
 563         return -1;
 564     }
 565     else
 566         ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
 567
 568     return -1;
 569 }
 570
 571 static INT GSUB_apply_SingleSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 572 {
 573     int j;
 574     TRACE("Single Substitution Subtable\n");
 575
 576     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 577     {
 578         int offset;
 579         const GSUB_SingleSubstFormat1 *ssf1;
 580         offset = GET_BE_WORD(look->SubTable[j]);
 581         ssf1 = (const GSUB_SingleSubstFormat1*)((const BYTE*)look+offset);
 582         if (GET_BE_WORD(ssf1->SubstFormat) == 1)
 583         {
 584             int offset = GET_BE_WORD(ssf1->Coverage);
 585             TRACE("  subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
 586             if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyphs[glyph_index]) != -1)
 587             {
 588                 TRACE("  Glyph 0x%x ->",glyphs[glyph_index]);
 589                 glyphs[glyph_index] = glyphs[glyph_index] + GET_BE_WORD(ssf1->DeltaGlyphID);
 590                 TRACE(" 0x%x\n",glyphs[glyph_index]);
 591                 return glyph_index + write_dir;
 592             }
 593         }
 594         else
 595         {
 596             const GSUB_SingleSubstFormat2 *ssf2;
 597             INT index;
 598             INT offset;
 599
 600             ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
 601             offset = GET_BE_WORD(ssf1->Coverage);
 602             TRACE("  subtype 2,  glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
 603             index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyphs[glyph_index]);
 604             TRACE("  Coverage index %i\n",index);
 605             if (index != -1)
 606             {
 607                 if (glyphs[glyph_index] == GET_BE_WORD(ssf2->Substitute[index]))
 608                     return GSUB_E_NOGLYPH;
 609
 610                 TRACE("    Glyph is 0x%x ->",glyphs[glyph_index]);
 611                 glyphs[glyph_index] = GET_BE_WORD(ssf2->Substitute[index]);
 612                 TRACE("0x%x\n",glyphs[glyph_index]);
 613                 return glyph_index + write_dir;
 614             }
 615         }
 616     }
 617     return GSUB_E_NOGLYPH;
 618 }
 619
 620 static INT GSUB_apply_MultipleSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 621 {
 622     int j;
 623     TRACE("Multiple Substitution Subtable\n");
 624
 625     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 626     {
 627         int offset, index;
 628         const GSUB_MultipleSubstFormat1 *msf1;
 629         offset = GET_BE_WORD(look->SubTable[j]);
 630         msf1 = (const GSUB_MultipleSubstFormat1*)((const BYTE*)look+offset);
 631
 632         offset = GET_BE_WORD(msf1->Coverage);
 633         index = GSUB_is_glyph_covered((const BYTE*)msf1+offset, glyphs[glyph_index]);
 634         if (index != -1)
 635         {
 636             const GSUB_Sequence *seq;
 637             int sub_count;
 638             int j;
 639             offset = GET_BE_WORD(msf1->Sequence[index]);
 640             seq = (const GSUB_Sequence*)((const BYTE*)msf1+offset);
 641             sub_count = GET_BE_WORD(seq->GlyphCount);
 642             TRACE("  Glyph 0x%x (+%i)->",glyphs[glyph_index],(sub_count-1));
 643
 644             for (j = (*glyph_count)+(sub_count-1); j > glyph_index; j--)
 645                     glyphs[j] =glyphs[j-(sub_count-1)];
 646
 647             for (j = 0; j < sub_count; j++)
 648                     if (write_dir < 0)
 649                         glyphs[glyph_index + (sub_count-1) - j] = GET_BE_WORD(seq->Substitute[j]);
 650                     else
 651                         glyphs[glyph_index + j] = GET_BE_WORD(seq->Substitute[j]);
 652
 653             *glyph_count = *glyph_count + (sub_count - 1);
 654
 655             if (TRACE_ON(uniscribe))
 656             {
 657                 for (j = 0; j < sub_count; j++)
 658                     TRACE(" 0x%x",glyphs[glyph_index+j]);
 659                 TRACE("\n");
 660             }
 661
 662             return glyph_index + (sub_count * write_dir);
 663         }
 664     }
 665     return GSUB_E_NOGLYPH;
 666 }
 667
 668 static INT GSUB_apply_AlternateSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 669 {
 670     int j;
 671     TRACE("Alternate Substitution Subtable\n");
 672
 673     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 674     {
 675         int offset;
 676         const GSUB_AlternateSubstFormat1 *asf1;
 677         INT index;
 678
 679         offset = GET_BE_WORD(look->SubTable[j]);
 680         asf1 = (const GSUB_AlternateSubstFormat1*)((const BYTE*)look+offset);
 681         offset = GET_BE_WORD(asf1->Coverage);
 682
 683         index = GSUB_is_glyph_covered((const BYTE*)asf1+offset, glyphs[glyph_index]);
 684         if (index != -1)
 685         {
 686             const GSUB_AlternateSet *as;
 687             offset =  GET_BE_WORD(asf1->AlternateSet[index]);
 688             as = (const GSUB_AlternateSet*)((const BYTE*)asf1+offset);
 689             FIXME("%i alternates, picking index 0\n",GET_BE_WORD(as->GlyphCount));
 690             if (glyphs[glyph_index] == GET_BE_WORD(as->Alternate[0]))
 691                 return GSUB_E_NOGLYPH;
 692
 693             TRACE("  Glyph 0x%x ->",glyphs[glyph_index]);
 694             glyphs[glyph_index] = GET_BE_WORD(as->Alternate[0]);
 695             TRACE(" 0x%x\n",glyphs[glyph_index]);
 696             return glyph_index + write_dir;
 697         }
 698     }
 699     return GSUB_E_NOGLYPH;
 700 }
 701
 702 static INT GSUB_apply_LigatureSubst(const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 703 {
 704     int j;
 705
 706     TRACE("Ligature Substitution Subtable\n");
 707     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 708     {
 709         const GSUB_LigatureSubstFormat1 *lsf1;
 710         int offset,index;
 711
 712         offset = GET_BE_WORD(look->SubTable[j]);
 713         lsf1 = (const GSUB_LigatureSubstFormat1*)((const BYTE*)look+offset);
 714         offset = GET_BE_WORD(lsf1->Coverage);
 715         index = GSUB_is_glyph_covered((const BYTE*)lsf1+offset, glyphs[glyph_index]);
 716         TRACE("  Coverage index %i\n",index);
 717         if (index != -1)
 718         {
 719             const GSUB_LigatureSet *ls;
 720             int k, count;
 721
 722             offset = GET_BE_WORD(lsf1->LigatureSet[index]);
 723             ls = (const GSUB_LigatureSet*)((const BYTE*)lsf1+offset);
 724             count = GET_BE_WORD(ls->LigatureCount);
 725             TRACE("  LigatureSet has %i members\n",count);
 726             for (k = 0; k < count; k++)
 727             {
 728                 const GSUB_Ligature *lig;
 729                 int CompCount,l,CompIndex;
 730
 731                 offset = GET_BE_WORD(ls->Ligature[k]);
 732                 lig = (const GSUB_Ligature*)((const BYTE*)ls+offset);
 733                 CompCount = GET_BE_WORD(lig->CompCount) - 1;
 734                 CompIndex = glyph_index+write_dir;
 735                 for (l = 0; l < CompCount && CompIndex >= 0 && CompIndex < *glyph_count; l++)
 736                 {
 737                     int CompGlyph;
 738                     CompGlyph = GET_BE_WORD(lig->Component[l]);
 739                     if (CompGlyph != glyphs[CompIndex])
 740                         break;
 741                     CompIndex += write_dir;
 742                 }
 743                 if (l == CompCount)
 744                 {
 745                     int replaceIdx = glyph_index;
 746                     if (write_dir < 0)
 747                         replaceIdx = glyph_index - CompCount;
 748
 749                     TRACE("    Glyph is 0x%x (+%i) ->",glyphs[glyph_index],CompCount);
 750                     glyphs[replaceIdx] = GET_BE_WORD(lig->LigGlyph);
 751                     TRACE("0x%x\n",glyphs[replaceIdx]);
 752                     if (CompCount > 0)
 753                     {
 754                         int j;
 755                         for (j = replaceIdx + 1; j < *glyph_count; j++)
 756                             glyphs[j] =glyphs[j+CompCount];
 757                         *glyph_count = *glyph_count - CompCount;
 758                     }
 759                     return replaceIdx + write_dir;
 760                 }
 761             }
 762         }
 763     }
 764     return GSUB_E_NOGLYPH;
 765 }
 766
 767 static INT GSUB_apply_ChainContextSubst(const OT_LookupList* lookup, const OT_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 768 {
 769     int j;
 770     BOOL done = FALSE;
 771
 772     TRACE("Chaining Contextual Substitution Subtable\n");
 773     for (j = 0; j < GET_BE_WORD(look->SubTableCount) && !done; j++)
 774     {
 775         const GSUB_ChainContextSubstFormat1 *ccsf1;
 776         int offset;
 777         int dirLookahead = write_dir;
 778         int dirBacktrack = -1 * write_dir;
 779
 780         offset = GET_BE_WORD(look->SubTable[j]);
 781         ccsf1 = (const GSUB_ChainContextSubstFormat1*)((const BYTE*)look+offset);
 782         if (GET_BE_WORD(ccsf1->SubstFormat) == 1)
 783         {
 784             FIXME("  TODO: subtype 1 (Simple context glyph substitution)\n");
 785             continue;
 786         }
 787         else if (GET_BE_WORD(ccsf1->SubstFormat) == 2)
 788         {
 789             FIXME("  TODO: subtype 2 (Class-based Chaining Context Glyph Substitution)\n");
 790             continue;
 791         }
 792         else if (GET_BE_WORD(ccsf1->SubstFormat) == 3)
 793         {
 794             int k;
 795             int indexGlyphs;
 796             const GSUB_ChainContextSubstFormat3_1 *ccsf3_1;
 797             const GSUB_ChainContextSubstFormat3_2 *ccsf3_2;
 798             const GSUB_ChainContextSubstFormat3_3 *ccsf3_3;
 799             const GSUB_ChainContextSubstFormat3_4 *ccsf3_4;
 800             int newIndex = glyph_index;
 801
 802             ccsf3_1 = (const GSUB_ChainContextSubstFormat3_1 *)ccsf1;
 803
 804             TRACE("  subtype 3 (Coverage-based Chaining Context Glyph Substitution)\n");
 805
 806             for (k = 0; k < GET_BE_WORD(ccsf3_1->BacktrackGlyphCount); k++)
 807             {
 808                 offset = GET_BE_WORD(ccsf3_1->Coverage[k]);
 809                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirBacktrack * (k+1))]) == -1)
 810                     break;
 811             }
 812             if (k != GET_BE_WORD(ccsf3_1->BacktrackGlyphCount))
 813                 continue;
 814             TRACE("Matched Backtrack\n");
 815
 816             ccsf3_2 = (const GSUB_ChainContextSubstFormat3_2 *)(((LPBYTE)ccsf1)+sizeof(GSUB_ChainContextSubstFormat3_1) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_1->BacktrackGlyphCount)-1)));
 817
 818             indexGlyphs = GET_BE_WORD(ccsf3_2->InputGlyphCount);
 819             for (k = 0; k < indexGlyphs; k++)
 820             {
 821                 offset = GET_BE_WORD(ccsf3_2->Coverage[k]);
 822                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (write_dir * k)]) == -1)
 823                     break;
 824             }
 825             if (k != indexGlyphs)
 826                 continue;
 827             TRACE("Matched IndexGlyphs\n");
 828
 829             ccsf3_3 = (const GSUB_ChainContextSubstFormat3_3 *)(((LPBYTE)ccsf3_2)+sizeof(GSUB_ChainContextSubstFormat3_2) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_2->InputGlyphCount)-1)));
 830
 831             for (k = 0; k < GET_BE_WORD(ccsf3_3->LookaheadGlyphCount); k++)
 832             {
 833                 offset = GET_BE_WORD(ccsf3_3->Coverage[k]);
 834                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirLookahead * (indexGlyphs + k))]) == -1)
 835                     break;
 836             }
 837             if (k != GET_BE_WORD(ccsf3_3->LookaheadGlyphCount))
 838                 continue;
 839             TRACE("Matched LookAhead\n");
 840
 841             ccsf3_4 = (const GSUB_ChainContextSubstFormat3_4 *)(((LPBYTE)ccsf3_3)+sizeof(GSUB_ChainContextSubstFormat3_3) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_3->LookaheadGlyphCount)-1)));
 842
 843             if (GET_BE_WORD(ccsf3_4->SubstCount))
 844             {
 845                 for (k = 0; k < GET_BE_WORD(ccsf3_4->SubstCount); k++)
 846                 {
 847                     int lookupIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].LookupListIndex);
 848                     int SequenceIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].SequenceIndex) * write_dir;
 849
 850                     TRACE("SUBST: %i -> %i %i\n",k, SequenceIndex, lookupIndex);
 851                     newIndex = GSUB_apply_lookup(lookup, lookupIndex, glyphs, glyph_index + SequenceIndex, write_dir, glyph_count);
 852                     if (newIndex == -1)
 853                     {
 854                         ERR("Chain failed to generate a glyph\n");
 855                         continue;
 856                     }
 857                 }
 858                 return newIndex;
 859             }
 860             else return GSUB_E_NOGLYPH;
 861         }
 862     }
 863     return -1;
 864 }
 865
 866 static INT GSUB_apply_lookup(const OT_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 867 {
 868     int offset;
 869     const OT_LookupTable *look;
 870
 871     offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
 872     look = (const OT_LookupTable*)((const BYTE*)lookup + offset);
 873     TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
 874     switch(GET_BE_WORD(look->LookupType))
 875     {
 876         case 1:
 877             return GSUB_apply_SingleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
 878         case 2:
 879             return GSUB_apply_MultipleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
 880         case 3:
 881             return GSUB_apply_AlternateSubst(look, glyphs, glyph_index, write_dir, glyph_count);
 882         case 4:
 883             return GSUB_apply_LigatureSubst(look, glyphs, glyph_index, write_dir, glyph_count);
 884         case 6:
 885             return GSUB_apply_ChainContextSubst(lookup, look, glyphs, glyph_index, write_dir, glyph_count);
 886         default:
 887             FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
 888     }
 889     return GSUB_E_NOGLYPH;
 890 }
 891
 892 INT OpenType_apply_GSUB_lookup(LPCVOID table, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 893 {
 894     const GSUB_Header *header = (const GSUB_Header *)table;
 895     const OT_LookupList *lookup = (const OT_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
 896
 897     return GSUB_apply_lookup(lookup, lookup_index, glyphs, glyph_index, write_dir, glyph_count);
 898 }
 899
 900 /**********
 901  * GPOS
 902  **********/
 903 static INT GPOS_get_device_table_value(const OT_DeviceTable *DeviceTable, WORD ppem)
 904 {
 905     static const WORD mask[3] = {3,0xf,0xff};
 906     if (DeviceTable && ppem >= GET_BE_WORD(DeviceTable->StartSize) && ppem  <= GET_BE_WORD(DeviceTable->EndSize))
 907     {
 908         int format = GET_BE_WORD(DeviceTable->DeltaFormat);
 909         int index = ppem - GET_BE_WORD(DeviceTable->StartSize);
 910         int value;
 911         TRACE("device table, format %i, index %i\n",format, index);
 912         index = index << format;
 913         value = (DeviceTable->DeltaValue[index/sizeof(WORD)] << (index%sizeof(WORD)))&mask[format-1];
 914         TRACE("offset %i, value %i\n",index, value);
 915         if (value > mask[format-1]/2)
 916             value = -1 * ((mask[format-1]+1) - value);
 917         return value;
 918     }
 919     return 0;
 920 }
 921
 922 static VOID GPOS_get_anchor_values(LPCVOID table, LPPOINT pt, WORD ppem)
 923 {
 924     const GPOS_AnchorFormat1* anchor1 = (const GPOS_AnchorFormat1*)table;
 925
 926     switch (GET_BE_WORD(anchor1->AnchorFormat))
 927     {
 928         case 1:
 929         {
 930             TRACE("Anchor Format 1\n");
 931             pt->x = (short)GET_BE_WORD(anchor1->XCoordinate);
 932             pt->y = (short)GET_BE_WORD(anchor1->YCoordinate);
 933             break;
 934         }
 935         case 2:
 936         {
 937             const GPOS_AnchorFormat2* anchor2 = (const GPOS_AnchorFormat2*)table;
 938             TRACE("Anchor Format 2\n");
 939             pt->x = (short)GET_BE_WORD(anchor2->XCoordinate);
 940             pt->y = (short)GET_BE_WORD(anchor2->YCoordinate);
 941             break;
 942         }
 943         case 3:
 944         {
 945             int offset;
 946             const GPOS_AnchorFormat3* anchor3 = (const GPOS_AnchorFormat3*)table;
 947             TRACE("Anchor Format 3\n");
 948             pt->x = (short)GET_BE_WORD(anchor3->XCoordinate);
 949             pt->y = (short)GET_BE_WORD(anchor3->YCoordinate);
 950             offset = GET_BE_WORD(anchor3->XDeviceTable);
 951             TRACE("ppem %i\n",ppem);
 952             if (offset)
 953             {
 954                 const OT_DeviceTable* DeviceTableX = NULL;
 955                 DeviceTableX = (const OT_DeviceTable*)((const BYTE*)anchor3 + offset);
 956                 pt->x += GPOS_get_device_table_value(DeviceTableX, ppem);
 957             }
 958             offset = GET_BE_WORD(anchor3->YDeviceTable);
 959             if (offset)
 960             {
 961                 const OT_DeviceTable* DeviceTableY = NULL;
 962                 DeviceTableY = (const OT_DeviceTable*)((const BYTE*)anchor3 + offset);
 963                 pt->y += GPOS_get_device_table_value(DeviceTableY, ppem);
 964             }
 965             break;
 966         }
 967         default:
 968             ERR("Unknown Anchor Format %i\n",GET_BE_WORD(anchor1->AnchorFormat));
 969             pt->x = 0;
 970             pt->y = 0;
 971     }
 972 }
 973
 974 static INT GPOS_apply_lookup(LPOUTLINETEXTMETRICW lpotm, LPLOGFONTW lplogfont, INT* piAdvance, const OT_LookupList* lookup, INT lookup_index, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, GOFFSET *pGoffset)
 975 {
 976     int offset;
 977     const OT_LookupTable *look;
 978
 979     offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
 980     look = (const OT_LookupTable*)((const BYTE*)lookup + offset);
 981     TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
 982     switch(GET_BE_WORD(look->LookupType))
 983     {
 984         default:
 985             FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
 986     }
 987     return glyph_index+1;
 988 }
 989
 990 INT OpenType_apply_GPOS_lookup(LPOUTLINETEXTMETRICW lpotm, LPLOGFONTW lplogfont, INT* piAdvance, LPCVOID table, INT lookup_index, const WORD *glyphs, INT glyph_index, INT write_dir, INT glyph_count, GOFFSET *pGoffset)
 991 {
 992     const GPOS_Header *header = (const GPOS_Header *)table;
 993     const OT_LookupList *lookup = (const OT_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
 994
 995     return GPOS_apply_lookup(lpotm, lplogfont, piAdvance, lookup, lookup_index, glyphs, glyph_index, write_dir, glyph_count, pGoffset);
 996 }
 997
 998 static void GSUB_initialize_script_cache(ScriptCache *psc)
 999 {
1000     int i;
1001
1002     if (psc->GSUB_Table)
1003     {
1004         const OT_ScriptList *script;
1005         const GSUB_Header* header = (const GSUB_Header*)psc->GSUB_Table;
1006         script = (const OT_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
1007         psc->script_count = GET_BE_WORD(script->ScriptCount);
1008         TRACE("initializing %i scripts in this font\n",psc->script_count);
1009         if (psc->script_count)
1010         {
1011             psc->scripts = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(LoadedScript) * psc->script_count);
1012             for (i = 0; i < psc->script_count; i++)
1013             {
1014                 int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1015                 psc->scripts[i].tag = MS_MAKE_TAG(script->ScriptRecord[i].ScriptTag[0], script->ScriptRecord[i].ScriptTag[1], script->ScriptRecord[i].ScriptTag[2], script->ScriptRecord[i].ScriptTag[3]);
1016                 psc->scripts[i].gsub_table = ((const BYTE*)script + offset);
1017             }
1018         }
1019     }
1020 }
1021
1022 static void GPOS_expand_script_cache(ScriptCache *psc)
1023 {
1024     int i, count;
1025     const OT_ScriptList *script;
1026     const GPOS_Header* header = (const GPOS_Header*)psc->GPOS_Table;
1027
1028     if (!header)
1029         return;
1030
1031     script = (const OT_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
1032     count = GET_BE_WORD(script->ScriptCount);
1033
1034     if (!psc->script_count)
1035     {
1036         psc->script_count = count;
1037         TRACE("initializing %i scripts in this font\n",psc->script_count);
1038         if (psc->script_count)
1039         {
1040             psc->scripts = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(LoadedScript) * psc->script_count);
1041             for (i = 0; i < psc->script_count; i++)
1042             {
1043                 int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1044                 psc->scripts[i].tag = MS_MAKE_TAG(script->ScriptRecord[i].ScriptTag[0], script->ScriptRecord[i].ScriptTag[1], script->ScriptRecord[i].ScriptTag[2], script->ScriptRecord[i].ScriptTag[3]);
1045                 psc->scripts[i].gpos_table = ((const BYTE*)script + offset);
1046             }
1047         }
1048     }
1049     else
1050     {
1051         for (i = 0; i < count; i++)
1052         {
1053             int j;
1054             int offset = GET_BE_WORD(script->ScriptRecord[i].Script);
1055             OPENTYPE_TAG tag = MS_MAKE_TAG(script->ScriptRecord[i].ScriptTag[0], script->ScriptRecord[i].ScriptTag[1], script->ScriptRecord[i].ScriptTag[2], script->ScriptRecord[i].ScriptTag[3]);
1056             for (j = 0; j < psc->script_count; j++)
1057             {
1058                 if (psc->scripts[j].tag == tag)
1059                 {
1060                     psc->scripts[j].gpos_table = ((const BYTE*)script + offset);
1061                     break;
1062                 }
1063             }
1064             if (j == psc->script_count)
1065             {
1066                 psc->script_count++;
1067                 psc->scripts = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,psc->scripts, sizeof(LoadedScript) * psc->script_count);
1068                 psc->scripts[j].tag = tag;
1069                 psc->scripts[j].gpos_table = ((const BYTE*)script + offset);
1070             }
1071         }
1072     }
1073 }
1074
1075 static void _initialize_script_cache(ScriptCache *psc)
1076 {
1077     if (!psc->script_count)
1078     {
1079         GSUB_initialize_script_cache(psc);
1080         GPOS_expand_script_cache(psc);
1081     }
1082 }
1083
1084 HRESULT OpenType_GetFontScriptTags(ScriptCache *psc, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pScriptTags, int *pcTags)
1085 {
1086     int i;
1087     HRESULT rc = S_OK;
1088
1089     _initialize_script_cache(psc);
1090
1091     *pcTags = psc->script_count;
1092
1093     if (!searchingFor && cMaxTags < *pcTags)
1094         rc = E_OUTOFMEMORY;
1095     else if (searchingFor)
1096         rc = USP_E_SCRIPT_NOT_IN_FONT;
1097
1098     for (i = 0; i < psc->script_count; i++)
1099     {
1100         if (i < cMaxTags)
1101             pScriptTags[i] = psc->scripts[i].tag;
1102
1103         if (searchingFor)
1104         {
1105             if (searchingFor == psc->scripts[i].tag)
1106             {
1107                 pScriptTags[0] = psc->scripts[i].tag;
1108                 *pcTags = 1;
1109                 rc = S_OK;
1110                 break;
1111             }
1112         }
1113     }
1114     return rc;
1115 }
1116
1117 static void GSUB_initialize_language_cache(LoadedScript *script)
1118 {
1119     int i;
1120
1121     if (script->gsub_table)
1122     {
1123         DWORD offset;
1124         const OT_Script* table = script->gsub_table;
1125         script->language_count = GET_BE_WORD(table->LangSysCount);
1126         offset = GET_BE_WORD(table->DefaultLangSys);
1127         if (offset)
1128         {
1129             script->default_language.tag = MS_MAKE_TAG('d','f','l','t');
1130             script->default_language.gsub_table = (const BYTE*)table + offset;
1131         }
1132
1133         if (script->language_count)
1134         {
1135             TRACE("Deflang %p, LangCount %i\n",script->default_language.gsub_table, script->language_count);
1136
1137             script->languages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LoadedLanguage) * script->language_count);
1138
1139             for (i = 0; i < script->language_count; i++)
1140             {
1141                 int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1142                 script->languages[i].tag = MS_MAKE_TAG(table->LangSysRecord[i].LangSysTag[0], table->LangSysRecord[i].LangSysTag[1], table->LangSysRecord[i].LangSysTag[2], table->LangSysRecord[i].LangSysTag[3]);
1143                 script->languages[i].gsub_table = ((const BYTE*)table + offset);
1144             }
1145         }
1146     }
1147 }
1148
1149 static void GPOS_expand_language_cache(LoadedScript *script)
1150 {
1151     int count;
1152     const OT_Script* table = script->gpos_table;
1153     DWORD offset;
1154
1155     if (!table)
1156         return;
1157
1158     offset = GET_BE_WORD(table->DefaultLangSys);
1159     if (offset)
1160         script->default_language.gpos_table = (const BYTE*)table + offset;
1161
1162     count = GET_BE_WORD(table->LangSysCount);
1163
1164     TRACE("Deflang %p, LangCount %i\n",script->default_language.gpos_table, count);
1165     if (!script->language_count)
1166     {
1167         int i;
1168         script->language_count = count;
1169
1170         script->languages = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LoadedLanguage) * script->language_count);
1171
1172         for (i = 0; i < script->language_count; i++)
1173         {
1174             int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1175             script->languages[i].tag = MS_MAKE_TAG(table->LangSysRecord[i].LangSysTag[0], table->LangSysRecord[i].LangSysTag[1], table->LangSysRecord[i].LangSysTag[2], table->LangSysRecord[i].LangSysTag[3]);
1176             script->languages[i].gpos_table = ((const BYTE*)table + offset);
1177         }
1178     }
1179     else if (count)
1180     {
1181         int i,j;
1182         for (i = 0; i < count; i++)
1183         {
1184             int offset = GET_BE_WORD(table->LangSysRecord[i].LangSys);
1185             OPENTYPE_TAG tag = MS_MAKE_TAG(table->LangSysRecord[i].LangSysTag[0], table->LangSysRecord[i].LangSysTag[1], table->LangSysRecord[i].LangSysTag[2], table->LangSysRecord[i].LangSysTag[3]);
1186
1187             for (j = 0; j < script->language_count; j++)
1188             {
1189                 if (script->languages[j].tag == tag)
1190                 {
1191                     script->languages[j].gpos_table = ((const BYTE*)table + offset);
1192                     break;
1193                 }
1194             }
1195             if (j == script->language_count)
1196             {
1197                 script->language_count++;
1198                 script->languages = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,script->languages, sizeof(LoadedLanguage) * script->language_count);
1199                 script->languages[j].tag = tag;
1200                 script->languages[j].gpos_table = ((const BYTE*)table + offset);
1201             }
1202         }
1203     }
1204 }
1205
1206 static void _initialize_language_cache(LoadedScript *script)
1207 {
1208     if (!script->language_count)
1209     {
1210         GSUB_initialize_language_cache(script);
1211         GPOS_expand_language_cache(script);
1212     }
1213 }
1214
1215 HRESULT OpenType_GetFontLanguageTags(ScriptCache *psc, OPENTYPE_TAG script_tag, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pLanguageTags, int *pcTags)
1216 {
1217     int i;
1218     HRESULT rc = S_OK;
1219     LoadedScript *script = NULL;
1220
1221     _initialize_script_cache(psc);
1222
1223     for (i = 0; i < psc->script_count; i++)
1224     {
1225          if (psc->scripts[i].tag == script_tag)
1226          {
1227             script = &psc->scripts[i];
1228             break;
1229          }
1230     }
1231
1232     if (!script)
1233         return E_INVALIDARG;
1234
1235     _initialize_language_cache(script);
1236
1237     if (!searchingFor && cMaxTags < script->language_count)
1238         rc = E_OUTOFMEMORY;
1239     else if (searchingFor)
1240         rc = E_INVALIDARG;
1241
1242     *pcTags = script->language_count;
1243
1244     for (i = 0; i < script->language_count; i++)
1245     {
1246         if (i < cMaxTags)
1247             pLanguageTags[i] = script->languages[i].tag;
1248
1249         if (searchingFor)
1250         {
1251             if (searchingFor == script->languages[i].tag)
1252             {
1253                 pLanguageTags[0] = script->languages[i].tag;
1254                 *pcTags = 1;
1255                 rc = S_OK;
1256                 break;
1257             }
1258         }
1259     }
1260
1261     if (script->default_language.gsub_table)
1262     {
1263         if (i < cMaxTags)
1264             pLanguageTags[i] = script->default_language.tag;
1265
1266         if (searchingFor  && FAILED(rc))
1267         {
1268             pLanguageTags[0] = script->default_language.tag;
1269         }
1270         i++;
1271         *pcTags = (*pcTags) + 1;
1272     }
1273
1274     return rc;
1275 }
1276
1277
1278 static void GSUB_initialize_feature_cache(LPCVOID table, LoadedLanguage *language)
1279 {
1280     int i;
1281
1282     if (language->gsub_table)
1283     {
1284         const OT_LangSys *lang = language->gsub_table;
1285         const GSUB_Header *header = (const GSUB_Header *)table;
1286         const OT_FeatureList *feature_list;
1287
1288         language->feature_count = GET_BE_WORD(lang->FeatureCount);
1289         TRACE("%i features\n",language->feature_count);
1290
1291         if (language->feature_count)
1292         {
1293             language->features = HeapAlloc(GetProcessHeap(),0,sizeof(LoadedFeature)*language->feature_count);
1294
1295             feature_list = (const OT_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
1296
1297             for (i = 0; i < language->feature_count; i++)
1298             {
1299                 const OT_Feature *feature;
1300                 int j;
1301                 int index = GET_BE_WORD(lang->FeatureIndex[i]);
1302
1303                 language->features[i].tag = MS_MAKE_TAG(feature_list->FeatureRecord[index].FeatureTag[0], feature_list->FeatureRecord[index].FeatureTag[1], feature_list->FeatureRecord[index].FeatureTag[2], feature_list->FeatureRecord[index].FeatureTag[3]);
1304                 language->features[i].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1305                 feature = (const OT_Feature*)language->features[i].feature;
1306                 language->features[i].lookup_count = GET_BE_WORD(feature->LookupCount);
1307                 language->features[i].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[i].lookup_count);
1308                 for (j = 0; j < language->features[i].lookup_count; j++)
1309                     language->features[i].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1310             }
1311         }
1312     }
1313 }
1314
1315 static void GPOS_expand_feature_cache(LPCVOID table, LoadedLanguage *language)
1316 {
1317     int i, count;
1318     const OT_LangSys *lang = language->gpos_table;
1319     const GPOS_Header *header = (const GPOS_Header *)table;
1320     const OT_FeatureList *feature_list;
1321
1322     if (!lang)
1323         return;
1324
1325     count = GET_BE_WORD(lang->FeatureCount);
1326     feature_list = (const OT_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
1327
1328     TRACE("%i features\n",count);
1329     if (!language->feature_count)
1330     {
1331         language->feature_count = count;
1332
1333         if (language->feature_count)
1334         {
1335             language->features = HeapAlloc(GetProcessHeap(),0,sizeof(LoadedFeature)*language->feature_count);
1336
1337             for (i = 0; i < language->feature_count; i++)
1338             {
1339                 const OT_Feature *feature;
1340                 int j;
1341                 int index = GET_BE_WORD(lang->FeatureIndex[i]);
1342
1343                 language->features[i].tag = MS_MAKE_TAG(feature_list->FeatureRecord[index].FeatureTag[0], feature_list->FeatureRecord[index].FeatureTag[1], feature_list->FeatureRecord[index].FeatureTag[2], feature_list->FeatureRecord[index].FeatureTag[3]);
1344                 language->features[i].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1345                 feature = (const OT_Feature*)language->features[i].feature;
1346                 language->features[i].lookup_count = GET_BE_WORD(feature->LookupCount);
1347                 language->features[i].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[i].lookup_count);
1348                 for (j = 0; j < language->features[i].lookup_count; j++)
1349                     language->features[i].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1350             }
1351         }
1352     }
1353     else if (count)
1354     {
1355         language->features = HeapReAlloc(GetProcessHeap(),0,language->features, sizeof(LoadedFeature)*(language->feature_count + count));
1356
1357         for (i = 0; i < count; i++)
1358         {
1359             const OT_Feature *feature;
1360             int j;
1361             int index = GET_BE_WORD(lang->FeatureIndex[i]);
1362             int idx = language->feature_count + i;
1363
1364             language->features[idx].tag = MS_MAKE_TAG(feature_list->FeatureRecord[index].FeatureTag[0], feature_list->FeatureRecord[index].FeatureTag[1], feature_list->FeatureRecord[index].FeatureTag[2], feature_list->FeatureRecord[index].FeatureTag[3]);
1365             language->features[idx].feature = ((const BYTE*)feature_list + GET_BE_WORD(feature_list->FeatureRecord[index].Feature));
1366             feature = (const OT_Feature*)language->features[idx].feature;
1367             language->features[idx].lookup_count = GET_BE_WORD(feature->LookupCount);
1368             language->features[idx].lookups = HeapAlloc(GetProcessHeap(),0,sizeof(WORD) * language->features[idx].lookup_count);
1369             for (j = 0; j < language->features[idx].lookup_count; j++)
1370                 language->features[idx].lookups[j] = GET_BE_WORD(feature->LookupListIndex[j]);
1371         }
1372         language->feature_count += count;
1373     }
1374 }
1375
1376 static void _initialize_feature_cache(ScriptCache *psc, LoadedLanguage *language)
1377 {
1378     if (!language->feature_count)
1379     {
1380         GSUB_initialize_feature_cache(psc->GSUB_Table, language);
1381         GPOS_expand_feature_cache(psc->GPOS_Table, language);
1382     }
1383 }
1384
1385 HRESULT OpenType_GetFontFeatureTags(ScriptCache *psc, OPENTYPE_TAG script_tag, OPENTYPE_TAG language_tag, BOOL filtered, OPENTYPE_TAG searchingFor, int cMaxTags, OPENTYPE_TAG *pFeatureTags, int *pcTags, LoadedFeature** feature)
1386 {
1387     int i;
1388     HRESULT rc = S_OK;
1389     LoadedScript *script = NULL;
1390     LoadedLanguage *language = NULL;
1391
1392     _initialize_script_cache(psc);
1393
1394     for (i = 0; i < psc->script_count; i++)
1395     {
1396         if (psc->scripts[i].tag == script_tag)
1397         {
1398             script = &psc->scripts[i];
1399             break;
1400         }
1401     }
1402
1403     if (!script)
1404     {
1405         *pcTags = 0;
1406         if (!filtered)
1407             return S_OK;
1408         else
1409             return E_INVALIDARG;
1410     }
1411
1412     _initialize_language_cache(script);
1413
1414     if ((script->default_language.gsub_table || script->default_language.gpos_table) && script->default_language.tag == language_tag)
1415         language = &script->default_language;
1416     else
1417     {
1418         for (i = 0; i < script->language_count; i++)
1419         {
1420             if (script->languages[i].tag == language_tag)
1421             {
1422                 language = &script->languages[i];
1423                 break;
1424             }
1425         }
1426     }
1427
1428     if (!language)
1429     {
1430         *pcTags = 0;
1431         return S_OK;
1432     }
1433
1434     _initialize_feature_cache(psc, language);
1435
1436     *pcTags = language->feature_count;
1437
1438     if (!searchingFor && cMaxTags < *pcTags)
1439         rc = E_OUTOFMEMORY;
1440     else if (searchingFor)
1441         rc = E_INVALIDARG;
1442
1443     for (i = 0; i < language->feature_count; i++)
1444     {
1445         if (i < cMaxTags)
1446             pFeatureTags[i] = language->features[i].tag;
1447
1448         if (searchingFor)
1449         {
1450             if (searchingFor == language->features[i].tag)
1451             {
1452                 pFeatureTags[0] = language->features[i].tag;
1453                 *pcTags = 1;
1454                 if (feature)
1455                     *feature = &language->features[i];
1456                 rc = S_OK;
1457                 break;
1458             }
1459         }
1460     }
1461     return rc;
1462 }