src/otf.h

   1 /* otf.h -- Header file for libotf (OpenType font library).
   2
   3 Copyright (C) 2003, 2004, 2005
   4   National Institute of Advanced Industrial Science and Technology (AIST)
   5   Registration Number H15PRO167
   6
   7 This file is part of libotf.
   8
   9 Libotf is free software; you can redistribute it and/or modify it
  10 under the terms of the GNU Lesser General Public License as published
  11 by the Free Software Foundation; either version 2.1 of the License, or
  12 (at your option) any later version.
  13
  14 Libotf is distributed in the hope that it will be useful, but WITHOUT
  15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  17 License for more details.
  18
  19 You should have received a copy of the GNU Lesser General Public
  20 License along with this library, in a file named COPYING; if not,
  21 write to the Free Software Foundation, Inc., 59 Temple Place, Suite
  22 330, Boston, MA 02111-1307, USA.  */
  23
  24 #ifndef _OTF_H_
  25 #define _OTF_H_
  26
  27 /* Version name of this library.  */
  28 #define LIBOTF_VERSION "0.9.4"
  29
  30 /* Major version number.  */
  31 #define LIBOTF_MAJOR_VERSION 0
  32 /* Minor version number.  */
  33 #define LIBOTF_MINOR_VERSION 9
  34 /* Release (i.e. patch level) number.  */
  35 #define LIBOTF_RELEASE_NUMBER 4
  36
  37 /***
  38     Table of contents:
  39
  40     (1) Structures for OTF Layout tables and OTF itself
  41     (1-1) Basic types
  42     (1-2) "head" table
  43     (1-3) "name" table
  44     (1-4) "cmap" table
  45     (1-5) Structures common to GDEF, GSUB, and GPOS
  46     (1-6) "GDEF" table
  47     (1-7) Structures for ScriptList, FeatureList, and LookupList
  48     (1-8) Structures common to GSUB and GPOS
  49     (1-9) "GSUB" table
  50     (1-10) "GPOS" table
  51     (1-11) Structure for OTF
  52
  53     (2) API for reading OTF
  54     (2-1) OTF_open()
  55     (2-2) OTF_close()
  56     (2-3) OTF_get_table()
  57     (2-4) OTF_check_table()
  58
  59     (3) API for driving OTF
  60     (3-1) Structure for glyph string
  61     (3-2) OTF_drive_cmap()
  62     (3-3) OTF_drive_gdef()
  63     (3-4) OTF_drive_gsub()
  64     (3-5) OTF_drive_gpos()
  65     (3-6) OTF_drive_tables()
  66     (3-7) OTF_get_unicode()
  67     (3-8) OTF_drive_gsub_alternate()
  68
  69     (4) API for error handling
  70     (4-1) Error codes
  71     (4-2) OTF_perror()
  72
  73     (5) API miscellaneous
  74
  75 */
  76
  77 \f
  78 /*** (1) Structures for OTF Layout tables and OTF itself */
  79
  80 /*** (1-1) Basic types */
  81
  82 typedef unsigned OTF_Tag;
  83 typedef unsigned OTF_GlyphID;
  84 typedef unsigned OTF_Offset;
  85
  86 typedef struct
  87 {
  88   unsigned high;
  89   unsigned low;
  90 } OTF_Fixed;
  91
  92
  93 /*** (1-2) "head" table */
  94
  95 typedef struct
  96 {
  97   OTF_Fixed TableVersionNumber;
  98   OTF_Fixed fontRevision;
  99   unsigned checkSumAdjustment;
 100   unsigned magicNumber;
 101   unsigned flags;
 102   int unitsPerEm;
 103 } OTF_head;
 104
 105
 106 /*** (1-3) "name" table */
 107
 108 typedef struct
 109 {
 110   int platformID;
 111   int encodingID;
 112   int languageID;
 113   int nameID;
 114   int length;
 115   int offset;
 116
 117   /* If nonzero, NAME is an ASCII string.  */
 118   int ascii;
 119   unsigned char *name;
 120 } OTF_NameRecord;
 121
 122 #define OTF_max_nameID 23
 123
 124 typedef struct
 125 {
 126   int format;
 127   int count;
 128   int stringOffset;
 129   OTF_NameRecord *nameRecord;
 130   char *name[OTF_max_nameID + 1];
 131 } OTF_name;
 132
 133
 134 /*** (1-4) "cmap" table */
 135
 136 typedef struct
 137 {
 138   unsigned char glyphIdArray[256];
 139 } OTF_EncodingSubtable0;
 140
 141 typedef struct
 142 {
 143   unsigned firstCode;
 144   unsigned entryCount;
 145   int idDelta;
 146   unsigned idRangeOffset;
 147 } OTF_cmapSubHeader;
 148
 149 typedef struct
 150 {
 151   unsigned short subHeaderKeys[256];
 152   int subHeaderCount;
 153   OTF_cmapSubHeader *subHeaders;
 154   int glyphIndexCount;
 155   OTF_GlyphID *glyphIndexArray;
 156 } OTF_EncodingSubtable2;
 157
 158 typedef struct
 159 {
 160   unsigned startCount;
 161   unsigned endCount;
 162   int idDelta;
 163   unsigned idRangeOffset;
 164 } OTF_cmapSegument;
 165
 166 typedef struct
 167 {
 168   unsigned segCountX2;
 169   unsigned searchRange;
 170   unsigned entrySelector;
 171   unsigned rangeShift;
 172   OTF_cmapSegument *segments;
 173   int GlyphCount;
 174   unsigned *glyphIdArray;
 175 } OTF_EncodingSubtable4;
 176
 177 typedef struct
 178 {
 179   unsigned firstCode;
 180   unsigned entryCount;
 181   unsigned *glyphIdArray;
 182 } OTF_EncodingSubtable6;
 183
 184 typedef struct
 185 {
 186   unsigned startCharCode;
 187   unsigned endCharCode;
 188   unsigned startGlyphID;
 189 } OTF_cmapGroup;
 190
 191 typedef struct
 192 {
 193   unsigned char is32[8192];
 194   unsigned nGroups;
 195   OTF_cmapGroup *Groups;
 196 } OTF_EncodingSubtable8;
 197
 198 typedef struct
 199 {
 200   unsigned startCharCode;
 201   unsigned numChars;
 202   unsigned *glyphs;
 203 } OTF_EncodingSubtable10;
 204
 205 typedef struct
 206 {
 207   unsigned nGroups;
 208   OTF_cmapGroup *Groups;
 209 } OTF_EncodingSubtable12;
 210
 211 typedef struct
 212 {
 213   unsigned format;
 214   unsigned length;
 215   unsigned language;
 216   union {
 217     OTF_EncodingSubtable0 *f0;
 218     OTF_EncodingSubtable2 *f2;
 219     OTF_EncodingSubtable4 *f4;
 220     OTF_EncodingSubtable6 *f6;
 221     OTF_EncodingSubtable8 *f8;
 222     OTF_EncodingSubtable10 *f10;
 223     OTF_EncodingSubtable12 *f12;
 224   }f;
 225 } OTF_EncodingSubtable;
 226
 227 typedef struct
 228 {
 229   unsigned platformID;
 230   unsigned encodingID;
 231   unsigned offset;
 232   OTF_EncodingSubtable subtable;
 233 } OTF_EncodingRecord;
 234
 235 typedef struct
 236 {
 237   unsigned version;
 238   unsigned numTables;
 239   OTF_EncodingRecord *EncodingRecord;
 240   /* Mapping table: Unicode->GlyphID */
 241   unsigned short *unicode_table;
 242   int max_glyph_id;
 243   /* Mapping table: GlyphID->Unicode */
 244   unsigned short *decode_table;
 245 } OTF_cmap;
 246
 247
 248 /*** (1-5) Structures common to GDEF, GSUB, GPOS */
 249
 250 typedef struct
 251 {
 252   OTF_GlyphID Start;
 253   OTF_GlyphID End;
 254   unsigned StartCoverageIndex;
 255 } OTF_RangeRecord;
 256
 257 typedef struct
 258 {
 259   OTF_Offset offset;
 260   unsigned CoverageFormat;
 261   unsigned Count;
 262   union {
 263     OTF_GlyphID *GlyphArray;
 264     OTF_RangeRecord *RangeRecord;
 265   } table;
 266 } OTF_Coverage;
 267
 268 typedef struct
 269 {
 270   OTF_Offset offset;
 271   unsigned StartSize;
 272   unsigned EndSize;
 273   unsigned DeltaFormat;
 274   char *DeltaValue;
 275 } OTF_DeviceTable;
 276
 277 typedef struct
 278 {
 279   OTF_GlyphID Start;
 280   OTF_GlyphID End;
 281   unsigned Class;
 282 } OTF_ClassRangeRecord;
 283
 284 typedef struct
 285 {
 286   OTF_Offset offset;
 287   unsigned ClassFormat;
 288   union {
 289     struct {
 290       OTF_GlyphID StartGlyph;
 291       unsigned GlyphCount;
 292       unsigned *ClassValueArray;
 293     } f1;
 294     struct {
 295       unsigned ClassRangeCount;
 296       OTF_ClassRangeRecord *ClassRangeRecord;
 297     } f2;
 298   } f;
 299 } OTF_ClassDef;
 300
 301
 302 /*** (1-6) "GDEF" table */
 303
 304 typedef struct
 305 {
 306   OTF_Fixed Version;
 307   OTF_Offset GlyphClassDef;
 308   OTF_Offset AttachList;
 309   OTF_Offset LigCaretList;
 310   OTF_Offset MarkAttachClassDef;
 311 } OTF_GDEFHeader;
 312
 313 enum OTF_GlyphClassDef
 314   {
 315     OTF_GlyphClass0 = 0,
 316     OTF_GlyphClassBase = 1,
 317     OTF_GlyphClassLigature = 2,
 318     OTF_GlyphClassMark = 3,
 319     OTF_GlyphClassComponent = 4
 320   };
 321
 322 typedef struct
 323 {
 324   OTF_Offset offset;
 325   unsigned PointCount;
 326   unsigned *PointIndex;
 327 } OTF_AttachPoint;
 328
 329 typedef struct
 330 {
 331   OTF_Coverage Coverage;
 332   unsigned GlyphCount;
 333   OTF_AttachPoint *AttachPoint;
 334 } OTF_AttachList;
 335
 336 typedef struct
 337 {
 338   OTF_Offset offset;
 339   unsigned CaretValueFormat;    /* 1, 2, or 3 */
 340   union {
 341     union {
 342       int Coordinate;
 343     } f1;
 344     union {
 345       unsigned CaretValuePoint;
 346     } f2;
 347     union {
 348       int Coordinate;
 349       OTF_DeviceTable DeviceTable;
 350     } f3;
 351   } f;
 352 } OTF_CaretValue;
 353
 354 typedef struct
 355 {
 356   OTF_Offset offset;
 357   unsigned CaretCount;
 358   OTF_CaretValue *CaretValue;
 359 } OTF_LigGlyph;
 360
 361 typedef struct
 362 {
 363   OTF_Coverage Coverage;
 364   unsigned LigGlyphCount;
 365   OTF_LigGlyph *LigGlyph;
 366 } OTF_LigCaretList;
 367
 368 typedef struct
 369 {
 370   OTF_GDEFHeader header;
 371   OTF_ClassDef glyph_class_def;
 372   OTF_AttachList attach_list;
 373   OTF_LigCaretList lig_caret_list;
 374   OTF_ClassDef mark_attach_class_def;
 375 } OTF_GDEF;
 376
 377
 378 /*** (1-7) Structures for ScriptList, FeatureList, and LookupList  */
 379
 380 /*** The structure hierarchy
 381
 382    ScriptList
 383      ScriptRecord[]
 384        ScriptTag
 385      Script[]
 386        DefaultLangSys
 387        LangSysRecord[]
 388          LangSysTag
 389        LangSys[]
 390          LookupOrder
 391          ReqFeatureIndex
 392          FeatureIndex[]
 393
 394   FeatureList
 395     FeatureRecored[]
 396       FeatureTag
 397     Feature[]
 398       FeatureParams
 399       LookupListIndex[]
 400
 401   LookupList
 402     LookupOffset[]
 403     Lookup[]
 404       LookupType
 405       LookupFlag
 406       SubTableOffset[]
 407       SubTable.gsub[] or SubTable.gpos[]
 408 */
 409
 410
 411 typedef struct
 412 {
 413   OTF_Offset LookupOrder;
 414   unsigned ReqFeatureIndex;
 415   unsigned FeatureCount;
 416   unsigned *FeatureIndex;
 417 } OTF_LangSys;
 418
 419 typedef struct
 420 {
 421   OTF_Tag LangSysTag;
 422   OTF_Offset LangSys;
 423 } OTF_LangSysRecord;
 424
 425 typedef struct
 426 {
 427   OTF_Tag ScriptTag;
 428   OTF_Offset offset;
 429   OTF_Offset DefaultLangSysOffset;
 430   OTF_LangSys DefaultLangSys;
 431   unsigned LangSysCount;
 432   OTF_LangSysRecord *LangSysRecord;
 433   OTF_LangSys *LangSys;
 434 } OTF_Script;
 435
 436 typedef struct
 437 {
 438   OTF_Offset offset;
 439   unsigned ScriptCount;
 440   OTF_Script *Script;
 441 } OTF_ScriptList;
 442
 443 typedef struct
 444 {
 445   OTF_Tag FeatureTag;
 446   OTF_Offset offset;
 447   OTF_Offset FeatureParams;
 448   unsigned LookupCount;
 449   unsigned *LookupListIndex;
 450 } OTF_Feature;
 451
 452 typedef struct
 453 {
 454   OTF_Offset offset;
 455   unsigned FeatureCount;
 456   OTF_Feature *Feature;
 457 } OTF_FeatureList;
 458
 459 typedef struct OTF_LookupSubTableGSUB OTF_LookupSubTableGSUB;
 460 typedef struct OTF_LookupSubTableGPOS OTF_LookupSubTableGPOS;
 461
 462 enum OTF_LookupFlagBit
 463   {
 464     OTF_RightToLeft = 0x0001,
 465     OTF_IgnoreBaseGlyphs = 0x0002,
 466     OTF_IgnoreLigatures = 0x0004,
 467     OTF_IgnoreMarks = 0x0008,
 468     OTF_Reserved = 0x00F0,
 469     OTF_MarkAttachmentType = 0xFF00
 470   };
 471
 472 #define OTF_LookupFlagIgnoreMask \
 473   (OTF_IgnoreBaseGlyphs | OTF_IgnoreLigatures | OTF_IgnoreMarks)
 474
 475 typedef struct
 476 {
 477   OTF_Offset offset;
 478   unsigned LookupType;
 479   unsigned LookupFlag;
 480   unsigned SubTableCount;
 481   OTF_Offset *SubTableOffset;
 482   union {
 483     OTF_LookupSubTableGSUB *gsub;
 484     OTF_LookupSubTableGPOS *gpos;
 485   } SubTable;
 486 } OTF_Lookup;
 487
 488 typedef struct
 489 {
 490   OTF_Offset offset;
 491   unsigned LookupCount;
 492   OTF_Lookup *Lookup;
 493 } OTF_LookupList;
 494
 495
 496 /*** (1-8) Structures common to GSUB and GPOS */
 497
 498 /* For SubstLookupRecord (GSUB) and PosLookupRecord (GPOS).  */
 499
 500 typedef struct
 501 {
 502   unsigned SequenceIndex;
 503   unsigned LookupListIndex;
 504 } OTF_LookupRecord;
 505
 506 typedef struct
 507 {
 508   OTF_Offset offset;
 509   unsigned GlyphCount;
 510   unsigned LookupCount;
 511   OTF_GlyphID *Input;           /* [<GlyphCount> - 1] */
 512   OTF_LookupRecord *LookupRecord; /* [<LookupCount>] */
 513 } OTF_Rule;
 514
 515 typedef struct
 516 {
 517   OTF_Offset offset;
 518   unsigned RuleCount;
 519   OTF_Rule *Rule;               /* [<RuleCount>] */
 520 } OTF_RuleSet;
 521
 522 typedef struct
 523 {
 524   OTF_Offset offset;
 525   unsigned GlyphCount;
 526   unsigned LookupCount;
 527   unsigned *Class;              /* [<GlyphCount> - 1] */
 528   OTF_LookupRecord *LookupRecord; /* [<LookupCount>] */
 529 } OTF_ClassRule;
 530
 531 typedef struct
 532 {
 533   OTF_Offset offset;
 534   unsigned ClassRuleCnt;
 535   OTF_ClassRule *ClassRule;     /* [<ClassRuleCnt>] */
 536 } OTF_ClassSet;
 537
 538 typedef struct
 539 {
 540   OTF_Offset offset;
 541   unsigned BacktrackGlyphCount;
 542   OTF_GlyphID *Backtrack;
 543   unsigned InputGlyphCount;
 544   OTF_GlyphID *Input;
 545   unsigned LookaheadGlyphCount;
 546   OTF_GlyphID *LookAhead;
 547   unsigned LookupCount;
 548   OTF_LookupRecord *LookupRecord;
 549 } OTF_ChainRule;
 550
 551 typedef struct
 552 {
 553   OTF_Offset offset;
 554   unsigned ChainRuleCount;
 555   OTF_ChainRule *ChainRule;
 556 } OTF_ChainRuleSet;
 557
 558 typedef struct
 559 {
 560   OTF_Offset offset;
 561   unsigned BacktrackGlyphCount;
 562   unsigned *Backtrack;
 563   unsigned InputGlyphCount;
 564   unsigned *Input;
 565   unsigned LookaheadGlyphCount;
 566   unsigned *LookAhead;
 567   unsigned LookupCount;
 568   OTF_LookupRecord *LookupRecord;
 569 } OTF_ChainClassRule;
 570
 571 typedef struct
 572 {
 573   OTF_Offset offset;
 574   unsigned ChainClassRuleCnt;
 575   OTF_ChainClassRule *ChainClassRule;
 576 } OTF_ChainClassSet;
 577
 578
 579 /* Common to OTF_GSUB/GPOS_Context1/2/3.  */
 580
 581 typedef struct
 582 {
 583   unsigned RuleSetCount;
 584   OTF_RuleSet *RuleSet;         /* [<RuleSetCount>] */
 585 } OTF_Context1;
 586
 587 typedef struct
 588 {
 589   OTF_ClassDef ClassDef;
 590   unsigned ClassSetCnt;
 591   OTF_ClassSet *ClassSet;       /* [<ClassSetCnt>] */
 592 } OTF_Context2;
 593
 594 typedef struct
 595 {
 596   unsigned GlyphCount;
 597   unsigned LookupCount;
 598   OTF_Coverage *Coverage;       /* [<GlyphCount>] */
 599   OTF_LookupRecord *LookupRecord; /* [<LookupCount>] */
 600 } OTF_Context3;
 601
 602
 603 /* Common to OTF_GSUB/GPOS_ChainContext1/2/3.  */
 604
 605 typedef struct
 606 {
 607   unsigned ChainRuleSetCount;
 608   OTF_ChainRuleSet *ChainRuleSet;
 609 } OTF_ChainContext1;
 610
 611 typedef struct
 612 {
 613   OTF_ClassDef BacktrackClassDef;
 614   OTF_ClassDef InputClassDef;
 615   OTF_ClassDef LookaheadClassDef;
 616   unsigned ChainClassSetCnt;
 617   OTF_ChainClassSet *ChainClassSet;
 618 } OTF_ChainContext2;
 619
 620 typedef struct
 621 {
 622   unsigned BacktrackGlyphCount;
 623   OTF_Coverage *Backtrack;
 624   unsigned InputGlyphCount;
 625   OTF_Coverage *Input;
 626   unsigned LookaheadGlyphCount;
 627   OTF_Coverage *LookAhead;
 628   unsigned LookupCount;
 629   OTF_LookupRecord *LookupRecord;
 630 } OTF_ChainContext3;
 631
 632 /* Common to OTF_GSUB/GPOS.  */
 633
 634 typedef struct
 635 {
 636   OTF_Fixed Version;
 637   OTF_ScriptList ScriptList;
 638   OTF_FeatureList FeatureList;
 639   OTF_LookupList LookupList;
 640 } OTF_GSUB_GPOS;
 641
 642 /*** (1-9) "GSUB" table */
 643
 644 typedef struct
 645 {
 646   int DeltaGlyphID;
 647 } OTF_GSUB_Single1;
 648
 649 typedef struct
 650 {
 651   unsigned GlyphCount;
 652   OTF_GlyphID *Substitute;
 653 } OTF_GSUB_Single2;
 654
 655 typedef struct OTF_Sequence OTF_Sequence;
 656
 657 typedef struct
 658 {
 659   unsigned SequenceCount;
 660   OTF_Sequence *Sequence;
 661 } OTF_GSUB_Multiple1;
 662
 663 struct OTF_Sequence
 664 {
 665   OTF_Offset offset;
 666   unsigned GlyphCount;
 667   OTF_GlyphID *Substitute;
 668 };
 669
 670 typedef struct OTF_AlternateSet OTF_AlternateSet;
 671
 672 typedef struct
 673 {
 674   unsigned AlternateSetCount;
 675   OTF_AlternateSet *AlternateSet;
 676 } OTF_GSUB_Alternate1;
 677
 678 struct OTF_AlternateSet
 679 {
 680   OTF_Offset offset;
 681   unsigned GlyphCount;
 682   OTF_GlyphID *Alternate;
 683 };
 684
 685 typedef struct OTF_LigatureSet OTF_LigatureSet;
 686 typedef struct OTF_Ligature OTF_Ligature;
 687
 688 typedef struct
 689 {
 690   unsigned LigSetCount;
 691   OTF_LigatureSet *LigatureSet;
 692 } OTF_GSUB_Ligature1;
 693
 694 struct OTF_LigatureSet
 695 {
 696   OTF_Offset offset;
 697   unsigned LigatureCount;
 698   OTF_Ligature *Ligature;
 699 };
 700
 701 struct OTF_Ligature
 702 {
 703   OTF_Offset offset;
 704   OTF_GlyphID LigGlyph;
 705   unsigned CompCount;
 706   OTF_GlyphID *Component;
 707 };
 708
 709 typedef OTF_Context1 OTF_GSUB_Context1;
 710
 711 typedef OTF_Context2 OTF_GSUB_Context2;
 712
 713 typedef OTF_Context3 OTF_GSUB_Context3;
 714
 715 typedef OTF_ChainContext1 OTF_GSUB_ChainContext1;
 716
 717 typedef OTF_ChainContext2 OTF_GSUB_ChainContext2;
 718
 719 typedef OTF_ChainContext3 OTF_GSUB_ChainContext3;
 720
 721 typedef struct
 722 {
 723   unsigned ExtensionLookupType;
 724   unsigned ExtensionOffset;
 725   OTF_LookupSubTableGSUB *ExtensionSubtable;
 726 } OTF_GSUB_Extension1;
 727
 728 typedef struct
 729 {
 730   unsigned BacktrackGlyphCount;
 731   OTF_Coverage *Backtrack;
 732   unsigned LookaheadGlyphCount;
 733   OTF_Coverage *LookAhead;
 734   unsigned GlyphCount;
 735   OTF_GlyphID *Substitute;
 736 } OTF_GSUB_ReverseChain1;
 737
 738 struct OTF_LookupSubTableGSUB
 739 {
 740   unsigned Format;
 741   OTF_Coverage Coverage;
 742   union {
 743     /* LookupType 1 */
 744     OTF_GSUB_Single1 single1;
 745     OTF_GSUB_Single2 single2;
 746     /* LookupType 2 */
 747     OTF_GSUB_Multiple1 multiple1;
 748     /* LookupType 3 */
 749     OTF_GSUB_Alternate1 alternate1;
 750     /* LookupType 4 */
 751     OTF_GSUB_Ligature1 ligature1;
 752     /* LookupType 5 */
 753     OTF_GSUB_Context1 context1;
 754     OTF_GSUB_Context2 context2;
 755     OTF_GSUB_Context3 context3;
 756     /* LookupType 6 */
 757     OTF_GSUB_ChainContext1 chain_context1;
 758     OTF_GSUB_ChainContext2 chain_context2;
 759     OTF_GSUB_ChainContext3 chain_context3;
 760     /* LookupType 7 */
 761     OTF_GSUB_Extension1 extension1;
 762     /* LookupType 8 */
 763     OTF_GSUB_ReverseChain1 reverse_chain1;
 764   } u;
 765 };
 766
 767 typedef OTF_GSUB_GPOS OTF_GSUB;
 768
 769 /*** (1-10) "GPOS" table */
 770
 771 enum OTF_ValueFormat
 772   {
 773     OTF_XPlacement = 0x0001,
 774     OTF_YPlacement = 0x0002,
 775     OTF_XAdvance = 0x0004,
 776     OTF_YAdvance = 0x0008,
 777     OTF_XPlaDevice = 0x0010,
 778     OTF_YPlaDevice = 0x0020,
 779     OTF_XAdvDevice = 0x0040,
 780     OTF_YAdvDevice = 0x0080
 781   };
 782
 783 typedef struct
 784 {
 785   int XPlacement;
 786   int YPlacement;
 787   int XAdvance;
 788   int YAdvance;
 789   OTF_DeviceTable XPlaDevice;
 790   OTF_DeviceTable YPlaDevice;
 791   OTF_DeviceTable XAdvDevice;
 792   OTF_DeviceTable YAdvDevice;
 793 } OTF_ValueRecord;
 794
 795 typedef struct
 796 {
 797   OTF_Offset offset;
 798   unsigned AnchorFormat;
 799   int XCoordinate;
 800   int YCoordinate;
 801   union {
 802     union {
 803       unsigned AnchorPoint;
 804     } f1;
 805     union {
 806       OTF_DeviceTable XDeviceTable;
 807       OTF_DeviceTable YDeviceTable;
 808     } f2;
 809   } f;
 810 } OTF_Anchor;
 811
 812 typedef struct
 813 {
 814   unsigned Class;
 815   OTF_Anchor MarkAnchor;
 816 } OTF_MarkRecord;
 817
 818 typedef struct
 819 {
 820   OTF_Offset offset;
 821   unsigned MarkCount;
 822   OTF_MarkRecord *MarkRecord;
 823 } OTF_MarkArray;
 824
 825 typedef struct
 826 {
 827   unsigned ValueFormat;
 828   OTF_ValueRecord Value;
 829 } OTF_GPOS_Single1;
 830
 831 typedef struct
 832 {
 833   unsigned ValueFormat;
 834   unsigned ValueCount;
 835   OTF_ValueRecord *Value;       /* [<ValueCount>] */
 836 } OTF_GPOS_Single2;
 837
 838 typedef struct
 839 {
 840   OTF_GlyphID SecondGlyph;
 841   OTF_ValueRecord Value1;
 842   OTF_ValueRecord Value2;
 843 } OTF_PairValueRecord;
 844
 845 typedef struct
 846 {
 847   OTF_Offset offset;
 848   unsigned PairValueCount;
 849   OTF_PairValueRecord *PairValueRecord;
 850 } OTF_PairSet;
 851
 852 typedef struct
 853 {
 854   unsigned ValueFormat1;
 855   unsigned ValueFormat2;
 856   unsigned PairSetCount;
 857   OTF_PairSet *PairSet;
 858 } OTF_GPOS_Pair1;
 859
 860 typedef struct
 861 {
 862   OTF_ValueRecord Value1;
 863   OTF_ValueRecord Value2;
 864 } OTF_Class2Record;
 865
 866 typedef struct
 867 {
 868   OTF_Class2Record *Class2Record;
 869 } OTF_Class1Record;
 870
 871 typedef struct
 872 {
 873   unsigned ValueFormat1;
 874   unsigned ValueFormat2;
 875   OTF_ClassDef ClassDef1;
 876   OTF_ClassDef ClassDef2;
 877   unsigned Class1Count;
 878   unsigned Class2Count;
 879   OTF_Class1Record *Class1Record; /* size: <Class1Count> */
 880 } OTF_GPOS_Pair2;
 881
 882 typedef struct
 883 {
 884   OTF_Anchor EntryAnchor;
 885   OTF_Anchor ExitAnchor;
 886 } OTF_EntryExitRecord;
 887
 888 typedef struct
 889 {
 890   unsigned EntryExitCount;
 891   OTF_EntryExitRecord *EntryExitRecord;
 892 } OTF_GPOS_Cursive1;
 893
 894 typedef struct
 895 {
 896   OTF_Anchor *Anchor;
 897 } OTF_AnchorRecord;
 898
 899 typedef struct
 900 {
 901   OTF_Offset offset;
 902   unsigned Count;
 903   OTF_AnchorRecord *AnchorRecord;
 904 } OTF_AnchorArray;
 905
 906 typedef struct
 907 {
 908   OTF_Coverage BaseCoverage;
 909   unsigned ClassCount;
 910   OTF_MarkArray MarkArray;
 911   OTF_AnchorArray BaseArray;
 912 } OTF_GPOS_MarkBase1;
 913
 914 typedef struct
 915 {
 916   OTF_Anchor *LigatureAnchor; /* [<ClassCount>] */
 917 } OTF_ComponentRecord;
 918
 919 typedef struct
 920 {
 921   OTF_Offset offset;
 922   unsigned ComponentCount;
 923   OTF_ComponentRecord *ComponentRecord; /* [<ComponentCount>] */
 924 } OTF_LigatureAttach;
 925
 926 typedef struct
 927 {
 928   OTF_Offset offset;
 929   unsigned LigatureCount;
 930   OTF_LigatureAttach *LigatureAttach; /* [<LiagureCount>] */
 931 } OTF_LigatureArray;
 932
 933 typedef struct
 934 {
 935   OTF_Coverage LigatureCoverage;
 936   unsigned ClassCount;
 937   OTF_MarkArray MarkArray;
 938   OTF_LigatureArray LigatureArray;
 939 } OTF_GPOS_MarkLig1;
 940
 941 typedef struct
 942 {
 943   OTF_Coverage Mark2Coverage;
 944   unsigned ClassCount;
 945   OTF_MarkArray Mark1Array;
 946   OTF_AnchorArray Mark2Array;
 947 } OTF_GPOS_MarkMark1;
 948
 949 typedef OTF_Context1 OTF_GPOS_Context1;
 950
 951 typedef OTF_Context2 OTF_GPOS_Context2;
 952
 953 typedef OTF_Context3 OTF_GPOS_Context3;
 954
 955 typedef OTF_ChainContext1 OTF_GPOS_ChainContext1;
 956
 957 typedef OTF_ChainContext2 OTF_GPOS_ChainContext2;
 958
 959 typedef OTF_ChainContext3 OTF_GPOS_ChainContext3;
 960
 961 typedef struct
 962 {
 963   unsigned ExtensionLookupType;
 964   unsigned ExtensionOffset;
 965   OTF_LookupSubTableGPOS *ExtensionSubtable;
 966 } OTF_GPOS_Extension1;
 967
 968
 969 struct OTF_LookupSubTableGPOS
 970 {
 971   unsigned Format;
 972   OTF_Coverage Coverage;
 973   union {
 974     /* LookupType 1 */
 975     OTF_GPOS_Single1 single1;
 976     OTF_GPOS_Single2 single2;
 977     /* LookupType 2 */
 978     OTF_GPOS_Pair1 pair1;
 979     OTF_GPOS_Pair2 pair2;
 980     /* LookupType 3 */
 981     OTF_GPOS_Cursive1 cursive1;
 982     /* LookupType 4 */
 983     OTF_GPOS_MarkBase1 mark_base1;
 984     /* LookupType 5 */
 985     OTF_GPOS_MarkLig1 mark_lig1;
 986     /* LookupType 6 */
 987     OTF_GPOS_MarkMark1 mark_mark1;
 988     /* LookupType 7 */
 989     OTF_GPOS_Context1 context1;
 990     OTF_GPOS_Context2 context2;
 991     OTF_GPOS_Context3 context3;
 992     /* LookupType 8 */
 993     OTF_GPOS_ChainContext1 chain_context1;
 994     OTF_GPOS_ChainContext2 chain_context2;
 995     OTF_GPOS_ChainContext3 chain_context3;
 996     /* LookupType 9 */
 997     OTF_GPOS_Extension1 extension1;
 998   } u;
 999 };
1000
1001 typedef OTF_GSUB_GPOS OTF_GPOS;
1002
1003 /*** (1-11) Structure for OTF */
1004
1005 typedef struct
1006 {
1007   OTF_Fixed sfnt_version;
1008   unsigned numTables;
1009   unsigned searchRange;
1010   unsigned enterSelector;
1011   unsigned rangeShift;
1012 } OTF_OffsetTable;
1013
1014 typedef struct
1015 {
1016   OTF_Tag tag;
1017   char name[5];
1018   unsigned checkSum;
1019   unsigned offset;
1020   unsigned length;
1021 } OTF_TableDirectory;
1022
1023 typedef struct OTF_InternalData  OTF_InternalData;
1024
1025 typedef struct
1026 {
1027   char *filename;
1028   OTF_OffsetTable offset_table;
1029   OTF_TableDirectory *table_dirs;
1030   OTF_head *head;
1031   OTF_name *name;
1032   OTF_cmap *cmap;
1033   OTF_GDEF *gdef;
1034   OTF_GSUB *gsub;
1035   OTF_GPOS *gpos;
1036   /* The following tables are not yet supported.  */
1037   /* OTF_BASE *base; */
1038   /* OTF_JSTF *jstf; */
1039   OTF_InternalData *internal_data;
1040 } OTF;
1041
1042 \f
1043 /*** (2) API for reading OTF */
1044
1045 /*** (2-1) otf_open () */
1046
1047 /***
1048     Open OpenType font
1049
1050     The OTF_open() function reads the OpenType font file whose name is
1051     $NAME, and return a pointer to the structure of type OTF.
1052
1053     It setups these member of the structure OTF:
1054         filename, offset_table, table_dirs
1055
1056     If the file can't be read or the file contains invalid data, NULL
1057     is returned, and the variable OTF_error is set to one of the
1058     following values.
1059
1060         OTF_ERROR_MEMORY
1061         OTF_ERROR_FILE
1062         OTF_ERROR_TABLE
1063
1064     See also OTF_get_table() and OTF_close().  */
1065
1066 extern OTF *OTF_open (char *name);
1067
1068
1069 /*** (2-2) OTF_close () */
1070
1071 /***
1072     Close OpenType font
1073
1074     The OTF_close() function closes the OpenType font $OTF which must
1075     be what the OTF_open() function returned.
1076
1077     See also OTF_open().  */
1078
1079 extern void OTF_close (OTF *otf);
1080
1081
1082 /*** (2-3) OTF_get_table () */
1083
1084 /***
1085     Get OpenType font table
1086
1087     The OTF_get_table() function setups one of the OTF table specified
1088     by $NAME in the OpenType font $OTF.
1089
1090     $NAME must be one of "head", "name", "cmap", "GDEF", "GSUB", and
1091     "GPOS", and a member of the same name is setup.
1092
1093     If the table is successfully setup, return 0.  Otherwise, return
1094     -1, and set the variable OTF_error to OTF_ERROR_TABLE.
1095
1096     See also OTF_open().  */
1097
1098 extern int OTF_get_table (OTF *otf, char *name);
1099
1100 /*** (2-4) OTF_check_table () */
1101
1102 /***
1103     Check the existence of OpenType font table
1104
1105     The OTF_check_table() function checks if the the OTF table
1106     specified by $NAME exists in OpenType font $OTF.
1107
1108     If the table exists, return 0, else return -1.
1109
1110     See also OTF_open().  */
1111
1112 extern int OTF_check_table (OTF *otf, char *name);
1113
1114 /*** (2-5) OTF_get_scripts () */
1115
1116 /***
1117     Get supported scripts.
1118
1119     The OTF_get_scripts() function setups OTF_ScriptList of GSUB (if
1120     $GSUBP is nonzero) or GPOS (if $GSUBP is zero) table of the
1121     OpenType font $OTF.
1122
1123     If the table is successfully setup, return 0.  Otherwise, retrun
1124     -1, and set the variable OTF_error to OTF_ERROR_TABLE.  */
1125
1126 extern int OTF_get_scripts (OTF *otf, int gsubp);
1127
1128 /*** (2-6) OTF_get_features () */
1129
1130 /***
1131     Get supported features.
1132
1133     The OTF_get_features() function setups OTF_FeatureList of GSUB (if
1134     $GSUBP is nonzero) or GPOS (if $GSUBP is zero) table of the
1135     OpenType font $OTF.
1136
1137     If the table is successfully setup, return 0.  Otherwise, retrun
1138     -1, and set the variable OTF_error to OTF_ERROR_TABLE.  */
1139
1140 extern int OTF_get_features (OTF *otf, int gsubp);
1141
1142 /*** (2-7) OTF_check_features  */
1143
1144 /***
1145     Check supported features.
1146
1147     The OTF_check_features() function checks if or not the OpenType
1148     font $OTF has, for $SCRIPT and $LANGUAGE, all features in the
1149     array $FEATURES.  The array size is $N_FEATURES.  If $LANGUAGE is
1150     zero or $OTF doesn't have LangSys for $SCRIPT, the default LangSys
1151     is checked.
1152
1153     If $OTF has all the features, return 1.  Otherwise, return 0.  If
1154     an error occurs, return -1, and set the variable OTF_error to
1155     OTF_ERROR_TABLE.   */
1156
1157 extern int OTF_check_features (OTF *otf, int gsubp,
1158                                OTF_Tag script, OTF_Tag language,
1159                                OTF_Tag *features, int n_features);
1160
1161 /*** (3) API for driving OTF */
1162
1163 /*** (3-1) Structure for glyph string */
1164
1165 /***
1166     The structure OTF_Glyph contains information about each glyph in
1167     the structure OTF_GlyphString.  */
1168
1169 typedef struct
1170 {
1171   /** The first two members must be set by a clinet before calling the
1172       function OTF_drive_XXX().  **/
1173
1174   /* Character code of the glyph.  The value less than 32 is treated
1175      as a place-holder in a glyph string, and OTF_drive_XXX ()
1176      function just ignore the glyph as if it doesn't exist.  */
1177   int c;
1178
1179   /* Glyph ID of the glyph.  If the value is 0, the library gets a
1180      correct value from the above character code via cmap.  */
1181   OTF_GlyphID glyph_id;
1182
1183   /* GlyphClass of the glyph.  The value is extracted from the GDEF
1184      table.  */
1185   enum OTF_GlyphClassDef GlyphClass;
1186
1187   /* MarkAttachClassDef of the glyph.  The value is extracted from the
1188      GDEF table.  */
1189   unsigned MarkAttachClass;
1190
1191   /* Positioning format type of the glyph.  The value specifies how
1192      the glyph positioning information is encoded in the member <f>.
1193      If the value is N, the union member fN, is used.  If the value is
1194      zero, the glyph has no positioning information, i.e. it should be
1195      drawn at the normal position.  */
1196   int positioning_type;
1197   union {
1198     struct {
1199       int from, to;
1200     } index;
1201     struct {
1202       enum OTF_ValueFormat format;
1203       OTF_ValueRecord *value;
1204     } f1;
1205     struct {
1206       enum OTF_ValueFormat format;
1207       OTF_ValueRecord *value;
1208     } f2;
1209     struct {
1210       OTF_Anchor *entry_anchor;
1211       OTF_Anchor *exit_anchor;
1212     } f3;
1213     struct {
1214       OTF_Anchor *mark_anchor;
1215       OTF_Anchor *base_anchor;
1216     } f4;
1217     struct {
1218       OTF_Anchor *mark_anchor;
1219       OTF_Anchor *ligature_anchor;
1220     } f5;
1221     struct {
1222       OTF_Anchor *mark1_anchor;
1223       OTF_Anchor *mark2_anchor;
1224     } f6;
1225   } f;
1226 } OTF_Glyph;
1227
1228 /***
1229     The structure OTF_GlyphString contains an array of glyphs (type
1230     OTF_Glyph).  It is used as arguments of otf_drive_XXX().  */
1231
1232 typedef struct
1233 {
1234   /* How many glyphs are allocated at the memory pointed by the member
1235       <glyphs>.  */
1236   int size;
1237   /* How many glyphs contain valid information.  */
1238   int used;
1239   /* Array of glyphs.  It must be allocated by malloc().  The
1240      functions otf_drive_XXX() may reallocate it and increase the
1241      members <size> and <used>.  */
1242   OTF_Glyph *glyphs;
1243 } OTF_GlyphString;
1244
1245
1246 /*** (3-2) OTF_drive_cmap() */
1247
1248 /***
1249     Process glyph string by Unicode-based cmap table.
1250
1251     The OTF_drive_cmap() function looks up a Unicode-based cmap table
1252     of OpenType font $OTF, and setup the member <glyhph_id> of all
1253     glhphs in the glyph string $GSTRING if the value of the member is
1254     not zero.  */
1255
1256 extern int OTF_drive_cmap (OTF *otf, OTF_GlyphString *gstring);
1257
1258 /***
1259     Process glyph string by a specific cmap table.
1260
1261     The OTF_drive_cmap2() function looks up a cmap table (whose
1262     Platform-ID is $PLATFORM_ID an Encoding-ID is $ENCODING_ID) of
1263     OpenType font $OTF, and setup the member <glyhph_id> of all glhphs
1264     in the glyph string $GSTRING if the value of the member is not
1265     zero.  */
1266
1267 extern int OTF_drive_cmap2 (OTF *otf, OTF_GlyphString *gstring,
1268                             int platform_id, int encoding_id);
1269
1270 /*** (3-3) OTF_drive_gdef() */
1271
1272 /***
1273     Process glyph string by GDEF table.
1274
1275     The OTF_drive_gdef() function looks up the GDEF table of OpenType
1276     font $OTF, and setup members <GlyphClass> and <MarkAttachClass> of
1277     all glhphs in the glyph string $GSTRING.  */
1278
1279 extern int OTF_drive_gdef (OTF *otf, OTF_GlyphString *gstring);
1280
1281
1282 /*** (3-4) OTF_drive_gsub() */
1283
1284 /***
1285     Process glyph string by GSUB table.
1286
1287     The OTF_drive_gsub() function looks up the GSUB table of OpenType
1288     font $OTF, and by using features the font has for script $SCRIPT
1289     and language system $LANGSYS, update member <glyphs> of the glyph
1290     string $GSTRING.  It may substitute, delete, insert glyphs in that
1291     array.  $FEATURES is a list of features to apply.  This doesn't
1292     perform a lookup of type 3 (Alternate Substitution).  For that,
1293     use OTF_drive_gsub_alternate().  */
1294
1295 extern int OTF_drive_gsub (OTF *otf, OTF_GlyphString *gstring,
1296                            char *script, char *language, char *features);
1297
1298 /*** (3-5) OTF_drive_gpos() */
1299
1300 /***
1301     Process glyph string by GPOS table.
1302
1303     The OTF_drive_gdef() function looks up the GPOS table of $OTF of
1304     OpenType font $OTF, and by using features the font has for script
1305     $SCRIPT and language system $LANGSYS, setup members
1306     <positioning_type> and <f> of all glhphs in the glyph string
1307     $GSTRING.  $FEATURES is a list of features to apply.  */
1308
1309 extern int OTF_drive_gpos (OTF *otf, OTF_GlyphString *gstring,
1310                            char *script, char *language, char *features);
1311
1312 /*** (3-6) OTF_drive_tables() */
1313
1314 /***
1315     Process glyph string by cmap, GDEF, GSUB, and GPOS tables.
1316
1317     The OTF_drive_tables() function calls OTF_drive_cmap(),
1318     OTF_drive_gdef(), OTF_drive_gsub(), and OTF_drive_gpos() in this
1319     order, and update the glyphs string GSTRING.  */
1320
1321 extern int OTF_drive_tables (OTF *otf, OTF_GlyphString *gstring,
1322                              char *script, char *language,
1323                              char *gsub_features, char *gpos_features);
1324
1325
1326 /*** (3-7) OTF_get_unicode()  */
1327
1328 /***
1329     Return Unicode code point corresponding to the glyph-id CODE.
1330   */
1331
1332 extern int OTF_get_unicode (OTF *otf, OTF_GlyphID code);
1333
1334 /*** (3-8) OTF_drive_gsub_alternate() */
1335
1336 /***
1337     Find alternate glyphs.
1338
1339     This is like OTF_drive_gsub(), but perform only a lookup of type 3
1340     (Alternate Substituion).  */
1341
1342 extern int OTF_drive_gsub_alternate (OTF *otf, OTF_GlyphString *gstring,
1343                                      char *script, char *language,
1344                                      char *features);
1345
1346 /*** (4) API for error handling ***/
1347
1348 /*** (4-1) Error codes ***/
1349
1350 /***
1351     Global variable holding an error code.
1352
1353     The variable OTF_error is set to one of OTF_ERROR_XXX macros when
1354     an error is detected in the OTF library.  */
1355 extern int OTF_error;
1356
1357 /***
1358     Memory allocation error
1359
1360     This error indicates that the library couldn't allocate
1361     memory.  */
1362 #define OTF_ERROR_MEMORY        1
1363
1364 /***
1365     File error
1366
1367     This error indicates that the library fails in opening, reading,
1368     or seeking an OTF file.  */
1369 #define OTF_ERROR_FILE          2
1370
1371 /***
1372     Invalid table contents
1373
1374     This error indicates that an OTF file contains invalid data.  */
1375 #define OTF_ERROR_TABLE         3
1376
1377 /***
1378     CMAP driving error
1379
1380     See the function otf_drive_cmap() for more detail.  */
1381 #define OTF_ERROR_CMAP_DRIVE    4
1382
1383 /***
1384     GDEF driving error
1385
1386     See the function OTF_drive_gdef() for more detail.  */
1387 #define OTF_ERROR_GDEF_DRIVE    5
1388
1389 /***
1390     GSUB driving error
1391
1392     See the function OTF_drive_gsub() for more detail.  */
1393 #define OTF_ERROR_GSUB_DRIVE    6
1394
1395 /***
1396     GPOS driving error
1397
1398     See the function OTF_drive_gpos() for more detail.  */
1399 #define OTF_ERROR_GPOS_DRIVE    7
1400
1401
1402 /*** (4-2) OTF_perror() */
1403
1404 /***
1405     Print an OTF error message
1406
1407     The OTF_perror() function produces a message on the standard error
1408     output, describing the last error encountered during a call to the
1409     OTF library function.  If $PREFIX is not NULL, it is printed
1410     first, followed by a colon and a blank.  Then the message and a
1411     newline.  */
1412
1413 extern void OTF_perror (char *prefix);
1414
1415
1416 /*** (5) API miscellaneous ***/
1417
1418 /***
1419     Return OTF tag of a specified name string.
1420
1421     The OTF_tag() function returns OTF tag of name $NAME.  If $NAME is
1422     NULL, return 0.  Otherwise, $NAME must be at least 4-byte length.
1423     Only the first 4 characters are took into an account.  */
1424
1425 extern OTF_Tag OTF_tag (char *name);
1426
1427 /***
1428     Convert OTF tag to name string.
1429
1430     The OTF_tag_name() function converts OTF tag $TAG to a 5-byte name
1431     string (including the terminating NULL), and store it in $NAME.
1432     At least 5-byte space must be at $NAME.  */
1433
1434 extern void OTF_tag_name (OTF_Tag tag, char *name);
1435
1436
1437 #endif /* not _OTF_H_ */