?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Load .so builtin modules without using libwine.
[wine/zf.git] / dlls / dwrite / opentype.c
blob9813676ab0a4ace15fa31fc101058ea8ef700c15
1 /*
2 * Methods for dealing with opentype font tables
3 *
4 * Copyright 2014 Aric Stewart for CodeWeavers
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 #define COBJMACROS
22 #define NONAMELESSUNION
23
24 #include "dwrite_private.h"
25 #include "winternl.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(dwrite);
28
29 #define MS_HEAD_TAG DWRITE_MAKE_OPENTYPE_TAG('h','e','a','d')
30 #define MS_HHEA_TAG DWRITE_MAKE_OPENTYPE_TAG('h','h','e','a')
31 #define MS_OTTO_TAG DWRITE_MAKE_OPENTYPE_TAG('O','T','T','O')
32 #define MS_OS2_TAG DWRITE_MAKE_OPENTYPE_TAG('O','S','/','2')
33 #define MS_POST_TAG DWRITE_MAKE_OPENTYPE_TAG('p','o','s','t')
34 #define MS_TTCF_TAG DWRITE_MAKE_OPENTYPE_TAG('t','t','c','f')
35 #define MS_GDEF_TAG DWRITE_MAKE_OPENTYPE_TAG('G','D','E','F')
36 #define MS_GPOS_TAG DWRITE_MAKE_OPENTYPE_TAG('G','P','O','S')
37 #define MS_GSUB_TAG DWRITE_MAKE_OPENTYPE_TAG('G','S','U','B')
38 #define MS_NAME_TAG DWRITE_MAKE_OPENTYPE_TAG('n','a','m','e')
39 #define MS_GLYF_TAG DWRITE_MAKE_OPENTYPE_TAG('g','l','y','f')
40 #define MS_CFF__TAG DWRITE_MAKE_OPENTYPE_TAG('C','F','F',' ')
41 #define MS_CFF2_TAG DWRITE_MAKE_OPENTYPE_TAG('C','F','F','2')
42 #define MS_CPAL_TAG DWRITE_MAKE_OPENTYPE_TAG('C','P','A','L')
43 #define MS_COLR_TAG DWRITE_MAKE_OPENTYPE_TAG('C','O','L','R')
44 #define MS_SVG__TAG DWRITE_MAKE_OPENTYPE_TAG('S','V','G',' ')
45 #define MS_SBIX_TAG DWRITE_MAKE_OPENTYPE_TAG('s','b','i','x')
46 #define MS_MAXP_TAG DWRITE_MAKE_OPENTYPE_TAG('m','a','x','p')
47 #define MS_CBLC_TAG DWRITE_MAKE_OPENTYPE_TAG('C','B','L','C')
48 #define MS_CMAP_TAG DWRITE_MAKE_OPENTYPE_TAG('c','m','a','p')
49 #define MS_META_TAG DWRITE_MAKE_OPENTYPE_TAG('m','e','t','a')
50
51 /* 'sbix' formats */
52 #define MS_PNG__TAG DWRITE_MAKE_OPENTYPE_TAG('p','n','g',' ')
53 #define MS_JPG__TAG DWRITE_MAKE_OPENTYPE_TAG('j','p','g',' ')
54 #define MS_TIFF_TAG DWRITE_MAKE_OPENTYPE_TAG('t','i','f','f')
55
56 #define MS_WOFF_TAG DWRITE_MAKE_OPENTYPE_TAG('w','O','F','F')
57 #define MS_WOF2_TAG DWRITE_MAKE_OPENTYPE_TAG('w','O','F','2')
58
59 /* 'meta' tags */
60 #define MS_DLNG_TAG DWRITE_MAKE_OPENTYPE_TAG('d','l','n','g')
61 #define MS_SLNG_TAG DWRITE_MAKE_OPENTYPE_TAG('s','l','n','g')
62
63 #ifdef WORDS_BIGENDIAN
64 #define GET_BE_WORD(x) (x)
65 #define GET_BE_DWORD(x) (x)
66 #else
67 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
68 #define GET_BE_DWORD(x) RtlUlongByteSwap(x)
69 #endif
70
71 typedef struct {
72 CHAR TTCTag[4];
73 DWORD Version;
74 DWORD numFonts;
75 DWORD OffsetTable[1];
76 } TTC_Header_V1;
77
78 typedef struct {
79 DWORD version;
80 WORD numTables;
81 WORD searchRange;
82 WORD entrySelector;
83 WORD rangeShift;
84 } TTC_SFNT_V1;
85
86 typedef struct {
87 DWORD tag;
88 DWORD checkSum;
89 DWORD offset;
90 DWORD length;
91 } TT_TableRecord;
92
93 struct cmap_encoding_record
94 {
95 WORD platformID;
96 WORD encodingID;
97 DWORD offset;
98 };
99
100 struct cmap_header
101 {
102 WORD version;
103 WORD num_tables;
104 struct cmap_encoding_record tables[1];
105 } CMAP_Header;
106
107 typedef struct {
108 DWORD startCharCode;
109 DWORD endCharCode;
110 DWORD startGlyphID;
111 } CMAP_SegmentedCoverage_group;
112
113 struct cmap_segmented_coverage
114 {
115 WORD format;
116 WORD reserved;
117 DWORD length;
118 DWORD language;
119 DWORD num_groups;
120 CMAP_SegmentedCoverage_group groups[1];
121 };
122
123 struct cmap_segment_mapping
124 {
125 WORD format;
126 WORD length;
127 WORD language;
128 WORD seg_count_x2;
129 WORD search_range;
130 WORD entry_selector;
131 WORD range_shift;
132 WORD end_code[1];
133 };
134
135 enum OPENTYPE_CMAP_TABLE_FORMAT
136 {
137 OPENTYPE_CMAP_TABLE_SEGMENT_MAPPING = 4,
138 OPENTYPE_CMAP_TABLE_SEGMENTED_COVERAGE = 12
139 };
140
141 enum opentype_cmap_table_platform
142 {
143 OPENTYPE_CMAP_TABLE_PLATFORM_WIN = 3,
144 };
145
146 enum opentype_cmap_table_encoding
147 {
148 OPENTYPE_CMAP_TABLE_ENCODING_SYMBOL = 0,
149 OPENTYPE_CMAP_TABLE_ENCODING_UNICODE_BMP = 1,
150 OPENTYPE_CMAP_TABLE_ENCODING_UNICODE_FULL = 10,
151 };
152
153 /* PANOSE is 10 bytes in size, need to pack the structure properly */
154 #include "pshpack2.h"
155 typedef struct
156 {
157 USHORT majorVersion;
158 USHORT minorVersion;
159 ULONG revision;
160 ULONG checksumadj;
161 ULONG magic;
162 USHORT flags;
163 USHORT unitsPerEm;
164 ULONGLONG created;
165 ULONGLONG modified;
166 SHORT xMin;
167 SHORT yMin;
168 SHORT xMax;
169 SHORT yMax;
170 USHORT macStyle;
171 USHORT lowestRecPPEM;
172 SHORT direction_hint;
173 SHORT index_format;
174 SHORT glyphdata_format;
175 } TT_HEAD;
176
177 enum TT_HEAD_MACSTYLE
178 {
179 TT_HEAD_MACSTYLE_BOLD = 1 << 0,
180 TT_HEAD_MACSTYLE_ITALIC = 1 << 1,
181 TT_HEAD_MACSTYLE_UNDERLINE = 1 << 2,
182 TT_HEAD_MACSTYLE_OUTLINE = 1 << 3,
183 TT_HEAD_MACSTYLE_SHADOW = 1 << 4,
184 TT_HEAD_MACSTYLE_CONDENSED = 1 << 5,
185 TT_HEAD_MACSTYLE_EXTENDED = 1 << 6,
186 };
187
188 typedef struct
189 {
190 ULONG Version;
191 ULONG italicAngle;
192 SHORT underlinePosition;
193 SHORT underlineThickness;
194 ULONG fixed_pitch;
195 ULONG minmemType42;
196 ULONG maxmemType42;
197 ULONG minmemType1;
198 ULONG maxmemType1;
199 } TT_POST;
200
201 typedef struct
202 {
203 USHORT version;
204 SHORT xAvgCharWidth;
205 USHORT usWeightClass;
206 USHORT usWidthClass;
207 SHORT fsType;
208 SHORT ySubscriptXSize;
209 SHORT ySubscriptYSize;
210 SHORT ySubscriptXOffset;
211 SHORT ySubscriptYOffset;
212 SHORT ySuperscriptXSize;
213 SHORT ySuperscriptYSize;
214 SHORT ySuperscriptXOffset;
215 SHORT ySuperscriptYOffset;
216 SHORT yStrikeoutSize;
217 SHORT yStrikeoutPosition;
218 SHORT sFamilyClass;
219 PANOSE panose;
220 ULONG ulUnicodeRange1;
221 ULONG ulUnicodeRange2;
222 ULONG ulUnicodeRange3;
223 ULONG ulUnicodeRange4;
224 CHAR achVendID[4];
225 USHORT fsSelection;
226 USHORT usFirstCharIndex;
227 USHORT usLastCharIndex;
228 /* According to the Apple spec, original version didn't have the below fields,
229 * version numbers were taken from the OpenType spec.
230 */
231 /* version 0 (TrueType 1.5) */
232 USHORT sTypoAscender;
233 USHORT sTypoDescender;
234 USHORT sTypoLineGap;
235 USHORT usWinAscent;
236 USHORT usWinDescent;
237 /* version 1 (TrueType 1.66) */
238 ULONG ulCodePageRange1;
239 ULONG ulCodePageRange2;
240 /* version 2 (OpenType 1.2) */
241 SHORT sxHeight;
242 SHORT sCapHeight;
243 USHORT usDefaultChar;
244 USHORT usBreakChar;
245 USHORT usMaxContext;
246 } TT_OS2_V2;
247
248 typedef struct {
249 USHORT majorVersion;
250 USHORT minorVersion;
251 SHORT ascender;
252 SHORT descender;
253 SHORT linegap;
254 USHORT advanceWidthMax;
255 SHORT minLeftSideBearing;
256 SHORT minRightSideBearing;
257 SHORT xMaxExtent;
258 SHORT caretSlopeRise;
259 SHORT caretSlopeRun;
260 SHORT caretOffset;
261 SHORT reserved[4];
262 SHORT metricDataFormat;
263 USHORT numberOfHMetrics;
264 } TT_HHEA;
265
266 struct sbix_header
267 {
268 WORD version;
269 WORD flags;
270 DWORD num_strikes;
271 DWORD strike_offset[1];
272 };
273
274 struct sbix_strike
275 {
276 WORD ppem;
277 WORD ppi;
278 DWORD glyphdata_offsets[1];
279 };
280
281 struct sbix_glyph_data
282 {
283 WORD originOffsetX;
284 WORD originOffsetY;
285 DWORD graphic_type;
286 BYTE data[1];
287 };
288
289 struct maxp
290 {
291 DWORD version;
292 WORD num_glyphs;
293 };
294
295 struct cblc_header
296 {
297 WORD major_version;
298 WORD minor_version;
299 DWORD num_sizes;
300 };
301
302 typedef struct {
303 BYTE res[12];
304 } sbitLineMetrics;
305
306 struct cblc_bitmapsize_table
307 {
308 DWORD indexSubTableArrayOffset;
309 DWORD indexTablesSize;
310 DWORD numberofIndexSubTables;
311 DWORD colorRef;
312 sbitLineMetrics hori;
313 sbitLineMetrics vert;
314 WORD startGlyphIndex;
315 WORD endGlyphIndex;
316 BYTE ppemX;
317 BYTE ppemY;
318 BYTE bit_depth;
319 BYTE flags;
320 };
321
322 struct gasp_range
323 {
324 WORD max_ppem;
325 WORD flags;
326 };
327
328 struct gasp_header
329 {
330 WORD version;
331 WORD num_ranges;
332 struct gasp_range ranges[1];
333 };
334
335 enum OS2_FSSELECTION {
336 OS2_FSSELECTION_ITALIC = 1 << 0,
337 OS2_FSSELECTION_UNDERSCORE = 1 << 1,
338 OS2_FSSELECTION_NEGATIVE = 1 << 2,
339 OS2_FSSELECTION_OUTLINED = 1 << 3,
340 OS2_FSSELECTION_STRIKEOUT = 1 << 4,
341 OS2_FSSELECTION_BOLD = 1 << 5,
342 OS2_FSSELECTION_REGULAR = 1 << 6,
343 OS2_FSSELECTION_USE_TYPO_METRICS = 1 << 7,
344 OS2_FSSELECTION_WWS = 1 << 8,
345 OS2_FSSELECTION_OBLIQUE = 1 << 9
346 };
347
348 typedef struct {
349 WORD platformID;
350 WORD encodingID;
351 WORD languageID;
352 WORD nameID;
353 WORD length;
354 WORD offset;
355 } TT_NameRecord;
356
357 typedef struct {
358 WORD format;
359 WORD count;
360 WORD stringOffset;
361 TT_NameRecord nameRecord[1];
362 } TT_NAME_V0;
363
364 struct vdmx_header
365 {
366 WORD version;
367 WORD num_recs;
368 WORD num_ratios;
369 };
370
371 struct vdmx_ratio
372 {
373 BYTE bCharSet;
374 BYTE xRatio;
375 BYTE yStartRatio;
376 BYTE yEndRatio;
377 };
378
379 struct vdmx_vtable
380 {
381 WORD yPelHeight;
382 SHORT yMax;
383 SHORT yMin;
384 };
385
386 struct vdmx_group
387 {
388 WORD recs;
389 BYTE startsz;
390 BYTE endsz;
391 struct vdmx_vtable entries[1];
392 };
393
394 struct ot_feature_record
395 {
396 DWORD tag;
397 WORD offset;
398 };
399
400 struct ot_feature_list
401 {
402 WORD feature_count;
403 struct ot_feature_record features[1];
404 };
405
406 struct ot_langsys
407 {
408 WORD lookup_order; /* Reserved */
409 WORD required_feature_index;
410 WORD feature_count;
411 WORD feature_index[1];
412 };
413
414 struct ot_langsys_record
415 {
416 CHAR tag[4];
417 WORD langsys;
418 };
419
420 struct ot_script
421 {
422 WORD default_langsys;
423 WORD langsys_count;
424 struct ot_langsys_record langsys[1];
425 } OT_Script;
426
427 struct ot_script_record
428 {
429 CHAR tag[4];
430 WORD script;
431 };
432
433 struct ot_script_list
434 {
435 WORD script_count;
436 struct ot_script_record scripts[1];
437 };
438
439 enum ot_gdef_class
440 {
441 GDEF_CLASS_UNCLASSIFIED = 0,
442 GDEF_CLASS_BASE = 1,
443 GDEF_CLASS_LIGATURE = 2,
444 GDEF_CLASS_MARK = 3,
445 GDEF_CLASS_COMPONENT = 4,
446 GDEF_CLASS_MAX = GDEF_CLASS_COMPONENT,
447 };
448
449 struct gdef_header
450 {
451 DWORD version;
452 WORD classdef;
453 WORD attach_list;
454 WORD ligcaret_list;
455 WORD markattach_classdef;
456 };
457
458 struct ot_gdef_classdef_format1
459 {
460 WORD format;
461 WORD start_glyph;
462 WORD glyph_count;
463 WORD classes[1];
464 };
465
466 struct ot_gdef_class_range
467 {
468 WORD start_glyph;
469 WORD end_glyph;
470 WORD glyph_class;
471 };
472
473 struct ot_gdef_classdef_format2
474 {
475 WORD format;
476 WORD range_count;
477 struct ot_gdef_class_range ranges[1];
478 };
479
480 struct gpos_gsub_header
481 {
482 DWORD version;
483 WORD script_list;
484 WORD feature_list;
485 WORD lookup_list;
486 };
487
488 enum gsub_gpos_lookup_flags
489 {
490 LOOKUP_FLAG_RTL = 0x1,
491 LOOKUP_FLAG_IGNORE_BASE = 0x2,
492 LOOKUP_FLAG_IGNORE_LIGATURES = 0x4,
493 LOOKUP_FLAG_IGNORE_MARKS = 0x8,
494
495 LOOKUP_FLAG_IGNORE_MASK = 0xe,
496 };
497
498 enum gpos_lookup_type
499 {
500 GPOS_LOOKUP_SINGLE_ADJUSTMENT = 1,
501 GPOS_LOOKUP_PAIR_ADJUSTMENT = 2,
502 GPOS_LOOKUP_CURSIVE_ATTACHMENT = 3,
503 GPOS_LOOKUP_MARK_TO_BASE_ATTACHMENT = 4,
504 GPOS_LOOKUP_MARK_TO_LIGATURE_ATTACHMENT = 5,
505 GPOS_LOOKUP_MARK_TO_MARK_ATTACHMENT = 6,
506 GPOS_LOOKUP_CONTEXTUAL_POSITION = 7,
507 GPOS_LOOKUP_CONTEXTUAL_CHAINING_POSITION = 8,
508 GPOS_LOOKUP_EXTENSION_POSITION = 9,
509 };
510
511 enum gpos_value_format
512 {
513 GPOS_VALUE_X_PLACEMENT = 0x1,
514 GPOS_VALUE_Y_PLACEMENT = 0x2,
515 GPOS_VALUE_X_ADVANCE = 0x4,
516 GPOS_VALUE_Y_ADVANCE = 0x8,
517 GPOS_VALUE_X_PLACEMENT_DEVICE = 0x10,
518 GPOS_VALUE_Y_PLACEMENT_DEVICE = 0x20,
519 GPOS_VALUE_X_ADVANCE_DEVICE = 0x40,
520 GPOS_VALUE_Y_ADVANCE_DEVICE = 0x80,
521 };
522
523 enum OPENTYPE_PLATFORM_ID
524 {
525 OPENTYPE_PLATFORM_UNICODE = 0,
526 OPENTYPE_PLATFORM_MAC,
527 OPENTYPE_PLATFORM_ISO,
528 OPENTYPE_PLATFORM_WIN,
529 OPENTYPE_PLATFORM_CUSTOM
530 };
531
532 struct ot_gpos_extensionpos_format1
533 {
534 WORD format;
535 WORD lookup_type;
536 DWORD extension_offset;
537 };
538
539 struct ot_feature
540 {
541 WORD feature_params;
542 WORD lookup_count;
543 WORD lookuplist_index[1];
544 };
545
546 struct ot_lookup_list
547 {
548 WORD lookup_count;
549 WORD lookup[1];
550 };
551
552 struct ot_lookup_table
553 {
554 WORD lookup_type;
555 WORD flags;
556 WORD subtable_count;
557 WORD subtable[1];
558 };
559
560 #define GLYPH_NOT_COVERED (~0u)
561
562 struct ot_coverage_format1
563 {
564 WORD format;
565 WORD glyph_count;
566 WORD glyphs[1];
567 };
568
569 struct ot_coverage_range
570 {
571 WORD start_glyph;
572 WORD end_glyph;
573 WORD startcoverage_index;
574 };
575
576 struct ot_coverage_format2
577 {
578 WORD format;
579 WORD range_count;
580 struct ot_coverage_range ranges[1];
581 };
582
583 struct ot_gpos_device_table
584 {
585 WORD start_size;
586 WORD end_size;
587 WORD format;
588 WORD values[1];
589 };
590
591 struct ot_gpos_singlepos_format1
592 {
593 WORD format;
594 WORD coverage;
595 WORD value_format;
596 WORD value[1];
597 };
598
599 struct ot_gpos_singlepos_format2
600 {
601 WORD format;
602 WORD coverage;
603 WORD value_format;
604 WORD value_count;
605 WORD values[1];
606 };
607
608 struct ot_gpos_pairvalue
609 {
610 WORD second_glyph;
611 BYTE data[1];
612 };
613
614 struct ot_gpos_pairset
615 {
616 WORD pairvalue_count;
617 struct ot_gpos_pairvalue pairvalues[1];
618 };
619
620 struct ot_gpos_pairpos_format1
621 {
622 WORD format;
623 WORD coverage;
624 WORD value_format1;
625 WORD value_format2;
626 WORD pairset_count;
627 WORD pairsets[1];
628 };
629
630 struct ot_gpos_pairpos_format2
631 {
632 WORD format;
633 WORD coverage;
634 WORD value_format1;
635 WORD value_format2;
636 WORD class_def1;
637 WORD class_def2;
638 WORD class1_count;
639 WORD class2_count;
640 WORD values[1];
641 };
642
643 struct ot_gpos_anchor_format1
644 {
645 WORD format;
646 short x_coord;
647 short y_coord;
648 };
649
650 struct ot_gpos_anchor_format2
651 {
652 WORD format;
653 short x_coord;
654 short y_coord;
655 WORD anchor_point;
656 };
657
658 struct ot_gpos_anchor_format3
659 {
660 WORD format;
661 short x_coord;
662 short y_coord;
663 WORD x_dev_offset;
664 WORD y_dev_offset;
665 };
666
667 struct ot_gpos_cursive_format1
668 {
669 WORD format;
670 WORD coverage;
671 WORD count;
672 WORD anchors[1];
673 };
674
675 struct ot_gpos_mark_record
676 {
677 WORD mark_class;
678 WORD mark_anchor;
679 };
680
681 struct ot_gpos_mark_array
682 {
683 WORD count;
684 struct ot_gpos_mark_record records[1];
685 };
686
687 struct ot_gpos_base_array
688 {
689 WORD count;
690 WORD offsets[1];
691 };
692
693 struct ot_gpos_mark_to_base_format1
694 {
695 WORD format;
696 WORD mark_coverage;
697 WORD base_coverage;
698 WORD mark_class_count;
699 WORD mark_array;
700 WORD base_array;
701 };
702
703 struct ot_gpos_mark_to_lig_format1
704 {
705 WORD format;
706 WORD mark_coverage;
707 WORD lig_coverage;
708 WORD mark_class_count;
709 WORD mark_array;
710 WORD lig_array;
711 };
712
713 struct ot_gpos_mark_to_mark_format1
714 {
715 WORD format;
716 WORD mark1_coverage;
717 WORD mark2_coverage;
718 WORD mark_class_count;
719 WORD mark1_array;
720 WORD mark2_array;
721 };
722
723 typedef struct {
724 WORD SubstFormat;
725 WORD Coverage;
726 WORD DeltaGlyphID;
727 } GSUB_SingleSubstFormat1;
728
729 typedef struct {
730 WORD SubstFormat;
731 WORD Coverage;
732 WORD GlyphCount;
733 WORD Substitute[1];
734 } GSUB_SingleSubstFormat2;
735
736 typedef struct {
737 WORD SubstFormat;
738 WORD ExtensionLookupType;
739 DWORD ExtensionOffset;
740 } GSUB_ExtensionPosFormat1;
741
742 #include "poppack.h"
743
744 enum gsub_lookup_type
745 {
746 GSUB_LOOKUP_SINGLE_SUBST = 1,
747 GSUB_LOOKUP_EXTENSION_SUBST = 7,
748 };
749
750 enum TT_NAME_WINDOWS_ENCODING_ID
751 {
752 TT_NAME_WINDOWS_ENCODING_SYMBOL = 0,
753 TT_NAME_WINDOWS_ENCODING_UCS2,
754 TT_NAME_WINDOWS_ENCODING_SJIS,
755 TT_NAME_WINDOWS_ENCODING_PRC,
756 TT_NAME_WINDOWS_ENCODING_BIG5,
757 TT_NAME_WINDOWS_ENCODING_WANSUNG,
758 TT_NAME_WINDOWS_ENCODING_JOHAB,
759 TT_NAME_WINDOWS_ENCODING_RESERVED1,
760 TT_NAME_WINDOWS_ENCODING_RESERVED2,
761 TT_NAME_WINDOWS_ENCODING_RESERVED3,
762 TT_NAME_WINDOWS_ENCODING_UCS4
763 };
764
765 enum TT_NAME_MAC_ENCODING_ID
766 {
767 TT_NAME_MAC_ENCODING_ROMAN = 0,
768 TT_NAME_MAC_ENCODING_JAPANESE,
769 TT_NAME_MAC_ENCODING_TRAD_CHINESE,
770 TT_NAME_MAC_ENCODING_KOREAN,
771 TT_NAME_MAC_ENCODING_ARABIC,
772 TT_NAME_MAC_ENCODING_HEBREW,
773 TT_NAME_MAC_ENCODING_GREEK,
774 TT_NAME_MAC_ENCODING_RUSSIAN,
775 TT_NAME_MAC_ENCODING_RSYMBOL,
776 TT_NAME_MAC_ENCODING_DEVANAGARI,
777 TT_NAME_MAC_ENCODING_GURMUKHI,
778 TT_NAME_MAC_ENCODING_GUJARATI,
779 TT_NAME_MAC_ENCODING_ORIYA,
780 TT_NAME_MAC_ENCODING_BENGALI,
781 TT_NAME_MAC_ENCODING_TAMIL,
782 TT_NAME_MAC_ENCODING_TELUGU,
783 TT_NAME_MAC_ENCODING_KANNADA,
784 TT_NAME_MAC_ENCODING_MALAYALAM,
785 TT_NAME_MAC_ENCODING_SINHALESE,
786 TT_NAME_MAC_ENCODING_BURMESE,
787 TT_NAME_MAC_ENCODING_KHMER,
788 TT_NAME_MAC_ENCODING_THAI,
789 TT_NAME_MAC_ENCODING_LAOTIAN,
790 TT_NAME_MAC_ENCODING_GEORGIAN,
791 TT_NAME_MAC_ENCODING_ARMENIAN,
792 TT_NAME_MAC_ENCODING_SIMPL_CHINESE,
793 TT_NAME_MAC_ENCODING_TIBETAN,
794 TT_NAME_MAC_ENCODING_MONGOLIAN,
795 TT_NAME_MAC_ENCODING_GEEZ,
796 TT_NAME_MAC_ENCODING_SLAVIC,
797 TT_NAME_MAC_ENCODING_VIETNAMESE,
798 TT_NAME_MAC_ENCODING_SINDHI,
799 TT_NAME_MAC_ENCODING_UNINTERPRETED
800 };
801
802 enum TT_NAME_MAC_LANGUAGE_ID
803 {
804 TT_NAME_MAC_LANGID_ENGLISH = 0,
805 TT_NAME_MAC_LANGID_FRENCH,
806 TT_NAME_MAC_LANGID_GERMAN,
807 TT_NAME_MAC_LANGID_ITALIAN,
808 TT_NAME_MAC_LANGID_DUTCH,
809 TT_NAME_MAC_LANGID_SWEDISH,
810 TT_NAME_MAC_LANGID_SPANISH,
811 TT_NAME_MAC_LANGID_DANISH,
812 TT_NAME_MAC_LANGID_PORTUGUESE,
813 TT_NAME_MAC_LANGID_NORWEGIAN,
814 TT_NAME_MAC_LANGID_HEBREW,
815 TT_NAME_MAC_LANGID_JAPANESE,
816 TT_NAME_MAC_LANGID_ARABIC,
817 TT_NAME_MAC_LANGID_FINNISH,
818 TT_NAME_MAC_LANGID_GREEK,
819 TT_NAME_MAC_LANGID_ICELANDIC,
820 TT_NAME_MAC_LANGID_MALTESE,
821 TT_NAME_MAC_LANGID_TURKISH,
822 TT_NAME_MAC_LANGID_CROATIAN,
823 TT_NAME_MAC_LANGID_TRAD_CHINESE,
824 TT_NAME_MAC_LANGID_URDU,
825 TT_NAME_MAC_LANGID_HINDI,
826 TT_NAME_MAC_LANGID_THAI,
827 TT_NAME_MAC_LANGID_KOREAN,
828 TT_NAME_MAC_LANGID_LITHUANIAN,
829 TT_NAME_MAC_LANGID_POLISH,
830 TT_NAME_MAC_LANGID_HUNGARIAN,
831 TT_NAME_MAC_LANGID_ESTONIAN,
832 TT_NAME_MAC_LANGID_LATVIAN,
833 TT_NAME_MAC_LANGID_SAMI,
834 TT_NAME_MAC_LANGID_FAROESE,
835 TT_NAME_MAC_LANGID_FARSI,
836 TT_NAME_MAC_LANGID_RUSSIAN,
837 TT_NAME_MAC_LANGID_SIMPL_CHINESE,
838 TT_NAME_MAC_LANGID_FLEMISH,
839 TT_NAME_MAC_LANGID_GAELIC,
840 TT_NAME_MAC_LANGID_ALBANIAN,
841 TT_NAME_MAC_LANGID_ROMANIAN,
842 TT_NAME_MAC_LANGID_CZECH,
843 TT_NAME_MAC_LANGID_SLOVAK,
844 TT_NAME_MAC_LANGID_SLOVENIAN,
845 TT_NAME_MAC_LANGID_YIDDISH,
846 TT_NAME_MAC_LANGID_SERBIAN,
847 TT_NAME_MAC_LANGID_MACEDONIAN,
848 TT_NAME_MAC_LANGID_BULGARIAN,
849 TT_NAME_MAC_LANGID_UKRAINIAN,
850 TT_NAME_MAC_LANGID_BYELORUSSIAN,
851 TT_NAME_MAC_LANGID_UZBEK,
852 TT_NAME_MAC_LANGID_KAZAKH,
853 TT_NAME_MAC_LANGID_AZERB_CYR,
854 TT_NAME_MAC_LANGID_AZERB_ARABIC,
855 TT_NAME_MAC_LANGID_ARMENIAN,
856 TT_NAME_MAC_LANGID_GEORGIAN,
857 TT_NAME_MAC_LANGID_MOLDAVIAN,
858 TT_NAME_MAC_LANGID_KIRGHIZ,
859 TT_NAME_MAC_LANGID_TAJIKI,
860 TT_NAME_MAC_LANGID_TURKMEN,
861 TT_NAME_MAC_LANGID_MONGOLIAN,
862 TT_NAME_MAC_LANGID_MONGOLIAN_CYR,
863 TT_NAME_MAC_LANGID_PASHTO,
864 TT_NAME_MAC_LANGID_KURDISH,
865 TT_NAME_MAC_LANGID_KASHMIRI,
866 TT_NAME_MAC_LANGID_SINDHI,
867 TT_NAME_MAC_LANGID_TIBETAN,
868 TT_NAME_MAC_LANGID_NEPALI,
869 TT_NAME_MAC_LANGID_SANSKRIT,
870 TT_NAME_MAC_LANGID_MARATHI,
871 TT_NAME_MAC_LANGID_BENGALI,
872 TT_NAME_MAC_LANGID_ASSAMESE,
873 TT_NAME_MAC_LANGID_GUJARATI,
874 TT_NAME_MAC_LANGID_PUNJABI,
875 TT_NAME_MAC_LANGID_ORIYA,
876 TT_NAME_MAC_LANGID_MALAYALAM,
877 TT_NAME_MAC_LANGID_KANNADA,
878 TT_NAME_MAC_LANGID_TAMIL,
879 TT_NAME_MAC_LANGID_TELUGU,
880 TT_NAME_MAC_LANGID_SINHALESE,
881 TT_NAME_MAC_LANGID_BURMESE,
882 TT_NAME_MAC_LANGID_KHMER,
883 TT_NAME_MAC_LANGID_LAO,
884 TT_NAME_MAC_LANGID_VIETNAMESE,
885 TT_NAME_MAC_LANGID_INDONESIAN,
886 TT_NAME_MAC_LANGID_TAGALOG,
887 TT_NAME_MAC_LANGID_MALAY_ROMAN,
888 TT_NAME_MAC_LANGID_MALAY_ARABIC,
889 TT_NAME_MAC_LANGID_AMHARIC,
890 TT_NAME_MAC_LANGID_TIGRINYA,
891 TT_NAME_MAC_LANGID_GALLA,
892 TT_NAME_MAC_LANGID_SOMALI,
893 TT_NAME_MAC_LANGID_SWAHILI,
894 TT_NAME_MAC_LANGID_KINYARWANDA,
895 TT_NAME_MAC_LANGID_RUNDI,
896 TT_NAME_MAC_LANGID_NYANJA,
897 TT_NAME_MAC_LANGID_MALAGASY,
898 TT_NAME_MAC_LANGID_ESPERANTO,
899 TT_NAME_MAC_LANGID_WELSH = 128,
900 TT_NAME_MAC_LANGID_BASQUE,
901 TT_NAME_MAC_LANGID_CATALAN,
902 TT_NAME_MAC_LANGID_LATIN,
903 TT_NAME_MAC_LANGID_QUECHUA,
904 TT_NAME_MAC_LANGID_GUARANI,
905 TT_NAME_MAC_LANGID_AYMARA,
906 TT_NAME_MAC_LANGID_TATAR,
907 TT_NAME_MAC_LANGID_UIGHUR,
908 TT_NAME_MAC_LANGID_DZONGKHA,
909 TT_NAME_MAC_LANGID_JAVANESE,
910 TT_NAME_MAC_LANGID_SUNDANESE,
911 TT_NAME_MAC_LANGID_GALICIAN,
912 TT_NAME_MAC_LANGID_AFRIKAANS,
913 TT_NAME_MAC_LANGID_BRETON,
914 TT_NAME_MAC_LANGID_INUKTITUT,
915 TT_NAME_MAC_LANGID_SCOTTISH_GAELIC,
916 TT_NAME_MAC_LANGID_MANX_GAELIC,
917 TT_NAME_MAC_LANGID_IRISH_GAELIC,
918 TT_NAME_MAC_LANGID_TONGAN,
919 TT_NAME_MAC_LANGID_GREEK_POLYTONIC,
920 TT_NAME_MAC_LANGID_GREENLANDIC,
921 TT_NAME_MAC_LANGID_AZER_ROMAN
922 };
923
924 /* Names are indexed with TT_NAME_MAC_LANGUAGE_ID values */
925 static const char name_mac_langid_to_locale[][10] = {
926 "en-US",
927 "fr-FR",
928 "de-DE",
929 "it-IT",
930 "nl-NL",
931 "sv-SE",
932 "es-ES",
933 "da-DA",
934 "pt-PT",
935 "no-NO",
936 "he-IL",
937 "ja-JP",
938 "ar-AR",
939 "fi-FI",
940 "el-GR",
941 "is-IS",
942 "mt-MT",
943 "tr-TR",
944 "hr-HR",
945 "zh-HK",
946 "ur-PK",
947 "hi-IN",
948 "th-TH",
949 "ko-KR",
950 "lt-LT",
951 "pl-PL",
952 "hu-HU",
953 "et-EE",
954 "lv-LV",
955 "se-NO",
956 "fo-FO",
957 "fa-IR",
958 "ru-RU",
959 "zh-CN",
960 "nl-BE",
961 "gd-GB",
962 "sq-AL",
963 "ro-RO",
964 "cs-CZ",
965 "sk-SK",
966 "sl-SI",
967 "",
968 "sr-Latn",
969 "mk-MK",
970 "bg-BG",
971 "uk-UA",
972 "be-BY",
973 "uz-Latn",
974 "kk-KZ",
975 "az-Cyrl-AZ",
976 "az-AZ",
977 "hy-AM",
978 "ka-GE",
979 "",
980 "",
981 "tg-TJ",
982 "tk-TM",
983 "mn-Mong",
984 "mn-MN",
985 "ps-AF",
986 "ku-Arab",
987 "",
988 "sd-Arab",
989 "bo-CN",
990 "ne-NP",
991 "sa-IN",
992 "mr-IN",
993 "bn-IN",
994 "as-IN",
995 "gu-IN",
996 "pa-Arab",
997 "or-IN",
998 "ml-IN",
999 "kn-IN",
1000 "ta-LK",
1001 "te-IN",
1002 "si-LK",
1003 "",
1004 "km-KH",
1005 "lo-LA",
1006 "vi-VN",
1007 "id-ID",
1008 "",
1009 "ms-MY",
1010 "ms-Arab",
1011 "am-ET",
1012 "ti-ET",
1013 "",
1014 "",
1015 "sw-KE",
1016 "rw-RW",
1017 "",
1018 "",
1019 "",
1020 "",
1021 "",
1022 "",
1023 "",
1024 "",
1025 "",
1026 "",
1027 "",
1028 "",
1029 "",
1030 "",
1031 "",
1032 "",
1033 "",
1034 "",
1035 "",
1036 "",
1037 "",
1038 "",
1039 "",
1040 "",
1041 "",
1042 "",
1043 "",
1044 "",
1045 "",
1046 "",
1047 "",
1048 "",
1049 "",
1050 "",
1051 "",
1052 "",
1053 "",
1054 "cy-GB",
1055 "eu-ES",
1056 "ca-ES",
1057 "",
1058 "",
1059 "",
1060 "",
1061 "tt-RU",
1062 "ug-CN",
1063 "",
1064 "",
1065 "",
1066 "gl-ES",
1067 "af-ZA",
1068 "br-FR",
1069 "iu-Latn-CA",
1070 "gd-GB",
1071 "",
1072 "ga-IE",
1073 "",
1074 "",
1075 "kl-GL",
1076 "az-Latn"
1077 };
1078
1079 enum OPENTYPE_STRING_ID
1080 {
1081 OPENTYPE_STRING_COPYRIGHT_NOTICE = 0,
1082 OPENTYPE_STRING_FAMILY_NAME,
1083 OPENTYPE_STRING_SUBFAMILY_NAME,
1084 OPENTYPE_STRING_UNIQUE_IDENTIFIER,
1085 OPENTYPE_STRING_FULL_FONTNAME,
1086 OPENTYPE_STRING_VERSION_STRING,
1087 OPENTYPE_STRING_POSTSCRIPT_FONTNAME,
1088 OPENTYPE_STRING_TRADEMARK,
1089 OPENTYPE_STRING_MANUFACTURER,
1090 OPENTYPE_STRING_DESIGNER,
1091 OPENTYPE_STRING_DESCRIPTION,
1092 OPENTYPE_STRING_VENDOR_URL,
1093 OPENTYPE_STRING_DESIGNER_URL,
1094 OPENTYPE_STRING_LICENSE_DESCRIPTION,
1095 OPENTYPE_STRING_LICENSE_INFO_URL,
1096 OPENTYPE_STRING_RESERVED_ID15,
1097 OPENTYPE_STRING_TYPOGRAPHIC_FAMILY_NAME,
1098 OPENTYPE_STRING_TYPOGRAPHIC_SUBFAMILY_NAME,
1099 OPENTYPE_STRING_COMPATIBLE_FULLNAME,
1100 OPENTYPE_STRING_SAMPLE_TEXT,
1101 OPENTYPE_STRING_POSTSCRIPT_CID_NAME,
1102 OPENTYPE_STRING_WWS_FAMILY_NAME,
1103 OPENTYPE_STRING_WWS_SUBFAMILY_NAME
1104 };
1105
1106 static const UINT16 dwriteid_to_opentypeid[DWRITE_INFORMATIONAL_STRING_WEIGHT_STRETCH_STYLE_FAMILY_NAME + 1] =
1107 {
1108 (UINT16)-1, /* DWRITE_INFORMATIONAL_STRING_NONE is not used */
1109 OPENTYPE_STRING_COPYRIGHT_NOTICE,
1110 OPENTYPE_STRING_VERSION_STRING,
1111 OPENTYPE_STRING_TRADEMARK,
1112 OPENTYPE_STRING_MANUFACTURER,
1113 OPENTYPE_STRING_DESIGNER,
1114 OPENTYPE_STRING_DESIGNER_URL,
1115 OPENTYPE_STRING_DESCRIPTION,
1116 OPENTYPE_STRING_VENDOR_URL,
1117 OPENTYPE_STRING_LICENSE_DESCRIPTION,
1118 OPENTYPE_STRING_LICENSE_INFO_URL,
1119 OPENTYPE_STRING_FAMILY_NAME,
1120 OPENTYPE_STRING_SUBFAMILY_NAME,
1121 OPENTYPE_STRING_TYPOGRAPHIC_FAMILY_NAME,
1122 OPENTYPE_STRING_TYPOGRAPHIC_SUBFAMILY_NAME,
1123 OPENTYPE_STRING_SAMPLE_TEXT,
1124 OPENTYPE_STRING_FULL_FONTNAME,
1125 OPENTYPE_STRING_POSTSCRIPT_FONTNAME,
1126 OPENTYPE_STRING_POSTSCRIPT_CID_NAME,
1127 OPENTYPE_STRING_WWS_FAMILY_NAME,
1128 };
1129
1130 /* CPAL table */
1131 struct cpal_header_0
1132 {
1133 USHORT version;
1134 USHORT num_palette_entries;
1135 USHORT num_palettes;
1136 USHORT num_color_records;
1137 ULONG offset_first_color_record;
1138 USHORT color_record_indices[1];
1139 };
1140
1141 struct cpal_color_record
1142 {
1143 BYTE blue;
1144 BYTE green;
1145 BYTE red;
1146 BYTE alpha;
1147 };
1148
1149 /* COLR table */
1150 struct colr_header
1151 {
1152 USHORT version;
1153 USHORT num_baseglyph_records;
1154 ULONG offset_baseglyph_records;
1155 ULONG offset_layer_records;
1156 USHORT num_layer_records;
1157 };
1158
1159 struct colr_baseglyph_record
1160 {
1161 USHORT glyph;
1162 USHORT first_layer_index;
1163 USHORT num_layers;
1164 };
1165
1166 struct colr_layer_record
1167 {
1168 USHORT glyph;
1169 USHORT palette_index;
1170 };
1171
1172 struct meta_data_map
1173 {
1174 DWORD tag;
1175 DWORD offset;
1176 DWORD length;
1177 };
1178
1179 struct meta_header
1180 {
1181 DWORD version;
1182 DWORD flags;
1183 DWORD reserved;
1184 DWORD data_maps_count;
1185 struct meta_data_map maps[1];
1186 };
1187
1188 static const void *table_read_ensure(const struct dwrite_fonttable *table, unsigned int offset, unsigned int size)
1189 {
1190 if (size > table->size || offset > table->size - size)
1191 return NULL;
1192
1193 return table->data + offset;
1194 }
1195
1196 static WORD table_read_be_word(const struct dwrite_fonttable *table, unsigned int offset)
1197 {
1198 const WORD *ptr = table_read_ensure(table, offset, sizeof(*ptr));
1199 return ptr ? GET_BE_WORD(*ptr) : 0;
1200 }
1201
1202 static DWORD table_read_be_dword(const struct dwrite_fonttable *table, unsigned int offset)
1203 {
1204 const DWORD *ptr = table_read_ensure(table, offset, sizeof(*ptr));
1205 return ptr ? GET_BE_DWORD(*ptr) : 0;
1206 }
1207
1208 static DWORD table_read_dword(const struct dwrite_fonttable *table, unsigned int offset)
1209 {
1210 const DWORD *ptr = table_read_ensure(table, offset, sizeof(*ptr));
1211 return ptr ? *ptr : 0;
1212 }
1213
1214 BOOL is_face_type_supported(DWRITE_FONT_FACE_TYPE type)
1215 {
1216 return (type == DWRITE_FONT_FACE_TYPE_CFF) ||
1217 (type == DWRITE_FONT_FACE_TYPE_TRUETYPE) ||
1218 (type == DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION) ||
1219 (type == DWRITE_FONT_FACE_TYPE_RAW_CFF);
1220 }
1221
1222 typedef HRESULT (*dwrite_fontfile_analyzer)(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type,
1223 DWRITE_FONT_FACE_TYPE *face_type);
1224
1225 static HRESULT opentype_ttc_analyzer(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type,
1226 DWRITE_FONT_FACE_TYPE *face_type)
1227 {
1228 static const DWORD ttctag = MS_TTCF_TAG;
1229 const TTC_Header_V1 *header;
1230 void *context;
1231 HRESULT hr;
1232
1233 hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&header, 0, sizeof(header), &context);
1234 if (FAILED(hr))
1235 return hr;
1236
1237 if (!memcmp(header->TTCTag, &ttctag, sizeof(ttctag))) {
1238 *font_count = GET_BE_DWORD(header->numFonts);
1239 *file_type = DWRITE_FONT_FILE_TYPE_OPENTYPE_COLLECTION;
1240 *face_type = DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION;
1241 }
1242
1243 IDWriteFontFileStream_ReleaseFileFragment(stream, context);
1244
1245 return *file_type != DWRITE_FONT_FILE_TYPE_UNKNOWN ? S_OK : S_FALSE;
1246 }
1247
1248 static HRESULT opentype_ttf_analyzer(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type,
1249 DWRITE_FONT_FACE_TYPE *face_type)
1250 {
1251 const DWORD *header;
1252 void *context;
1253 HRESULT hr;
1254
1255 hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&header, 0, sizeof(*header), &context);
1256 if (FAILED(hr))
1257 return hr;
1258
1259 if (GET_BE_DWORD(*header) == 0x10000) {
1260 *font_count = 1;
1261 *file_type = DWRITE_FONT_FILE_TYPE_TRUETYPE;
1262 *face_type = DWRITE_FONT_FACE_TYPE_TRUETYPE;
1263 }
1264
1265 IDWriteFontFileStream_ReleaseFileFragment(stream, context);
1266
1267 return *file_type != DWRITE_FONT_FILE_TYPE_UNKNOWN ? S_OK : S_FALSE;
1268 }
1269
1270 static HRESULT opentype_otf_analyzer(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type,
1271 DWRITE_FONT_FACE_TYPE *face_type)
1272 {
1273 const DWORD *header;
1274 void *context;
1275 HRESULT hr;
1276
1277 hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&header, 0, sizeof(*header), &context);
1278 if (FAILED(hr))
1279 return hr;
1280
1281 if (GET_BE_DWORD(*header) == MS_OTTO_TAG) {
1282 *font_count = 1;
1283 *file_type = DWRITE_FONT_FILE_TYPE_CFF;
1284 *face_type = DWRITE_FONT_FACE_TYPE_CFF;
1285 }
1286
1287 IDWriteFontFileStream_ReleaseFileFragment(stream, context);
1288
1289 return *file_type != DWRITE_FONT_FILE_TYPE_UNKNOWN ? S_OK : S_FALSE;
1290 }
1291
1292 static HRESULT opentype_type1_analyzer(IDWriteFontFileStream *stream, UINT32 *font_count, DWRITE_FONT_FILE_TYPE *file_type,
1293 DWRITE_FONT_FACE_TYPE *face_type)
1294 {
1295 #include "pshpack1.h"
1296 /* Specified in Adobe TechNote #5178 */
1297 struct pfm_header {
1298 WORD dfVersion;
1299 DWORD dfSize;
1300 char data0[95];
1301 DWORD dfDevice;
1302 char data1[12];
1303 };
1304 #include "poppack.h"
1305 struct type1_header {
1306 WORD tag;
1307 char data[14];
1308 };
1309 const struct type1_header *header;
1310 void *context;
1311 HRESULT hr;
1312
1313 hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&header, 0, sizeof(*header), &context);
1314 if (FAILED(hr))
1315 return hr;
1316
1317 /* tag is followed by plain text section */
1318 if (header->tag == 0x8001 &&
1319 (!memcmp(header->data, "%!PS-AdobeFont", 14) ||
1320 !memcmp(header->data, "%!FontType", 10))) {
1321 *font_count = 1;
1322 *file_type = DWRITE_FONT_FILE_TYPE_TYPE1_PFB;
1323 *face_type = DWRITE_FONT_FACE_TYPE_TYPE1;
1324 }
1325
1326 IDWriteFontFileStream_ReleaseFileFragment(stream, context);
1327
1328 /* let's see if it's a .pfm metrics file */
1329 if (*file_type == DWRITE_FONT_FILE_TYPE_UNKNOWN) {
1330 const struct pfm_header *pfm_header;
1331 UINT64 filesize;
1332 DWORD offset;
1333 BOOL header_checked;
1334
1335 hr = IDWriteFontFileStream_GetFileSize(stream, &filesize);
1336 if (FAILED(hr))
1337 return hr;
1338
1339 hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&pfm_header, 0, sizeof(*pfm_header), &context);
1340 if (FAILED(hr))
1341 return hr;
1342
1343 offset = pfm_header->dfDevice;
1344 header_checked = pfm_header->dfVersion == 0x100 && pfm_header->dfSize == filesize;
1345 IDWriteFontFileStream_ReleaseFileFragment(stream, context);
1346
1347 /* as a last test check static string in PostScript information section */
1348 if (header_checked) {
1349 static const char postscript[] = "PostScript";
1350 char *devtype_name;
1351
1352 hr = IDWriteFontFileStream_ReadFileFragment(stream, (const void**)&devtype_name, offset, sizeof(postscript), &context);
1353 if (FAILED(hr))
1354 return hr;
1355
1356 if (!memcmp(devtype_name, postscript, sizeof(postscript))) {
1357 *font_count = 1;
1358 *file_type = DWRITE_FONT_FILE_TYPE_TYPE1_PFM;
1359 *face_type = DWRITE_FONT_FACE_TYPE_TYPE1;
1360 }
1361
1362 IDWriteFontFileStream_ReleaseFileFragment(stream, context);
1363 }
1364 }
1365
1366 return *file_type != DWRITE_FONT_FILE_TYPE_UNKNOWN ? S_OK : S_FALSE;
1367 }
1368
1369 HRESULT opentype_analyze_font(IDWriteFontFileStream *stream, BOOL *supported, DWRITE_FONT_FILE_TYPE *file_type,
1370 DWRITE_FONT_FACE_TYPE *face_type, UINT32 *face_count)
1371 {
1372 static dwrite_fontfile_analyzer fontfile_analyzers[] = {
1373 opentype_ttf_analyzer,
1374 opentype_otf_analyzer,
1375 opentype_ttc_analyzer,
1376 opentype_type1_analyzer,
1377 NULL
1378 };
1379 dwrite_fontfile_analyzer *analyzer = fontfile_analyzers;
1380 DWRITE_FONT_FACE_TYPE face;
1381 HRESULT hr;
1382
1383 if (!face_type)
1384 face_type = &face;
1385
1386 *file_type = DWRITE_FONT_FILE_TYPE_UNKNOWN;
1387 *face_type = DWRITE_FONT_FACE_TYPE_UNKNOWN;
1388 *face_count = 0;
1389
1390 while (*analyzer) {
1391 hr = (*analyzer)(stream, face_count, file_type, face_type);
1392 if (FAILED(hr))
1393 return hr;
1394
1395 if (hr == S_OK)
1396 break;
1397
1398 analyzer++;
1399 }
1400
1401 *supported = is_face_type_supported(*face_type);
1402 return S_OK;
1403 }
1404
1405 HRESULT opentype_try_get_font_table(const struct file_stream_desc *stream_desc, UINT32 tag, const void **table_data,
1406 void **table_context, UINT32 *table_size, BOOL *found)
1407 {
1408 void *table_directory_context, *sfnt_context;
1409 TT_TableRecord *table_record = NULL;
1410 TTC_SFNT_V1 *font_header = NULL;
1411 UINT32 table_offset = 0;
1412 UINT16 table_count;
1413 HRESULT hr;
1414
1415 if (found) *found = FALSE;
1416 if (table_size) *table_size = 0;
1417
1418 *table_data = NULL;
1419 *table_context = NULL;
1420
1421 if (stream_desc->face_type == DWRITE_FONT_FACE_TYPE_OPENTYPE_COLLECTION) {
1422 const TTC_Header_V1 *ttc_header;
1423 void * ttc_context;
1424 hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void**)&ttc_header, 0, sizeof(*ttc_header), &ttc_context);
1425 if (SUCCEEDED(hr)) {
1426 if (stream_desc->face_index >= GET_BE_DWORD(ttc_header->numFonts))
1427 hr = E_INVALIDARG;
1428 else {
1429 table_offset = GET_BE_DWORD(ttc_header->OffsetTable[stream_desc->face_index]);
1430 hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void**)&font_header, table_offset, sizeof(*font_header), &sfnt_context);
1431 }
1432 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, ttc_context);
1433 }
1434 }
1435 else
1436 hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void**)&font_header, 0, sizeof(*font_header), &sfnt_context);
1437
1438 if (FAILED(hr))
1439 return hr;
1440
1441 table_count = GET_BE_WORD(font_header->numTables);
1442 table_offset += sizeof(*font_header);
1443
1444 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, sfnt_context);
1445
1446 hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, (const void **)&table_record, table_offset,
1447 table_count * sizeof(*table_record), &table_directory_context);
1448 if (hr == S_OK) {
1449 UINT16 i;
1450
1451 for (i = 0; i < table_count; i++) {
1452 if (table_record->tag == tag) {
1453 UINT32 offset = GET_BE_DWORD(table_record->offset);
1454 UINT32 length = GET_BE_DWORD(table_record->length);
1455
1456 if (found)
1457 *found = TRUE;
1458 if (table_size)
1459 *table_size = length;
1460 hr = IDWriteFontFileStream_ReadFileFragment(stream_desc->stream, table_data, offset,
1461 length, table_context);
1462 break;
1463 }
1464 table_record++;
1465 }
1466
1467 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, table_directory_context);
1468 }
1469
1470 return hr;
1471 }
1472
1473 static HRESULT opentype_get_font_table(const struct file_stream_desc *stream_desc, UINT32 tag,
1474 struct dwrite_fonttable *table)
1475 {
1476 return opentype_try_get_font_table(stream_desc, tag, (const void **)&table->data, &table->context, &table->size, &table->exists);
1477 }
1478
1479 /**********
1480 * CMAP
1481 **********/
1482
1483 static unsigned int opentype_cmap_get_unicode_ranges_count(const struct dwrite_fonttable *cmap)
1484 {
1485 unsigned int i, num_tables, count = 0;
1486 const struct cmap_header *header;
1487
1488 num_tables = table_read_be_word(cmap, FIELD_OFFSET(struct cmap_header, num_tables));
1489 header = table_read_ensure(cmap, 0, FIELD_OFFSET(struct cmap_header, tables[num_tables]));
1490
1491 if (!header)
1492 return 0;
1493
1494 for (i = 0; i < num_tables; ++i)
1495 {
1496 unsigned int format, offset;
1497
1498 if (GET_BE_WORD(header->tables[i].platformID) != 3)
1499 continue;
1500
1501 offset = GET_BE_DWORD(header->tables[i].offset);
1502 format = table_read_be_word(cmap, offset);
1503
1504 switch (format)
1505 {
1506 case OPENTYPE_CMAP_TABLE_SEGMENT_MAPPING:
1507 {
1508 count += table_read_be_word(cmap, offset + FIELD_OFFSET(struct cmap_segment_mapping, seg_count_x2)) / 2;
1509 break;
1510 }
1511 case OPENTYPE_CMAP_TABLE_SEGMENTED_COVERAGE:
1512 {
1513 count += table_read_be_dword(cmap, offset + FIELD_OFFSET(struct cmap_segmented_coverage, num_groups));
1514 break;
1515 }
1516 default:
1517 FIXME("table format %u is not supported.\n", format);
1518 }
1519 }
1520
1521 return count;
1522 }
1523
1524 HRESULT opentype_cmap_get_unicode_ranges(const struct file_stream_desc *stream_desc, unsigned int max_count,
1525 DWRITE_UNICODE_RANGE *ranges, unsigned int *count)
1526 {
1527 unsigned int i, num_tables, k = 0;
1528 const struct cmap_header *header;
1529 struct dwrite_fonttable cmap;
1530
1531 opentype_get_font_table(stream_desc, MS_CMAP_TAG, &cmap);
1532
1533 if (!cmap.exists)
1534 return E_FAIL;
1535
1536 *count = opentype_cmap_get_unicode_ranges_count(&cmap);
1537
1538 num_tables = table_read_be_word(&cmap, FIELD_OFFSET(struct cmap_header, num_tables));
1539 header = table_read_ensure(&cmap, 0, FIELD_OFFSET(struct cmap_header, tables[num_tables]));
1540
1541 if (!header)
1542 {
1543 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, cmap.context);
1544 return S_OK;
1545 }
1546
1547 for (i = 0; i < num_tables && k < max_count; ++i)
1548 {
1549 unsigned int j, offset, format;
1550
1551 if (GET_BE_WORD(header->tables[i].platformID) != 3)
1552 continue;
1553
1554 offset = GET_BE_DWORD(header->tables[i].offset);
1555
1556 format = table_read_be_word(&cmap, offset);
1557 switch (format)
1558 {
1559 case OPENTYPE_CMAP_TABLE_SEGMENT_MAPPING:
1560 {
1561 unsigned int segment_count = table_read_be_word(&cmap, offset +
1562 FIELD_OFFSET(struct cmap_segment_mapping, seg_count_x2)) / 2;
1563 const UINT16 *start_code = table_read_ensure(&cmap, offset,
1564 FIELD_OFFSET(struct cmap_segment_mapping, end_code[segment_count]) +
1565 2 /* reservedPad */ +
1566 2 * segment_count /* start code array */);
1567 const UINT16 *end_code = table_read_ensure(&cmap, offset,
1568 FIELD_OFFSET(struct cmap_segment_mapping, end_code[segment_count]));
1569
1570 if (!start_code || !end_code)
1571 continue;
1572
1573 for (j = 0; j < segment_count && GET_BE_WORD(end_code[j]) != 0xffff && k < max_count; ++j, ++k)
1574 {
1575 ranges[k].first = GET_BE_WORD(start_code[j]);
1576 ranges[k].last = GET_BE_WORD(end_code[j]);
1577 }
1578 break;
1579 }
1580 case OPENTYPE_CMAP_TABLE_SEGMENTED_COVERAGE:
1581 {
1582 unsigned int num_groups = table_read_be_dword(&cmap, offset +
1583 FIELD_OFFSET(struct cmap_segmented_coverage, num_groups));
1584 const struct cmap_segmented_coverage *coverage;
1585
1586 coverage = table_read_ensure(&cmap, offset,
1587 FIELD_OFFSET(struct cmap_segmented_coverage, groups[num_groups]));
1588
1589 for (j = 0; j < num_groups && k < max_count; j++, k++)
1590 {
1591 ranges[k].first = GET_BE_DWORD(coverage->groups[j].startCharCode);
1592 ranges[k].last = GET_BE_DWORD(coverage->groups[j].endCharCode);
1593 }
1594 break;
1595 }
1596 default:
1597 FIXME("table format %u unhandled.\n", format);
1598 }
1599 }
1600
1601 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, cmap.context);
1602
1603 return *count > max_count ? E_NOT_SUFFICIENT_BUFFER : S_OK;
1604 }
1605
1606 void opentype_get_font_typo_metrics(struct file_stream_desc *stream_desc, unsigned int *ascent, unsigned int *descent)
1607 {
1608 struct dwrite_fonttable os2;
1609 const TT_OS2_V2 *data;
1610
1611 opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
1612 data = (const TT_OS2_V2 *)os2.data;
1613
1614 *ascent = *descent = 0;
1615
1616 if (os2.size >= FIELD_OFFSET(TT_OS2_V2, sTypoLineGap))
1617 {
1618 SHORT value = GET_BE_WORD(data->sTypoDescender);
1619 *ascent = GET_BE_WORD(data->sTypoAscender);
1620 *descent = value < 0 ? -value : 0;
1621 }
1622
1623 if (data)
1624 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
1625 }
1626
1627 void opentype_get_font_metrics(struct file_stream_desc *stream_desc, DWRITE_FONT_METRICS1 *metrics, DWRITE_CARET_METRICS *caret)
1628 {
1629 struct dwrite_fonttable os2, head, post, hhea;
1630 const TT_OS2_V2 *tt_os2;
1631 const TT_HEAD *tt_head;
1632 const TT_POST *tt_post;
1633 const TT_HHEA *tt_hhea;
1634
1635 memset(metrics, 0, sizeof(*metrics));
1636
1637 opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
1638 opentype_get_font_table(stream_desc, MS_HEAD_TAG, &head);
1639 opentype_get_font_table(stream_desc, MS_POST_TAG, &post);
1640 opentype_get_font_table(stream_desc, MS_HHEA_TAG, &hhea);
1641
1642 tt_head = (const TT_HEAD *)head.data;
1643 tt_os2 = (const TT_OS2_V2 *)os2.data;
1644 tt_post = (const TT_POST *)post.data;
1645 tt_hhea = (const TT_HHEA *)hhea.data;
1646
1647 if (tt_head) {
1648 metrics->designUnitsPerEm = GET_BE_WORD(tt_head->unitsPerEm);
1649 metrics->glyphBoxLeft = GET_BE_WORD(tt_head->xMin);
1650 metrics->glyphBoxTop = GET_BE_WORD(tt_head->yMax);
1651 metrics->glyphBoxRight = GET_BE_WORD(tt_head->xMax);
1652 metrics->glyphBoxBottom = GET_BE_WORD(tt_head->yMin);
1653 }
1654
1655 if (caret)
1656 {
1657 if (tt_hhea) {
1658 caret->slopeRise = GET_BE_WORD(tt_hhea->caretSlopeRise);
1659 caret->slopeRun = GET_BE_WORD(tt_hhea->caretSlopeRun);
1660 caret->offset = GET_BE_WORD(tt_hhea->caretOffset);
1661 }
1662 else {
1663 caret->slopeRise = 0;
1664 caret->slopeRun = 0;
1665 caret->offset = 0;
1666 }
1667 }
1668
1669 if (tt_os2) {
1670 USHORT version = GET_BE_WORD(tt_os2->version);
1671
1672 metrics->ascent = GET_BE_WORD(tt_os2->usWinAscent);
1673 /* Some fonts have usWinDescent value stored as signed short, which could be wrongly
1674 interpreted as large unsigned value. */
1675 metrics->descent = abs((SHORT)GET_BE_WORD(tt_os2->usWinDescent));
1676
1677 /* line gap is estimated using two sets of ascender/descender values and 'hhea' line gap */
1678 if (tt_hhea) {
1679 SHORT descender = (SHORT)GET_BE_WORD(tt_hhea->descender);
1680 INT32 linegap;
1681
1682 linegap = GET_BE_WORD(tt_hhea->ascender) + abs(descender) + GET_BE_WORD(tt_hhea->linegap) -
1683 metrics->ascent - metrics->descent;
1684 metrics->lineGap = linegap > 0 ? linegap : 0;
1685 }
1686
1687 metrics->strikethroughPosition = GET_BE_WORD(tt_os2->yStrikeoutPosition);
1688 metrics->strikethroughThickness = GET_BE_WORD(tt_os2->yStrikeoutSize);
1689 metrics->subscriptPositionX = GET_BE_WORD(tt_os2->ySubscriptXOffset);
1690 /* Y offset is stored as positive offset below baseline */
1691 metrics->subscriptPositionY = -GET_BE_WORD(tt_os2->ySubscriptYOffset);
1692 metrics->subscriptSizeX = GET_BE_WORD(tt_os2->ySubscriptXSize);
1693 metrics->subscriptSizeY = GET_BE_WORD(tt_os2->ySubscriptYSize);
1694 metrics->superscriptPositionX = GET_BE_WORD(tt_os2->ySuperscriptXOffset);
1695 metrics->superscriptPositionY = GET_BE_WORD(tt_os2->ySuperscriptYOffset);
1696 metrics->superscriptSizeX = GET_BE_WORD(tt_os2->ySuperscriptXSize);
1697 metrics->superscriptSizeY = GET_BE_WORD(tt_os2->ySuperscriptYSize);
1698
1699 /* version 2 fields */
1700 if (version >= 2) {
1701 metrics->capHeight = GET_BE_WORD(tt_os2->sCapHeight);
1702 metrics->xHeight = GET_BE_WORD(tt_os2->sxHeight);
1703 }
1704
1705 if (GET_BE_WORD(tt_os2->fsSelection) & OS2_FSSELECTION_USE_TYPO_METRICS) {
1706 SHORT descent = GET_BE_WORD(tt_os2->sTypoDescender);
1707 metrics->ascent = GET_BE_WORD(tt_os2->sTypoAscender);
1708 metrics->descent = descent < 0 ? -descent : 0;
1709 metrics->lineGap = GET_BE_WORD(tt_os2->sTypoLineGap);
1710 metrics->hasTypographicMetrics = TRUE;
1711 }
1712 }
1713 else {
1714 metrics->strikethroughPosition = metrics->designUnitsPerEm / 3;
1715 if (tt_hhea) {
1716 metrics->ascent = GET_BE_WORD(tt_hhea->ascender);
1717 metrics->descent = abs((SHORT)GET_BE_WORD(tt_hhea->descender));
1718 }
1719 }
1720
1721 if (tt_post) {
1722 metrics->underlinePosition = GET_BE_WORD(tt_post->underlinePosition);
1723 metrics->underlineThickness = GET_BE_WORD(tt_post->underlineThickness);
1724 }
1725
1726 if (metrics->underlineThickness == 0)
1727 metrics->underlineThickness = metrics->designUnitsPerEm / 14;
1728 if (metrics->strikethroughThickness == 0)
1729 metrics->strikethroughThickness = metrics->underlineThickness;
1730
1731 /* estimate missing metrics */
1732 if (metrics->xHeight == 0)
1733 metrics->xHeight = metrics->designUnitsPerEm / 2;
1734 if (metrics->capHeight == 0)
1735 metrics->capHeight = metrics->designUnitsPerEm * 7 / 10;
1736
1737 if (tt_os2)
1738 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
1739 if (tt_head)
1740 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, head.context);
1741 if (tt_post)
1742 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, post.context);
1743 if (tt_hhea)
1744 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, hhea.context);
1745 }
1746
1747 void opentype_get_font_properties(struct file_stream_desc *stream_desc, struct dwrite_font_props *props)
1748 {
1749 struct dwrite_fonttable os2, head, colr, cpal;
1750 BOOL is_symbol, is_monospaced;
1751 const TT_OS2_V2 *tt_os2;
1752 const TT_HEAD *tt_head;
1753
1754 opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
1755 opentype_get_font_table(stream_desc, MS_HEAD_TAG, &head);
1756
1757 tt_os2 = (const TT_OS2_V2 *)os2.data;
1758 tt_head = (const TT_HEAD *)head.data;
1759
1760 /* default stretch, weight and style to normal */
1761 props->stretch = DWRITE_FONT_STRETCH_NORMAL;
1762 props->weight = DWRITE_FONT_WEIGHT_NORMAL;
1763 props->style = DWRITE_FONT_STYLE_NORMAL;
1764 memset(&props->panose, 0, sizeof(props->panose));
1765 memset(&props->fontsig, 0, sizeof(props->fontsig));
1766 memset(&props->lf, 0, sizeof(props->lf));
1767 props->flags = 0;
1768
1769 /* DWRITE_FONT_STRETCH enumeration values directly match font data values */
1770 if (tt_os2)
1771 {
1772 USHORT version = GET_BE_WORD(tt_os2->version);
1773 USHORT fsSelection = GET_BE_WORD(tt_os2->fsSelection);
1774 USHORT usWeightClass = GET_BE_WORD(tt_os2->usWeightClass);
1775 USHORT usWidthClass = GET_BE_WORD(tt_os2->usWidthClass);
1776
1777 if (usWidthClass > DWRITE_FONT_STRETCH_UNDEFINED && usWidthClass <= DWRITE_FONT_STRETCH_ULTRA_EXPANDED)
1778 props->stretch = usWidthClass;
1779
1780 if (usWeightClass >= 1 && usWeightClass <= 9)
1781 usWeightClass *= 100;
1782
1783 if (usWeightClass > DWRITE_FONT_WEIGHT_ULTRA_BLACK)
1784 props->weight = DWRITE_FONT_WEIGHT_ULTRA_BLACK;
1785 else if (usWeightClass > 0)
1786 props->weight = usWeightClass;
1787
1788 if (version >= 4 && (fsSelection & OS2_FSSELECTION_OBLIQUE))
1789 props->style = DWRITE_FONT_STYLE_OBLIQUE;
1790 else if (fsSelection & OS2_FSSELECTION_ITALIC)
1791 props->style = DWRITE_FONT_STYLE_ITALIC;
1792 props->lf.lfItalic = !!(fsSelection & OS2_FSSELECTION_ITALIC);
1793
1794 memcpy(&props->panose, &tt_os2->panose, sizeof(props->panose));
1795
1796 /* FONTSIGNATURE */
1797 props->fontsig.fsUsb[0] = GET_BE_DWORD(tt_os2->ulUnicodeRange1);
1798 props->fontsig.fsUsb[1] = GET_BE_DWORD(tt_os2->ulUnicodeRange2);
1799 props->fontsig.fsUsb[2] = GET_BE_DWORD(tt_os2->ulUnicodeRange3);
1800 props->fontsig.fsUsb[3] = GET_BE_DWORD(tt_os2->ulUnicodeRange4);
1801
1802 if (version)
1803 {
1804 props->fontsig.fsCsb[0] = GET_BE_DWORD(tt_os2->ulCodePageRange1);
1805 props->fontsig.fsCsb[1] = GET_BE_DWORD(tt_os2->ulCodePageRange2);
1806 }
1807 }
1808 else if (tt_head) {
1809 USHORT macStyle = GET_BE_WORD(tt_head->macStyle);
1810
1811 if (macStyle & TT_HEAD_MACSTYLE_CONDENSED)
1812 props->stretch = DWRITE_FONT_STRETCH_CONDENSED;
1813 else if (macStyle & TT_HEAD_MACSTYLE_EXTENDED)
1814 props->stretch = DWRITE_FONT_STRETCH_EXPANDED;
1815
1816 if (macStyle & TT_HEAD_MACSTYLE_BOLD)
1817 props->weight = DWRITE_FONT_WEIGHT_BOLD;
1818
1819 if (macStyle & TT_HEAD_MACSTYLE_ITALIC) {
1820 props->style = DWRITE_FONT_STYLE_ITALIC;
1821 props->lf.lfItalic = 1;
1822 }
1823 }
1824
1825 props->lf.lfWeight = props->weight;
1826
1827 /* FONT_IS_SYMBOL */
1828 if (!(is_symbol = props->panose.familyKind == DWRITE_PANOSE_FAMILY_SYMBOL))
1829 {
1830 struct dwrite_fonttable cmap;
1831 int i, offset, num_tables;
1832
1833 opentype_get_font_table(stream_desc, MS_CMAP_TAG, &cmap);
1834
1835 if (cmap.data)
1836 {
1837 num_tables = table_read_be_word(&cmap, FIELD_OFFSET(struct cmap_header, num_tables));
1838 offset = FIELD_OFFSET(struct cmap_header, tables);
1839
1840 for (i = 0; !is_symbol && i < num_tables; ++i)
1841 {
1842 WORD platform, encoding;
1843
1844 platform = table_read_be_word(&cmap, offset + i * sizeof(struct cmap_encoding_record) +
1845 FIELD_OFFSET(struct cmap_encoding_record, platformID));
1846 encoding = table_read_be_word(&cmap, offset + i * sizeof(struct cmap_encoding_record) +
1847 FIELD_OFFSET(struct cmap_encoding_record, encodingID));
1848
1849 is_symbol = platform == OPENTYPE_CMAP_TABLE_PLATFORM_WIN &&
1850 encoding == OPENTYPE_CMAP_TABLE_ENCODING_SYMBOL;
1851 }
1852
1853 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, cmap.context);
1854 }
1855 }
1856 if (is_symbol)
1857 props->flags |= FONT_IS_SYMBOL;
1858
1859 /* FONT_IS_MONOSPACED */
1860 if (!(is_monospaced = props->panose.text.proportion == DWRITE_PANOSE_PROPORTION_MONOSPACED))
1861 {
1862 struct dwrite_fonttable post;
1863
1864 opentype_get_font_table(stream_desc, MS_POST_TAG, &post);
1865
1866 if (post.data)
1867 {
1868 is_monospaced = !!table_read_dword(&post, FIELD_OFFSET(TT_POST, fixed_pitch));
1869
1870 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, post.context);
1871 }
1872 }
1873 if (is_monospaced)
1874 props->flags |= FONT_IS_MONOSPACED;
1875
1876 /* FONT_IS_COLORED */
1877 opentype_get_font_table(stream_desc, MS_COLR_TAG, &colr);
1878 if (colr.data)
1879 {
1880 opentype_get_font_table(stream_desc, MS_CPAL_TAG, &cpal);
1881 if (cpal.data)
1882 {
1883 props->flags |= FONT_IS_COLORED;
1884 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, cpal.context);
1885 }
1886
1887 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, colr.context);
1888 }
1889
1890 TRACE("stretch=%d, weight=%d, style %d\n", props->stretch, props->weight, props->style);
1891
1892 if (os2.data)
1893 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
1894 if (head.data)
1895 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, head.context);
1896 }
1897
1898 static UINT get_name_record_codepage(enum OPENTYPE_PLATFORM_ID platform, USHORT encoding)
1899 {
1900 UINT codepage = 0;
1901
1902 switch (platform) {
1903 case OPENTYPE_PLATFORM_UNICODE:
1904 break;
1905 case OPENTYPE_PLATFORM_MAC:
1906 switch (encoding)
1907 {
1908 case TT_NAME_MAC_ENCODING_ROMAN:
1909 codepage = 10000;
1910 break;
1911 case TT_NAME_MAC_ENCODING_JAPANESE:
1912 codepage = 10001;
1913 break;
1914 case TT_NAME_MAC_ENCODING_TRAD_CHINESE:
1915 codepage = 10002;
1916 break;
1917 case TT_NAME_MAC_ENCODING_KOREAN:
1918 codepage = 10003;
1919 break;
1920 case TT_NAME_MAC_ENCODING_ARABIC:
1921 codepage = 10004;
1922 break;
1923 case TT_NAME_MAC_ENCODING_HEBREW:
1924 codepage = 10005;
1925 break;
1926 case TT_NAME_MAC_ENCODING_GREEK:
1927 codepage = 10006;
1928 break;
1929 case TT_NAME_MAC_ENCODING_RUSSIAN:
1930 codepage = 10007;
1931 break;
1932 case TT_NAME_MAC_ENCODING_SIMPL_CHINESE:
1933 codepage = 10008;
1934 break;
1935 case TT_NAME_MAC_ENCODING_THAI:
1936 codepage = 10021;
1937 break;
1938 default:
1939 FIXME("encoding %u not handled, platform %d.\n", encoding, platform);
1940 break;
1941 }
1942 break;
1943 case OPENTYPE_PLATFORM_WIN:
1944 switch (encoding)
1945 {
1946 case TT_NAME_WINDOWS_ENCODING_SYMBOL:
1947 case TT_NAME_WINDOWS_ENCODING_UCS2:
1948 break;
1949 case TT_NAME_WINDOWS_ENCODING_SJIS:
1950 codepage = 932;
1951 break;
1952 case TT_NAME_WINDOWS_ENCODING_PRC:
1953 codepage = 936;
1954 break;
1955 case TT_NAME_WINDOWS_ENCODING_BIG5:
1956 codepage = 950;
1957 break;
1958 case TT_NAME_WINDOWS_ENCODING_WANSUNG:
1959 codepage = 20949;
1960 break;
1961 case TT_NAME_WINDOWS_ENCODING_JOHAB:
1962 codepage = 1361;
1963 break;
1964 default:
1965 FIXME("encoding %u not handled, platform %d.\n", encoding, platform);
1966 break;
1967 }
1968 break;
1969 default:
1970 FIXME("unknown platform %d\n", platform);
1971 }
1972
1973 return codepage;
1974 }
1975
1976 static void get_name_record_locale(enum OPENTYPE_PLATFORM_ID platform, USHORT lang_id, WCHAR *locale, USHORT locale_len)
1977 {
1978 static const WCHAR enusW[] = {'e','n','-','U','S',0};
1979
1980 switch (platform) {
1981 case OPENTYPE_PLATFORM_MAC:
1982 {
1983 const char *locale_name = NULL;
1984
1985 if (lang_id > TT_NAME_MAC_LANGID_AZER_ROMAN)
1986 WARN("invalid mac lang id %d\n", lang_id);
1987 else if (!name_mac_langid_to_locale[lang_id][0])
1988 FIXME("failed to map mac lang id %d to locale name\n", lang_id);
1989 else
1990 locale_name = name_mac_langid_to_locale[lang_id];
1991
1992 if (locale_name)
1993 MultiByteToWideChar(CP_ACP, 0, name_mac_langid_to_locale[lang_id], -1, locale, locale_len);
1994 else
1995 strcpyW(locale, enusW);
1996 break;
1997 }
1998 case OPENTYPE_PLATFORM_WIN:
1999 if (!LCIDToLocaleName(MAKELCID(lang_id, SORT_DEFAULT), locale, locale_len, 0)) {
2000 FIXME("failed to get locale name for lcid=0x%08x\n", MAKELCID(lang_id, SORT_DEFAULT));
2001 strcpyW(locale, enusW);
2002 }
2003 break;
2004 case OPENTYPE_PLATFORM_UNICODE:
2005 strcpyW(locale, enusW);
2006 break;
2007 default:
2008 FIXME("unknown platform %d\n", platform);
2009 }
2010 }
2011
2012 static BOOL opentype_decode_namerecord(const TT_NAME_V0 *header, BYTE *storage_area, USHORT recid, IDWriteLocalizedStrings *strings)
2013 {
2014 const TT_NameRecord *record = &header->nameRecord[recid];
2015 USHORT lang_id, length, offset, encoding, platform;
2016 BOOL ret = FALSE;
2017
2018 platform = GET_BE_WORD(record->platformID);
2019 lang_id = GET_BE_WORD(record->languageID);
2020 length = GET_BE_WORD(record->length);
2021 offset = GET_BE_WORD(record->offset);
2022 encoding = GET_BE_WORD(record->encodingID);
2023
2024 if (lang_id < 0x8000) {
2025 WCHAR locale[LOCALE_NAME_MAX_LENGTH];
2026 WCHAR *name_string;
2027 UINT codepage;
2028
2029 codepage = get_name_record_codepage(platform, encoding);
2030 get_name_record_locale(platform, lang_id, locale, ARRAY_SIZE(locale));
2031
2032 if (codepage) {
2033 DWORD len = MultiByteToWideChar(codepage, 0, (LPSTR)(storage_area + offset), length, NULL, 0);
2034 name_string = heap_alloc(sizeof(WCHAR) * (len+1));
2035 MultiByteToWideChar(codepage, 0, (LPSTR)(storage_area + offset), length, name_string, len);
2036 name_string[len] = 0;
2037 }
2038 else {
2039 int i;
2040
2041 length /= sizeof(WCHAR);
2042 name_string = heap_strdupnW((LPWSTR)(storage_area + offset), length);
2043 for (i = 0; i < length; i++)
2044 name_string[i] = GET_BE_WORD(name_string[i]);
2045 }
2046
2047 TRACE("string %s for locale %s found\n", debugstr_w(name_string), debugstr_w(locale));
2048 add_localizedstring(strings, locale, name_string);
2049 heap_free(name_string);
2050 ret = TRUE;
2051 }
2052 else
2053 FIXME("handle NAME format 1\n");
2054
2055 return ret;
2056 }
2057
2058 static HRESULT opentype_get_font_strings_from_id(const void *table_data, enum OPENTYPE_STRING_ID id, IDWriteLocalizedStrings **strings)
2059 {
2060 int i, count, candidate_mac, candidate_unicode;
2061 const TT_NAME_V0 *header;
2062 BYTE *storage_area = 0;
2063 WORD format;
2064 BOOL exists;
2065 HRESULT hr;
2066
2067 if (!table_data)
2068 return E_FAIL;
2069
2070 hr = create_localizedstrings(strings);
2071 if (FAILED(hr)) return hr;
2072
2073 header = table_data;
2074 format = GET_BE_WORD(header->format);
2075
2076 switch (format) {
2077 case 0:
2078 case 1:
2079 break;
2080 default:
2081 FIXME("unsupported NAME format %d\n", format);
2082 }
2083
2084 storage_area = (LPBYTE)table_data + GET_BE_WORD(header->stringOffset);
2085 count = GET_BE_WORD(header->count);
2086
2087 exists = FALSE;
2088 candidate_unicode = candidate_mac = -1;
2089 for (i = 0; i < count; i++) {
2090 const TT_NameRecord *record = &header->nameRecord[i];
2091 USHORT platform;
2092
2093 if (GET_BE_WORD(record->nameID) != id)
2094 continue;
2095
2096 platform = GET_BE_WORD(record->platformID);
2097 switch (platform)
2098 {
2099 /* Skip Unicode or Mac entries for now, fonts tend to duplicate those
2100 strings as WIN platform entries. If font does not have WIN entry for
2101 this id, we will use Mac or Unicode platform entry while assuming
2102 en-US locale. */
2103 case OPENTYPE_PLATFORM_UNICODE:
2104 if (candidate_unicode == -1)
2105 candidate_unicode = i;
2106 break;
2107 case OPENTYPE_PLATFORM_MAC:
2108 if (candidate_mac == -1)
2109 candidate_mac = i;
2110 break;
2111 case OPENTYPE_PLATFORM_WIN:
2112 if (opentype_decode_namerecord(header, storage_area, i, *strings))
2113 exists = TRUE;
2114 break;
2115 default:
2116 FIXME("platform %i not supported\n", platform);
2117 break;
2118 }
2119 }
2120
2121 if (!exists)
2122 {
2123 if (candidate_mac != -1)
2124 exists = opentype_decode_namerecord(header, storage_area, candidate_mac, *strings);
2125 if (!exists && candidate_unicode != -1)
2126 exists = opentype_decode_namerecord(header, storage_area, candidate_unicode, *strings);
2127
2128 if (!exists)
2129 {
2130 IDWriteLocalizedStrings_Release(*strings);
2131 *strings = NULL;
2132 }
2133 }
2134
2135 if (*strings)
2136 sort_localizedstrings(*strings);
2137
2138 return exists ? S_OK : E_FAIL;
2139 }
2140
2141 static WCHAR *meta_get_lng_name(WCHAR *str, WCHAR **ctx)
2142 {
2143 static const WCHAR delimW[] = {',',' ',0};
2144 WCHAR *ret;
2145
2146 if (!str) str = *ctx;
2147 while (*str && strchrW(delimW, *str)) str++;
2148 if (!*str) return NULL;
2149 ret = str++;
2150 while (*str && !strchrW(delimW, *str)) str++;
2151 if (*str) *str++ = 0;
2152 *ctx = str;
2153
2154 return ret;
2155 }
2156
2157 static HRESULT opentype_get_font_strings_from_meta(const struct file_stream_desc *stream_desc,
2158 DWRITE_INFORMATIONAL_STRING_ID id, IDWriteLocalizedStrings **ret)
2159 {
2160 static const WCHAR emptyW[] = { 0 };
2161 const struct meta_data_map *maps;
2162 IDWriteLocalizedStrings *strings;
2163 struct dwrite_fonttable meta;
2164 DWORD version, i, count, tag;
2165 HRESULT hr;
2166
2167 *ret = NULL;
2168
2169 switch (id)
2170 {
2171 case DWRITE_INFORMATIONAL_STRING_DESIGN_SCRIPT_LANGUAGE_TAG:
2172 tag = MS_DLNG_TAG;
2173 break;
2174 case DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG:
2175 tag = MS_SLNG_TAG;
2176 break;
2177 default:
2178 WARN("Unexpected id %d.\n", id);
2179 return S_OK;
2180 }
2181
2182 if (FAILED(hr = create_localizedstrings(&strings)))
2183 return hr;
2184
2185 opentype_get_font_table(stream_desc, MS_META_TAG, &meta);
2186
2187 if (meta.data)
2188 {
2189 version = table_read_be_dword(&meta, 0);
2190 if (version != 1)
2191 {
2192 WARN("Unexpected meta table version %d.\n", version);
2193 goto end;
2194 }
2195
2196 count = table_read_be_dword(&meta, FIELD_OFFSET(struct meta_header, data_maps_count));
2197 if (!(maps = table_read_ensure(&meta, FIELD_OFFSET(struct meta_header, maps),
2198 count * sizeof(struct meta_data_map))))
2199 goto end;
2200
2201 for (i = 0; i < count; ++i)
2202 {
2203 const char *data;
2204
2205 if (maps[i].tag == tag && maps[i].length)
2206 {
2207 DWORD length = GET_BE_DWORD(maps[i].length), j;
2208
2209 if ((data = table_read_ensure(&meta, GET_BE_DWORD(maps[i].offset), length)))
2210 {
2211 WCHAR *ptrW = heap_alloc((length + 1) * sizeof(WCHAR)), *ctx, *token;
2212
2213 if (!ptrW)
2214 {
2215 hr = E_OUTOFMEMORY;
2216 goto end;
2217 }
2218
2219 /* Data is stored in comma separated list, ASCII range only. */
2220 for (j = 0; j < length; ++j)
2221 ptrW[j] = data[j];
2222 ptrW[length] = 0;
2223
2224 token = meta_get_lng_name(ptrW, &ctx);
2225
2226 while (token)
2227 {
2228 add_localizedstring(strings, emptyW, token);
2229 token = meta_get_lng_name(NULL, &ctx);
2230 }
2231
2232 heap_free(ptrW);
2233 }
2234 }
2235 }
2236 end:
2237 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, meta.context);
2238 }
2239
2240 if (IDWriteLocalizedStrings_GetCount(strings))
2241 *ret = strings;
2242 else
2243 IDWriteLocalizedStrings_Release(strings);
2244
2245 return hr;
2246 }
2247
2248 HRESULT opentype_get_font_info_strings(const struct file_stream_desc *stream_desc, DWRITE_INFORMATIONAL_STRING_ID id,
2249 IDWriteLocalizedStrings **strings)
2250 {
2251 struct dwrite_fonttable name;
2252
2253 switch (id)
2254 {
2255 case DWRITE_INFORMATIONAL_STRING_DESIGN_SCRIPT_LANGUAGE_TAG:
2256 case DWRITE_INFORMATIONAL_STRING_SUPPORTED_SCRIPT_LANGUAGE_TAG:
2257 opentype_get_font_strings_from_meta(stream_desc, id, strings);
2258 break;
2259 default:
2260 opentype_get_font_table(stream_desc, MS_NAME_TAG, &name);
2261 opentype_get_font_strings_from_id(name.data, dwriteid_to_opentypeid[id], strings);
2262 if (name.context)
2263 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, name.context);
2264 }
2265
2266 return S_OK;
2267 }
2268
2269 /* FamilyName locating order is WWS Family Name -> Preferred Family Name -> Family Name. If font claims to
2270 have 'Preferred Family Name' in WWS format, then WWS name is not used. */
2271 HRESULT opentype_get_font_familyname(struct file_stream_desc *stream_desc, IDWriteLocalizedStrings **names)
2272 {
2273 struct dwrite_fonttable os2, name;
2274 const TT_OS2_V2 *tt_os2;
2275 const void *name_table;
2276 HRESULT hr;
2277
2278 opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
2279 opentype_get_font_table(stream_desc, MS_NAME_TAG, &name);
2280
2281 tt_os2 = (const TT_OS2_V2 *)os2.data;
2282 name_table = (const void *)name.data;
2283
2284 *names = NULL;
2285
2286 /* if Preferred Family doesn't conform to WWS model try WWS name */
2287 if (tt_os2 && !(GET_BE_WORD(tt_os2->fsSelection) & OS2_FSSELECTION_WWS))
2288 hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_WWS_FAMILY_NAME, names);
2289 else
2290 hr = E_FAIL;
2291
2292 if (FAILED(hr))
2293 hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_TYPOGRAPHIC_FAMILY_NAME, names);
2294 if (FAILED(hr))
2295 hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_FAMILY_NAME, names);
2296
2297 if (os2.context)
2298 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
2299 if (name.context)
2300 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, name.context);
2301
2302 return hr;
2303 }
2304
2305 /* FaceName locating order is WWS Face Name -> Preferred Face Name -> Face Name. If font claims to
2306 have 'Preferred Face Name' in WWS format, then WWS name is not used. */
2307 HRESULT opentype_get_font_facename(struct file_stream_desc *stream_desc, WCHAR *lfname, IDWriteLocalizedStrings **names)
2308 {
2309 struct dwrite_fonttable os2, name;
2310 IDWriteLocalizedStrings *lfnames;
2311 const TT_OS2_V2 *tt_os2;
2312 const void *name_table;
2313 HRESULT hr;
2314
2315 opentype_get_font_table(stream_desc, MS_OS2_TAG, &os2);
2316 opentype_get_font_table(stream_desc, MS_NAME_TAG, &name);
2317
2318 tt_os2 = (const TT_OS2_V2 *)os2.data;
2319 name_table = name.data;
2320
2321 *names = NULL;
2322
2323 /* if Preferred Family doesn't conform to WWS model try WWS name */
2324 if (tt_os2 && !(GET_BE_WORD(tt_os2->fsSelection) & OS2_FSSELECTION_WWS))
2325 hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_WWS_SUBFAMILY_NAME, names);
2326 else
2327 hr = E_FAIL;
2328
2329 if (FAILED(hr))
2330 hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_TYPOGRAPHIC_SUBFAMILY_NAME, names);
2331 if (FAILED(hr))
2332 hr = opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_SUBFAMILY_NAME, names);
2333
2334 /* User locale is preferred, with fallback to en-us. */
2335 *lfname = 0;
2336 if (SUCCEEDED(opentype_get_font_strings_from_id(name_table, OPENTYPE_STRING_FAMILY_NAME, &lfnames))) {
2337 static const WCHAR enusW[] = {'e','n','-','u','s',0};
2338 WCHAR localeW[LOCALE_NAME_MAX_LENGTH];
2339 UINT32 index;
2340 BOOL exists;
2341
2342 exists = FALSE;
2343 if (GetSystemDefaultLocaleName(localeW, ARRAY_SIZE(localeW)))
2344 IDWriteLocalizedStrings_FindLocaleName(lfnames, localeW, &index, &exists);
2345
2346 if (!exists)
2347 IDWriteLocalizedStrings_FindLocaleName(lfnames, enusW, &index, &exists);
2348
2349 if (exists) {
2350 UINT32 length = 0;
2351 WCHAR *nameW;
2352
2353 IDWriteLocalizedStrings_GetStringLength(lfnames, index, &length);
2354 nameW = heap_alloc((length + 1) * sizeof(WCHAR));
2355 if (nameW) {
2356 *nameW = 0;
2357 IDWriteLocalizedStrings_GetString(lfnames, index, nameW, length + 1);
2358 lstrcpynW(lfname, nameW, LF_FACESIZE);
2359 heap_free(nameW);
2360 }
2361 }
2362
2363 IDWriteLocalizedStrings_Release(lfnames);
2364 }
2365
2366 if (os2.context)
2367 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, os2.context);
2368 if (name.context)
2369 IDWriteFontFileStream_ReleaseFileFragment(stream_desc->stream, name.context);
2370
2371 return hr;
2372 }
2373
2374 static inline const struct ot_script *opentype_get_script(const struct ot_script_list *scriptlist, UINT32 scripttag)
2375 {
2376 UINT16 j;
2377
2378 for (j = 0; j < GET_BE_WORD(scriptlist->script_count); j++) {
2379 const char *tag = scriptlist->scripts[j].tag;
2380 if (scripttag == DWRITE_MAKE_OPENTYPE_TAG(tag[0], tag[1], tag[2], tag[3]))
2381 return (struct ot_script*)((BYTE*)scriptlist + GET_BE_WORD(scriptlist->scripts[j].script));
2382 }
2383
2384 return NULL;
2385 }
2386
2387 static inline const struct ot_langsys *opentype_get_langsys(const struct ot_script *script, UINT32 languagetag)
2388 {
2389 UINT16 j;
2390
2391 for (j = 0; j < GET_BE_WORD(script->langsys_count); j++) {
2392 const char *tag = script->langsys[j].tag;
2393 if (languagetag == DWRITE_MAKE_OPENTYPE_TAG(tag[0], tag[1], tag[2], tag[3]))
2394 return (struct ot_langsys *)((BYTE*)script + GET_BE_WORD(script->langsys[j].langsys));
2395 }
2396
2397 return NULL;
2398 }
2399
2400 static void opentype_add_font_features(const struct gpos_gsub_header *header, const struct ot_langsys *langsys,
2401 UINT32 max_tagcount, UINT32 *count, DWRITE_FONT_FEATURE_TAG *tags)
2402 {
2403 const struct ot_feature_list *features = (const struct ot_feature_list *)((const BYTE*)header + GET_BE_WORD(header->feature_list));
2404 UINT16 j;
2405
2406 for (j = 0; j < GET_BE_WORD(langsys->feature_count); j++) {
2407 const struct ot_feature_record *feature = &features->features[langsys->feature_index[j]];
2408
2409 if (*count < max_tagcount)
2410 tags[*count] = GET_BE_DWORD(feature->tag);
2411
2412 (*count)++;
2413 }
2414 }
2415
2416 HRESULT opentype_get_typographic_features(IDWriteFontFace *fontface, UINT32 scripttag, UINT32 languagetag, UINT32 max_tagcount,
2417 UINT32 *count, DWRITE_FONT_FEATURE_TAG *tags)
2418 {
2419 UINT32 tables[2] = { MS_GSUB_TAG, MS_GPOS_TAG };
2420 HRESULT hr;
2421 UINT8 i;
2422
2423 *count = 0;
2424 for (i = 0; i < ARRAY_SIZE(tables); i++) {
2425 const struct ot_script_list *scriptlist;
2426 const struct gpos_gsub_header *header;
2427 const struct ot_script *script;
2428 const void *ptr;
2429 void *context;
2430 UINT32 size;
2431 BOOL exists;
2432
2433 exists = FALSE;
2434 hr = IDWriteFontFace_TryGetFontTable(fontface, tables[i], &ptr, &size, &context, &exists);
2435 if (FAILED(hr))
2436 return hr;
2437
2438 if (!exists)
2439 continue;
2440
2441 header = (const struct gpos_gsub_header *)ptr;
2442 scriptlist = (const struct ot_script_list *)((const BYTE*)header + GET_BE_WORD(header->script_list));
2443
2444 script = opentype_get_script(scriptlist, scripttag);
2445 if (script) {
2446 const struct ot_langsys *langsys = opentype_get_langsys(script, languagetag);
2447 if (langsys)
2448 opentype_add_font_features(header, langsys, max_tagcount, count, tags);
2449 }
2450
2451 IDWriteFontFace_ReleaseFontTable(fontface, context);
2452 }
2453
2454 return *count > max_tagcount ? E_NOT_SUFFICIENT_BUFFER : S_OK;
2455 }
2456
2457 static unsigned int find_vdmx_group(const struct vdmx_header *hdr)
2458 {
2459 WORD num_ratios, i;
2460 const struct vdmx_ratio *ratios = (struct vdmx_ratio *)(hdr + 1);
2461 BYTE dev_x_ratio = 1, dev_y_ratio = 1;
2462 unsigned int group_offset = 0;
2463
2464 num_ratios = GET_BE_WORD(hdr->num_ratios);
2465
2466 for (i = 0; i < num_ratios; i++) {
2467
2468 if (!ratios[i].bCharSet) continue;
2469
2470 if ((ratios[i].xRatio == 0 && ratios[i].yStartRatio == 0 &&
2471 ratios[i].yEndRatio == 0) ||
2472 (ratios[i].xRatio == dev_x_ratio && ratios[i].yStartRatio <= dev_y_ratio &&
2473 ratios[i].yEndRatio >= dev_y_ratio))
2474 {
2475 group_offset = GET_BE_WORD(*((WORD *)(ratios + num_ratios) + i));
2476 break;
2477 }
2478 }
2479
2480 return group_offset;
2481 }
2482
2483 BOOL opentype_get_vdmx_size(const struct dwrite_fonttable *vdmx, INT emsize, UINT16 *ascent, UINT16 *descent)
2484 {
2485 unsigned int num_ratios, num_recs, group_offset, i;
2486 const struct vdmx_header *header;
2487 const struct vdmx_group *group;
2488
2489 if (!vdmx->exists)
2490 return FALSE;
2491
2492 num_ratios = table_read_be_word(vdmx, FIELD_OFFSET(struct vdmx_header, num_ratios));
2493 num_recs = table_read_be_word(vdmx, FIELD_OFFSET(struct vdmx_header, num_recs));
2494
2495 header = table_read_ensure(vdmx, 0, sizeof(*header) + num_ratios * sizeof(struct vdmx_ratio) +
2496 num_recs * sizeof(*group));
2497
2498 if (!header)
2499 return FALSE;
2500
2501 group_offset = find_vdmx_group(header);
2502 if (!group_offset)
2503 return FALSE;
2504
2505 num_recs = table_read_be_word(vdmx, group_offset);
2506 group = table_read_ensure(vdmx, group_offset, FIELD_OFFSET(struct vdmx_group, entries[num_recs]));
2507
2508 if (!group)
2509 return FALSE;
2510
2511 if (emsize < group->startsz || emsize >= group->endsz)
2512 return FALSE;
2513
2514 for (i = 0; i < num_recs; ++i)
2515 {
2516 WORD ppem = GET_BE_WORD(group->entries[i].yPelHeight);
2517 if (ppem > emsize) {
2518 FIXME("interpolate %d\n", emsize);
2519 return FALSE;
2520 }
2521
2522 if (ppem == emsize) {
2523 *ascent = (SHORT)GET_BE_WORD(group->entries[i].yMax);
2524 *descent = -(SHORT)GET_BE_WORD(group->entries[i].yMin);
2525 return TRUE;
2526 }
2527 }
2528
2529 return FALSE;
2530 }
2531
2532 unsigned int opentype_get_gasp_flags(const struct dwrite_fonttable *gasp, float emsize)
2533 {
2534 unsigned int version, num_ranges, i;
2535 const struct gasp_header *table;
2536 WORD flags = 0;
2537
2538 if (!gasp->exists)
2539 return 0;
2540
2541 num_ranges = table_read_be_word(gasp, FIELD_OFFSET(struct gasp_header, num_ranges));
2542
2543 table = table_read_ensure(gasp, 0, FIELD_OFFSET(struct gasp_header, ranges[num_ranges]));
2544 if (!table)
2545 return 0;
2546
2547 version = GET_BE_WORD(table->version);
2548 if (version > 1)
2549 {
2550 ERR("Unsupported gasp table format version %u.\n", version);
2551 goto done;
2552 }
2553
2554 for (i = 0; i < num_ranges; ++i)
2555 {
2556 flags = GET_BE_WORD(table->ranges[i].flags);
2557 if (emsize <= GET_BE_WORD(table->ranges[i].max_ppem)) break;
2558 }
2559
2560 done:
2561 return flags;
2562 }
2563
2564 unsigned int opentype_get_cpal_palettecount(const struct dwrite_fonttable *cpal)
2565 {
2566 return table_read_be_word(cpal, FIELD_OFFSET(struct cpal_header_0, num_palettes));
2567 }
2568
2569 unsigned int opentype_get_cpal_paletteentrycount(const struct dwrite_fonttable *cpal)
2570 {
2571 return table_read_be_word(cpal, FIELD_OFFSET(struct cpal_header_0, num_palette_entries));
2572 }
2573
2574 HRESULT opentype_get_cpal_entries(const struct dwrite_fonttable *cpal, unsigned int palette,
2575 unsigned int first_entry_index, unsigned int entry_count, DWRITE_COLOR_F *entries)
2576 {
2577 unsigned int num_palettes, num_palette_entries, i;
2578 const struct cpal_color_record *records;
2579 const struct cpal_header_0 *header;
2580
2581 header = table_read_ensure(cpal, 0, sizeof(*header));
2582
2583 if (!cpal->exists || !header)
2584 return DWRITE_E_NOCOLOR;
2585
2586 num_palettes = GET_BE_WORD(header->num_palettes);
2587 if (palette >= num_palettes)
2588 return DWRITE_E_NOCOLOR;
2589
2590 header = table_read_ensure(cpal, 0, FIELD_OFFSET(struct cpal_header_0, color_record_indices[palette]));
2591 if (!header)
2592 return DWRITE_E_NOCOLOR;
2593
2594 num_palette_entries = GET_BE_WORD(header->num_palette_entries);
2595 if (first_entry_index + entry_count > num_palette_entries)
2596 return E_INVALIDARG;
2597
2598 records = table_read_ensure(cpal, GET_BE_DWORD(header->offset_first_color_record),
2599 sizeof(*records) * GET_BE_WORD(header->num_color_records));
2600 if (!records)
2601 return DWRITE_E_NOCOLOR;
2602
2603 first_entry_index += GET_BE_WORD(header->color_record_indices[palette]);
2604
2605 for (i = 0; i < entry_count; i++) {
2606 entries[i].u1.r = records[first_entry_index + i].red / 255.0f;
2607 entries[i].u2.g = records[first_entry_index + i].green / 255.0f;
2608 entries[i].u3.b = records[first_entry_index + i].blue / 255.0f;
2609 entries[i].u4.a = records[first_entry_index + i].alpha / 255.0f;
2610 }
2611
2612 return S_OK;
2613 }
2614
2615 static int colr_compare_gid(const void *g, const void *r)
2616 {
2617 const struct colr_baseglyph_record *record = r;
2618 UINT16 glyph = *(UINT16*)g, GID = GET_BE_WORD(record->glyph);
2619 int ret = 0;
2620
2621 if (glyph > GID)
2622 ret = 1;
2623 else if (glyph < GID)
2624 ret = -1;
2625
2626 return ret;
2627 }
2628
2629 HRESULT opentype_get_colr_glyph(const struct dwrite_fonttable *colr, UINT16 glyph, struct dwrite_colorglyph *ret)
2630 {
2631 unsigned int num_baseglyph_records, offset_baseglyph_records;
2632 const struct colr_baseglyph_record *record;
2633 const struct colr_layer_record *layer;
2634 const struct colr_header *header;
2635
2636 memset(ret, 0, sizeof(*ret));
2637 ret->glyph = glyph;
2638 ret->palette_index = 0xffff;
2639
2640 header = table_read_ensure(colr, 0, sizeof(*header));
2641 if (!header)
2642 return S_FALSE;
2643
2644 num_baseglyph_records = GET_BE_WORD(header->num_baseglyph_records);
2645 offset_baseglyph_records = GET_BE_DWORD(header->offset_baseglyph_records);
2646 if (!table_read_ensure(colr, offset_baseglyph_records, num_baseglyph_records * sizeof(*record)))
2647 {
2648 return S_FALSE;
2649 }
2650
2651 record = bsearch(&glyph, colr->data + offset_baseglyph_records, num_baseglyph_records,
2652 sizeof(*record), colr_compare_gid);
2653 if (!record)
2654 return S_FALSE;
2655
2656 ret->first_layer = GET_BE_WORD(record->first_layer_index);
2657 ret->num_layers = GET_BE_WORD(record->num_layers);
2658
2659 if ((layer = table_read_ensure(colr, GET_BE_DWORD(header->offset_layer_records),
2660 (ret->first_layer + ret->layer) * sizeof(*layer))))
2661 {
2662 layer += ret->first_layer + ret->layer;
2663 ret->glyph = GET_BE_WORD(layer->glyph);
2664 ret->palette_index = GET_BE_WORD(layer->palette_index);
2665 }
2666
2667 return S_OK;
2668 }
2669
2670 void opentype_colr_next_glyph(const struct dwrite_fonttable *colr, struct dwrite_colorglyph *glyph)
2671 {
2672 const struct colr_layer_record *layer;
2673 const struct colr_header *header;
2674
2675 /* iterated all the way through */
2676 if (glyph->layer == glyph->num_layers)
2677 return;
2678
2679 if (!(header = table_read_ensure(colr, 0, sizeof(*header))))
2680 return;
2681
2682 glyph->layer++;
2683
2684 if ((layer = table_read_ensure(colr, GET_BE_DWORD(header->offset_layer_records),
2685 (glyph->first_layer + glyph->layer) * sizeof(*layer))))
2686 {
2687 layer += glyph->first_layer + glyph->layer;
2688 glyph->glyph = GET_BE_WORD(layer->glyph);
2689 glyph->palette_index = GET_BE_WORD(layer->palette_index);
2690 }
2691 }
2692
2693 BOOL opentype_has_vertical_variants(IDWriteFontFace5 *fontface)
2694 {
2695 const struct gpos_gsub_header *header;
2696 const struct ot_feature_list *featurelist;
2697 const struct ot_lookup_list *lookup_list;
2698 BOOL exists = FALSE, ret = FALSE;
2699 unsigned int i, j;
2700 const void *data;
2701 void *context;
2702 UINT32 size;
2703 HRESULT hr;
2704
2705 hr = IDWriteFontFace5_TryGetFontTable(fontface, MS_GSUB_TAG, &data, &size, &context, &exists);
2706 if (FAILED(hr) || !exists)
2707 return FALSE;
2708
2709 header = data;
2710 featurelist = (struct ot_feature_list *)((BYTE*)header + GET_BE_WORD(header->feature_list));
2711 lookup_list = (const struct ot_lookup_list *)((BYTE*)header + GET_BE_WORD(header->lookup_list));
2712
2713 for (i = 0; i < GET_BE_WORD(featurelist->feature_count); i++) {
2714 if (featurelist->features[i].tag == DWRITE_FONT_FEATURE_TAG_VERTICAL_WRITING) {
2715 const struct ot_feature *feature = (const struct ot_feature*)((BYTE*)featurelist + GET_BE_WORD(featurelist->features[i].offset));
2716 UINT16 lookup_count = GET_BE_WORD(feature->lookup_count), index, count, type;
2717 const GSUB_SingleSubstFormat2 *subst2;
2718 const struct ot_lookup_table *lookup_table;
2719 UINT32 offset;
2720
2721 if (lookup_count == 0)
2722 continue;
2723
2724 for (j = 0; j < lookup_count; ++j) {
2725 /* check if lookup is empty */
2726 index = GET_BE_WORD(feature->lookuplist_index[j]);
2727 lookup_table = (const struct ot_lookup_table *)((BYTE*)lookup_list + GET_BE_WORD(lookup_list->lookup[index]));
2728
2729 type = GET_BE_WORD(lookup_table->lookup_type);
2730 if (type != GSUB_LOOKUP_SINGLE_SUBST && type != GSUB_LOOKUP_EXTENSION_SUBST)
2731 continue;
2732
2733 count = GET_BE_WORD(lookup_table->subtable_count);
2734 if (count == 0)
2735 continue;
2736
2737 offset = GET_BE_WORD(lookup_table->subtable[0]);
2738 if (type == GSUB_LOOKUP_EXTENSION_SUBST) {
2739 const GSUB_ExtensionPosFormat1 *ext = (const GSUB_ExtensionPosFormat1 *)((const BYTE *)lookup_table + offset);
2740 if (GET_BE_WORD(ext->SubstFormat) == 1)
2741 offset += GET_BE_DWORD(ext->ExtensionOffset);
2742 else
2743 FIXME("Unhandled Extension Substitution Format %u\n", GET_BE_WORD(ext->SubstFormat));
2744 }
2745
2746 subst2 = (const GSUB_SingleSubstFormat2*)((BYTE*)lookup_table + offset);
2747 index = GET_BE_WORD(subst2->SubstFormat);
2748 if (index == 1)
2749 FIXME("Validate Single Substitution Format 1\n");
2750 else if (index == 2) {
2751 /* SimSun-ExtB has 0 glyph count for this substitution */
2752 if (GET_BE_WORD(subst2->GlyphCount) > 0) {
2753 ret = TRUE;
2754 break;
2755 }
2756 }
2757 else
2758 WARN("Unknown Single Substitution Format, %u\n", index);
2759 }
2760 }
2761 }
2762
2763 IDWriteFontFace5_ReleaseFontTable(fontface, context);
2764
2765 return ret;
2766 }
2767
2768 static BOOL opentype_has_font_table(IDWriteFontFace5 *fontface, UINT32 tag)
2769 {
2770 BOOL exists = FALSE;
2771 const void *data;
2772 void *context;
2773 UINT32 size;
2774 HRESULT hr;
2775
2776 hr = IDWriteFontFace5_TryGetFontTable(fontface, tag, &data, &size, &context, &exists);
2777 if (FAILED(hr))
2778 return FALSE;
2779
2780 if (exists)
2781 IDWriteFontFace5_ReleaseFontTable(fontface, context);
2782
2783 return exists;
2784 }
2785
2786 static unsigned int opentype_get_sbix_formats(IDWriteFontFace5 *fontface)
2787 {
2788 unsigned int num_strikes, num_glyphs, i, j, ret = 0;
2789 const struct sbix_header *sbix_header;
2790 struct dwrite_fonttable table;
2791
2792 memset(&table, 0, sizeof(table));
2793 table.exists = TRUE;
2794
2795 if (!get_fontface_table(fontface, MS_MAXP_TAG, &table))
2796 return 0;
2797
2798 num_glyphs = table_read_be_word(&table, FIELD_OFFSET(struct maxp, num_glyphs));
2799
2800 IDWriteFontFace5_ReleaseFontTable(fontface, table.context);
2801
2802 memset(&table, 0, sizeof(table));
2803 table.exists = TRUE;
2804
2805 if (!get_fontface_table(fontface, MS_SBIX_TAG, &table))
2806 return 0;
2807
2808 num_strikes = table_read_be_dword(&table, FIELD_OFFSET(struct sbix_header, num_strikes));
2809 sbix_header = table_read_ensure(&table, 0, FIELD_OFFSET(struct sbix_header, strike_offset[num_strikes]));
2810
2811 if (sbix_header)
2812 {
2813 for (i = 0; i < num_strikes; ++i)
2814 {
2815 unsigned int strike_offset = GET_BE_DWORD(sbix_header->strike_offset[i]);
2816 const struct sbix_strike *strike = table_read_ensure(&table, strike_offset,
2817 FIELD_OFFSET(struct sbix_strike, glyphdata_offsets[num_glyphs + 1]));
2818
2819 if (!strike)
2820 continue;
2821
2822 for (j = 0; j < num_glyphs; j++)
2823 {
2824 unsigned int offset = GET_BE_DWORD(strike->glyphdata_offsets[j]);
2825 unsigned int next_offset = GET_BE_DWORD(strike->glyphdata_offsets[j + 1]);
2826 const struct sbix_glyph_data *glyph_data;
2827
2828 if (offset == next_offset)
2829 continue;
2830
2831 glyph_data = table_read_ensure(&table, strike_offset + offset, sizeof(*glyph_data));
2832 if (!glyph_data)
2833 continue;
2834
2835 switch (glyph_data->graphic_type)
2836 {
2837 case MS_PNG__TAG:
2838 ret |= DWRITE_GLYPH_IMAGE_FORMATS_PNG;
2839 break;
2840 case MS_JPG__TAG:
2841 ret |= DWRITE_GLYPH_IMAGE_FORMATS_JPEG;
2842 break;
2843 case MS_TIFF_TAG:
2844 ret |= DWRITE_GLYPH_IMAGE_FORMATS_TIFF;
2845 break;
2846 default:
2847 FIXME("unexpected bitmap format %s\n", debugstr_tag(GET_BE_DWORD(glyph_data->graphic_type)));
2848 }
2849 }
2850 }
2851 }
2852
2853 IDWriteFontFace5_ReleaseFontTable(fontface, table.context);
2854
2855 return ret;
2856 }
2857
2858 static unsigned int opentype_get_cblc_formats(IDWriteFontFace5 *fontface)
2859 {
2860 const unsigned int format_mask = DWRITE_GLYPH_IMAGE_FORMATS_PNG |
2861 DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8;
2862 const struct cblc_bitmapsize_table *sizes;
2863 struct dwrite_fonttable cblc = { 0 };
2864 unsigned int num_sizes, i, ret = 0;
2865 const struct cblc_header *header;
2866
2867 cblc.exists = TRUE;
2868 if (!get_fontface_table(fontface, MS_CBLC_TAG, &cblc))
2869 return 0;
2870
2871 num_sizes = table_read_be_dword(&cblc, FIELD_OFFSET(struct cblc_header, num_sizes));
2872 sizes = table_read_ensure(&cblc, sizeof(*header), num_sizes * sizeof(*sizes));
2873
2874 if (sizes)
2875 {
2876 for (i = 0; i < num_sizes; ++i)
2877 {
2878 BYTE bpp = sizes[i].bit_depth;
2879
2880 if ((ret & format_mask) == format_mask)
2881 break;
2882
2883 if (bpp == 1 || bpp == 2 || bpp == 4 || bpp == 8)
2884 ret |= DWRITE_GLYPH_IMAGE_FORMATS_PNG;
2885 else if (bpp == 32)
2886 ret |= DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8;
2887 }
2888 }
2889
2890 IDWriteFontFace5_ReleaseFontTable(fontface, cblc.context);
2891
2892 return ret;
2893 }
2894
2895 UINT32 opentype_get_glyph_image_formats(IDWriteFontFace5 *fontface)
2896 {
2897 UINT32 ret = DWRITE_GLYPH_IMAGE_FORMATS_NONE;
2898
2899 if (opentype_has_font_table(fontface, MS_GLYF_TAG))
2900 ret |= DWRITE_GLYPH_IMAGE_FORMATS_TRUETYPE;
2901
2902 if (opentype_has_font_table(fontface, MS_CFF__TAG) ||
2903 opentype_has_font_table(fontface, MS_CFF2_TAG))
2904 ret |= DWRITE_GLYPH_IMAGE_FORMATS_CFF;
2905
2906 if (opentype_has_font_table(fontface, MS_COLR_TAG))
2907 ret |= DWRITE_GLYPH_IMAGE_FORMATS_COLR;
2908
2909 if (opentype_has_font_table(fontface, MS_SVG__TAG))
2910 ret |= DWRITE_GLYPH_IMAGE_FORMATS_SVG;
2911
2912 if (opentype_has_font_table(fontface, MS_SBIX_TAG))
2913 ret |= opentype_get_sbix_formats(fontface);
2914
2915 if (opentype_has_font_table(fontface, MS_CBLC_TAG))
2916 ret |= opentype_get_cblc_formats(fontface);
2917
2918 return ret;
2919 }
2920
2921 DWRITE_CONTAINER_TYPE opentype_analyze_container_type(void const *data, UINT32 data_size)
2922 {
2923 DWORD signature;
2924
2925 if (data_size < sizeof(DWORD))
2926 return DWRITE_CONTAINER_TYPE_UNKNOWN;
2927
2928 /* Both WOFF and WOFF2 start with 4 bytes signature. */
2929 signature = *(DWORD *)data;
2930
2931 switch (signature)
2932 {
2933 case MS_WOFF_TAG:
2934 return DWRITE_CONTAINER_TYPE_WOFF;
2935 case MS_WOF2_TAG:
2936 return DWRITE_CONTAINER_TYPE_WOFF2;
2937 default:
2938 return DWRITE_CONTAINER_TYPE_UNKNOWN;
2939 }
2940 }
2941
2942 void opentype_layout_scriptshaping_cache_init(struct scriptshaping_cache *cache)
2943 {
2944 cache->font->grab_font_table(cache->context, MS_GPOS_TAG, &cache->gpos.table.data, &cache->gpos.table.size,
2945 &cache->gpos.table.context);
2946
2947 if (cache->gpos.table.data)
2948 {
2949 cache->gpos.script_list = table_read_be_word(&cache->gpos.table,
2950 FIELD_OFFSET(struct gpos_gsub_header, script_list));
2951 cache->gpos.feature_list = table_read_be_word(&cache->gpos.table,
2952 FIELD_OFFSET(struct gpos_gsub_header, feature_list));
2953 cache->gpos.lookup_list = table_read_be_word(&cache->gpos.table,
2954 FIELD_OFFSET(struct gpos_gsub_header, lookup_list));
2955 }
2956
2957 cache->font->grab_font_table(cache->context, MS_GDEF_TAG, &cache->gdef.table.data, &cache->gdef.table.size,
2958 &cache->gdef.table.context);
2959
2960 if (cache->gdef.table.data)
2961 cache->gdef.classdef = table_read_be_word(&cache->gdef.table, FIELD_OFFSET(struct gdef_header, classdef));
2962 }
2963
2964 DWORD opentype_layout_find_script(const struct scriptshaping_cache *cache, DWORD kind, DWORD script,
2965 unsigned int *script_index)
2966 {
2967 WORD script_count;
2968 unsigned int i;
2969
2970 *script_index = ~0u;
2971
2972 if (kind != MS_GPOS_TAG)
2973 return 0;
2974
2975 script_count = table_read_be_word(&cache->gpos.table, cache->gpos.script_list);
2976 if (!script_count)
2977 return 0;
2978
2979 for (i = 0; i < script_count; i++)
2980 {
2981 DWORD tag = table_read_dword(&cache->gpos.table, cache->gpos.script_list +
2982 FIELD_OFFSET(struct ot_script_list, scripts) + i * sizeof(struct ot_script_record));
2983 if (!tag)
2984 continue;
2985
2986 if (tag == script)
2987 {
2988 *script_index = i;
2989 return script;
2990 }
2991 }
2992
2993 return 0;
2994 }
2995
2996 DWORD opentype_layout_find_language(const struct scriptshaping_cache *cache, DWORD kind, DWORD language,
2997 unsigned int script_index, unsigned int *language_index)
2998 {
2999 WORD table_offset, lang_count;
3000 unsigned int i;
3001
3002 *language_index = ~0u;
3003
3004 if (kind != MS_GPOS_TAG)
3005 return 0;
3006
3007 table_offset = table_read_be_word(&cache->gpos.table, cache->gpos.script_list +
3008 FIELD_OFFSET(struct ot_script_list, scripts) + script_index * sizeof(struct ot_script_record) +
3009 FIELD_OFFSET(struct ot_script_record, script));
3010 if (!table_offset)
3011 return 0;
3012
3013 lang_count = table_read_be_word(&cache->gpos.table, cache->gpos.script_list + table_offset +
3014 FIELD_OFFSET(struct ot_script, langsys_count));
3015 for (i = 0; i < lang_count; i++)
3016 {
3017 DWORD tag = table_read_dword(&cache->gpos.table, cache->gpos.script_list + table_offset +
3018 FIELD_OFFSET(struct ot_script, langsys) + i * sizeof(struct ot_langsys_record));
3019
3020 if (tag == language)
3021 {
3022 *language_index = i;
3023 return language;
3024 }
3025 }
3026
3027 /* Try 'defaultLangSys' if it's set. */
3028 if (table_read_be_word(&cache->gpos.table, cache->gpos.script_list + table_offset))
3029 return ~0u;
3030
3031 return 0;
3032 }
3033
3034 static int gdef_class_compare_format2(const void *g, const void *r)
3035 {
3036 const struct ot_gdef_class_range *range = r;
3037 UINT16 glyph = *(UINT16 *)g;
3038
3039 if (glyph < GET_BE_WORD(range->start_glyph))
3040 return -1;
3041 else if (glyph > GET_BE_WORD(range->end_glyph))
3042 return 1;
3043 else
3044 return 0;
3045 }
3046
3047 static unsigned int opentype_layout_get_glyph_class(const struct dwrite_fonttable *table,
3048 unsigned int offset, UINT16 glyph)
3049 {
3050 WORD format = table_read_be_word(table, offset), count;
3051 unsigned int glyph_class = GDEF_CLASS_UNCLASSIFIED;
3052
3053 if (format == 1)
3054 {
3055 const struct ot_gdef_classdef_format1 *format1;
3056
3057 count = table_read_be_word(table, offset + FIELD_OFFSET(struct ot_gdef_classdef_format1, glyph_count));
3058 format1 = table_read_ensure(table, offset, FIELD_OFFSET(struct ot_gdef_classdef_format1, classes[count]));
3059 if (format1)
3060 {
3061 WORD start_glyph = GET_BE_WORD(format1->start_glyph);
3062 if (glyph >= start_glyph && (glyph - start_glyph) < count)
3063 {
3064 glyph_class = GET_BE_WORD(format1->classes[glyph - start_glyph]);
3065 if (glyph_class > GDEF_CLASS_MAX)
3066 glyph_class = GDEF_CLASS_UNCLASSIFIED;
3067 }
3068 }
3069 }
3070 else if (format == 2)
3071 {
3072 const struct ot_gdef_classdef_format2 *format2;
3073
3074 count = table_read_be_word(table, offset + FIELD_OFFSET(struct ot_gdef_classdef_format2, range_count));
3075 format2 = table_read_ensure(table, offset, FIELD_OFFSET(struct ot_gdef_classdef_format2, ranges[count]));
3076 if (format2)
3077 {
3078 const struct ot_gdef_class_range *range = bsearch(&glyph, format2->ranges, count,
3079 sizeof(struct ot_gdef_class_range), gdef_class_compare_format2);
3080 glyph_class = range && glyph <= GET_BE_WORD(range->end_glyph) ?
3081 GET_BE_WORD(range->glyph_class) : GDEF_CLASS_UNCLASSIFIED;
3082 if (glyph_class > GDEF_CLASS_MAX)
3083 glyph_class = GDEF_CLASS_UNCLASSIFIED;
3084 }
3085 }
3086 else
3087 WARN("Unknown GDEF format %u.\n", format);
3088
3089 return glyph_class;
3090 }
3091
3092 struct coverage_compare_format1_context
3093 {
3094 UINT16 glyph;
3095 const UINT16 *table_base;
3096 unsigned int *coverage_index;
3097 };
3098
3099 static int coverage_compare_format1(const void *left, const void *right)
3100 {
3101 const struct coverage_compare_format1_context *context = left;
3102 UINT16 glyph = GET_BE_WORD(*(UINT16 *)right);
3103 int ret;
3104
3105 ret = context->glyph - glyph;
3106 if (!ret)
3107 *context->coverage_index = (UINT16 *)right - context->table_base;
3108
3109 return ret;
3110 }
3111
3112 static int coverage_compare_format2(const void *g, const void *r)
3113 {
3114 const struct ot_coverage_range *range = r;
3115 UINT16 glyph = *(UINT16 *)g;
3116
3117 if (glyph < GET_BE_WORD(range->start_glyph))
3118 return -1;
3119 else if (glyph > GET_BE_WORD(range->end_glyph))
3120 return 1;
3121 else
3122 return 0;
3123 }
3124
3125 static unsigned int opentype_layout_is_glyph_covered(const struct dwrite_fonttable *table, DWORD coverage,
3126 UINT16 glyph)
3127 {
3128 WORD format = table_read_be_word(table, coverage), count;
3129
3130 count = table_read_be_word(table, coverage + 2);
3131
3132 if (format == 1)
3133 {
3134 const struct ot_coverage_format1 *format1 = table_read_ensure(table, coverage,
3135 FIELD_OFFSET(struct ot_coverage_format1, glyphs[count]));
3136 struct coverage_compare_format1_context context;
3137 unsigned int coverage_index = GLYPH_NOT_COVERED;
3138
3139 if (format1)
3140 {
3141 context.glyph = glyph;
3142 context.table_base = format1->glyphs;
3143 context.coverage_index = &coverage_index;
3144
3145 bsearch(&context, format1->glyphs, count, sizeof(glyph), coverage_compare_format1);
3146 }
3147
3148 return coverage_index;
3149 }
3150 else if (format == 2)
3151 {
3152 const struct ot_coverage_format2 *format2 = table_read_ensure(table, coverage,
3153 FIELD_OFFSET(struct ot_coverage_format2, ranges[count]));
3154 if (format2)
3155 {
3156 const struct ot_coverage_range *range = bsearch(&glyph, format2->ranges, count,
3157 sizeof(struct ot_coverage_range), coverage_compare_format2);
3158 return range && glyph <= GET_BE_WORD(range->end_glyph) ?
3159 GET_BE_WORD(range->startcoverage_index) + glyph - GET_BE_WORD(range->start_glyph) :
3160 GLYPH_NOT_COVERED;
3161 }
3162 }
3163 else
3164 WARN("Unknown coverage format %u.\n", format);
3165
3166 return -1;
3167 }
3168
3169 static inline unsigned int dwrite_popcount(unsigned int x)
3170 {
3171 #ifdef HAVE___BUILTIN_POPCOUNT
3172 return __builtin_popcount(x);
3173 #else
3174 x -= x >> 1 & 0x55555555;
3175 x = (x & 0x33333333) + (x >> 2 & 0x33333333);
3176 return ((x + (x >> 4)) & 0x0f0f0f0f) * 0x01010101 >> 24;
3177 #endif
3178 }
3179
3180 static float opentype_scale_gpos_be_value(WORD value, float emsize, UINT16 upem)
3181 {
3182 return (short)GET_BE_WORD(value) * emsize / upem;
3183 }
3184
3185 static int opentype_layout_gpos_get_dev_value(const struct scriptshaping_context *context, unsigned int offset)
3186 {
3187 const struct scriptshaping_cache *cache = context->cache;
3188 unsigned int start_size, end_size, format, value_word;
3189 unsigned int index, ppem, mask;
3190 int value;
3191
3192 if (!offset)
3193 return 0;
3194
3195 start_size = table_read_be_word(&cache->gpos.table, offset);
3196 end_size = table_read_be_word(&cache->gpos.table, offset + FIELD_OFFSET(struct ot_gpos_device_table, end_size));
3197
3198 ppem = context->emsize;
3199 if (ppem < start_size || ppem > end_size)
3200 return 0;
3201
3202 format = table_read_be_word(&cache->gpos.table, offset + FIELD_OFFSET(struct ot_gpos_device_table, format));
3203
3204 if (format < 1 || format > 3)
3205 return 0;
3206
3207 index = ppem - start_size;
3208
3209 value_word = table_read_be_word(&cache->gpos.table, offset +
3210 FIELD_OFFSET(struct ot_gpos_device_table, values[index >> (4 - format)]));
3211 mask = 0xffff >> (16 - (1 << format));
3212
3213 value = (value_word >> ((index % (4 - format)) * (1 << format))) & mask;
3214
3215 if ((unsigned int)value >= ((mask + 1) >> 1))
3216 value -= mask + 1;
3217
3218 return value;
3219 }
3220
3221 static void opentype_layout_apply_gpos_value(struct scriptshaping_context *context, unsigned int table_offset,
3222 WORD value_format, const WORD *values, unsigned int glyph)
3223 {
3224 const struct scriptshaping_cache *cache = context->cache;
3225 DWRITE_GLYPH_OFFSET *offset = &context->offsets[glyph];
3226 float *advance = &context->advances[glyph];
3227
3228 if (!value_format)
3229 return;
3230
3231 if (value_format & GPOS_VALUE_X_PLACEMENT)
3232 {
3233 offset->advanceOffset += opentype_scale_gpos_be_value(*values, context->emsize, cache->upem);
3234 values++;
3235 }
3236 if (value_format & GPOS_VALUE_Y_PLACEMENT)
3237 {
3238 offset->ascenderOffset += opentype_scale_gpos_be_value(*values, context->emsize, cache->upem);
3239 values++;
3240 }
3241 if (value_format & GPOS_VALUE_X_ADVANCE)
3242 {
3243 *advance += opentype_scale_gpos_be_value(*values, context->emsize, cache->upem);
3244 values++;
3245 }
3246 if (value_format & GPOS_VALUE_Y_ADVANCE)
3247 {
3248 values++;
3249 }
3250 if (value_format & GPOS_VALUE_X_PLACEMENT_DEVICE)
3251 {
3252 offset->advanceOffset += opentype_layout_gpos_get_dev_value(context, table_offset + GET_BE_WORD(*values));
3253 values++;
3254 }
3255 if (value_format & GPOS_VALUE_Y_PLACEMENT_DEVICE)
3256 {
3257 offset->ascenderOffset += opentype_layout_gpos_get_dev_value(context, table_offset + GET_BE_WORD(*values));
3258 values++;
3259 }
3260 if (value_format & GPOS_VALUE_X_ADVANCE_DEVICE)
3261 {
3262 *advance += opentype_layout_gpos_get_dev_value(context, table_offset + GET_BE_WORD(*values));
3263 values++;
3264 }
3265 if (value_format & GPOS_VALUE_Y_ADVANCE_DEVICE)
3266 {
3267 values++;
3268 }
3269 }
3270
3271 static unsigned int opentype_layout_get_gpos_subtable(const struct scriptshaping_cache *cache,
3272 unsigned int lookup_offset, unsigned int subtable)
3273 {
3274 WORD lookup_type = table_read_be_word(&cache->gpos.table, lookup_offset);
3275 unsigned int subtable_offset = table_read_be_word(&cache->gpos.table, lookup_offset +
3276 FIELD_OFFSET(struct ot_lookup_table, subtable[subtable]));
3277 if (lookup_type == GPOS_LOOKUP_EXTENSION_POSITION)
3278 {
3279 const struct ot_gpos_extensionpos_format1 *format1 = table_read_ensure(&cache->gpos.table,
3280 lookup_offset + subtable_offset, sizeof(*format1));
3281 subtable_offset += GET_BE_DWORD(format1->extension_offset);
3282 }
3283
3284 return lookup_offset + subtable_offset;
3285 }
3286
3287 struct lookup
3288 {
3289 unsigned int offset;
3290 unsigned int subtable_count;
3291 unsigned int flags;
3292 };
3293
3294 struct glyph_iterator
3295 {
3296 const struct scriptshaping_context *context;
3297 unsigned int flags;
3298 unsigned int pos;
3299 unsigned int len;
3300 };
3301
3302 static void glyph_iterator_init(const struct scriptshaping_context *context, unsigned int flags, unsigned int pos,
3303 unsigned int len, struct glyph_iterator *iter)
3304 {
3305 iter->context = context;
3306 iter->flags = flags;
3307 iter->pos = pos;
3308 iter->len = len;
3309 }
3310
3311 static BOOL glyph_iterator_match(const struct glyph_iterator *iter)
3312 {
3313 struct scriptshaping_cache *cache = iter->context->cache;
3314
3315 if (cache->gdef.classdef)
3316 {
3317 unsigned int glyph_class = opentype_layout_get_glyph_class(&cache->gdef.table, cache->gdef.classdef,
3318 iter->context->u.pos.glyphs[iter->pos]);
3319 if ((1 << glyph_class) & iter->flags & LOOKUP_FLAG_IGNORE_MASK)
3320 return FALSE;
3321 }
3322
3323 return TRUE;
3324 }
3325
3326 static BOOL glyph_iterator_next(struct glyph_iterator *iter)
3327 {
3328 while (iter->pos + iter->len < iter->context->glyph_count)
3329 {
3330 ++iter->pos;
3331 if (glyph_iterator_match(iter))
3332 {
3333 --iter->len;
3334 return TRUE;
3335 }
3336 }
3337
3338 return FALSE;
3339 }
3340
3341 static BOOL glyph_iterator_prev(struct glyph_iterator *iter)
3342 {
3343 if (!iter->pos)
3344 return FALSE;
3345
3346 while (iter->pos > iter->len - 1)
3347 {
3348 --iter->pos;
3349 if (glyph_iterator_match(iter))
3350 {
3351 --iter->len;
3352 return TRUE;
3353 }
3354 }
3355
3356 return FALSE;
3357 }
3358
3359 static BOOL opentype_layout_apply_gpos_single_adjustment(struct scriptshaping_context *context,
3360 struct glyph_iterator *iter, const struct lookup *lookup)
3361 {
3362 struct scriptshaping_cache *cache = context->cache;
3363 WORD format, value_format, value_len, coverage;
3364 unsigned int i;
3365
3366 for (i = 0; i < lookup->subtable_count; ++i)
3367 {
3368 unsigned int subtable_offset = opentype_layout_get_gpos_subtable(cache, lookup->offset, i);
3369 unsigned int coverage_index;
3370
3371 format = table_read_be_word(&cache->gpos.table, subtable_offset);
3372
3373 coverage = table_read_be_word(&cache->gpos.table, subtable_offset +
3374 FIELD_OFFSET(struct ot_gpos_singlepos_format1, coverage));
3375 value_format = table_read_be_word(&cache->gpos.table, subtable_offset +
3376 FIELD_OFFSET(struct ot_gpos_singlepos_format1, value_format));
3377 value_len = dwrite_popcount(value_format);
3378
3379 if (format == 1)
3380 {
3381 const struct ot_gpos_singlepos_format1 *format1 = table_read_ensure(&cache->gpos.table, subtable_offset,
3382 FIELD_OFFSET(struct ot_gpos_singlepos_format1, value[value_len]));
3383
3384 coverage_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset + coverage,
3385 context->u.pos.glyphs[iter->pos]);
3386 if (coverage_index == GLYPH_NOT_COVERED)
3387 continue;
3388
3389 opentype_layout_apply_gpos_value(context, subtable_offset, value_format, format1->value, iter->pos);
3390 break;
3391 }
3392 else if (format == 2)
3393 {
3394 WORD value_count = table_read_be_word(&cache->gpos.table, subtable_offset +
3395 FIELD_OFFSET(struct ot_gpos_singlepos_format2, value_count));
3396 const struct ot_gpos_singlepos_format2 *format2 = table_read_ensure(&cache->gpos.table, subtable_offset,
3397 FIELD_OFFSET(struct ot_gpos_singlepos_format2, values) + value_count * value_len * sizeof(WORD));
3398
3399 coverage_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset + coverage,
3400 context->u.pos.glyphs[iter->pos]);
3401 if (coverage_index == GLYPH_NOT_COVERED || coverage_index >= value_count)
3402 continue;
3403
3404 opentype_layout_apply_gpos_value(context, subtable_offset, value_format,
3405 &format2->values[coverage_index * value_len], iter->pos);
3406 break;
3407 }
3408 else
3409 WARN("Unknown single adjustment format %u.\n", format);
3410 }
3411
3412 return FALSE;
3413 }
3414
3415 static int gpos_pair_adjustment_compare_format1(const void *g, const void *r)
3416 {
3417 const struct ot_gpos_pairvalue *pairvalue = r;
3418 UINT16 second_glyph = GET_BE_WORD(pairvalue->second_glyph);
3419 return *(UINT16 *)g - second_glyph;
3420 }
3421
3422 static BOOL opentype_layout_apply_gpos_pair_adjustment(struct scriptshaping_context *context,
3423 struct glyph_iterator *iter, const struct lookup *lookup)
3424 {
3425 struct scriptshaping_cache *cache = context->cache;
3426 unsigned int i, first_glyph, second_glyph;
3427 struct glyph_iterator iter_pair;
3428 WORD format, coverage;
3429
3430 glyph_iterator_init(context, iter->flags, iter->pos, 1, &iter_pair);
3431 if (!glyph_iterator_next(&iter_pair))
3432 return FALSE;
3433
3434 if (context->is_rtl)
3435 {
3436 first_glyph = iter_pair.pos;
3437 second_glyph = iter->pos;
3438 }
3439 else
3440 {
3441 first_glyph = iter->pos;
3442 second_glyph = iter_pair.pos;
3443 }
3444
3445 for (i = 0; i < lookup->subtable_count; ++i)
3446 {
3447 unsigned int subtable_offset = opentype_layout_get_gpos_subtable(cache, lookup->offset, i);
3448 WORD value_format1, value_format2, value_len1, value_len2;
3449 unsigned int coverage_index;
3450
3451 format = table_read_be_word(&cache->gpos.table, subtable_offset);
3452
3453 coverage = table_read_be_word(&cache->gpos.table, subtable_offset +
3454 FIELD_OFFSET(struct ot_gpos_pairpos_format1, coverage));
3455 if (!coverage)
3456 continue;
3457
3458 coverage_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3459 coverage, context->u.pos.glyphs[first_glyph]);
3460 if (coverage_index == GLYPH_NOT_COVERED)
3461 continue;
3462
3463 if (format == 1)
3464 {
3465 const struct ot_gpos_pairpos_format1 *format1;
3466 WORD pairset_count = table_read_be_word(&cache->gpos.table, subtable_offset +
3467 FIELD_OFFSET(struct ot_gpos_pairpos_format1, pairset_count));
3468 unsigned int pairvalue_len, pairset_offset;
3469 const struct ot_gpos_pairset *pairset;
3470 const WORD *pairvalue;
3471 WORD pairvalue_count;
3472
3473 if (!pairset_count || coverage_index >= pairset_count)
3474 continue;
3475
3476 format1 = table_read_ensure(&cache->gpos.table, subtable_offset,
3477 FIELD_OFFSET(struct ot_gpos_pairpos_format1, pairsets[pairset_count]));
3478 if (!format1)
3479 continue;
3480
3481 /* Ordered paired values. */
3482 pairvalue_count = table_read_be_word(&cache->gpos.table, subtable_offset +
3483 GET_BE_WORD(format1->pairsets[coverage_index]));
3484 if (!pairvalue_count)
3485 continue;
3486
3487 /* Structure length is variable, but does not change across the subtable. */
3488 value_format1 = GET_BE_WORD(format1->value_format1) & 0xff;
3489 value_format2 = GET_BE_WORD(format1->value_format2) & 0xff;
3490
3491 value_len1 = dwrite_popcount(value_format1);
3492 value_len2 = dwrite_popcount(value_format2);
3493 pairvalue_len = FIELD_OFFSET(struct ot_gpos_pairvalue, data) + value_len1 * sizeof(WORD) +
3494 value_len2 * sizeof(WORD);
3495
3496 pairset_offset = subtable_offset + GET_BE_WORD(format1->pairsets[coverage_index]);
3497 pairset = table_read_ensure(&cache->gpos.table, subtable_offset + pairset_offset,
3498 pairvalue_len * pairvalue_count);
3499 if (!pairset)
3500 continue;
3501
3502 pairvalue = bsearch(&context->u.pos.glyphs[second_glyph], pairset->pairvalues, pairvalue_count,
3503 pairvalue_len, gpos_pair_adjustment_compare_format1);
3504 if (!pairvalue)
3505 continue;
3506
3507 pairvalue += 1; /* Skip SecondGlyph. */
3508 opentype_layout_apply_gpos_value(context, pairset_offset, value_format1, pairvalue, first_glyph);
3509 opentype_layout_apply_gpos_value(context, pairset_offset, value_format2, pairvalue + value_len1,
3510 second_glyph);
3511
3512 iter->pos = iter_pair.pos;
3513 if (value_len2)
3514 iter->pos++;
3515
3516 return TRUE;
3517 }
3518 else if (format == 2)
3519 {
3520 const struct ot_gpos_pairpos_format2 *format2;
3521 WORD class1_count, class2_count;
3522 unsigned int class1, class2;
3523
3524 value_format1 = table_read_be_word(&cache->gpos.table, subtable_offset +
3525 FIELD_OFFSET(struct ot_gpos_pairpos_format2, value_format1)) & 0xff;
3526 value_format2 = table_read_be_word(&cache->gpos.table, subtable_offset +
3527 FIELD_OFFSET(struct ot_gpos_pairpos_format2, value_format2)) & 0xff;
3528
3529 class1_count = table_read_be_word(&cache->gpos.table, subtable_offset +
3530 FIELD_OFFSET(struct ot_gpos_pairpos_format2, class1_count));
3531 class2_count = table_read_be_word(&cache->gpos.table, subtable_offset +
3532 FIELD_OFFSET(struct ot_gpos_pairpos_format2, class2_count));
3533
3534 value_len1 = dwrite_popcount(value_format1);
3535 value_len2 = dwrite_popcount(value_format2);
3536
3537 format2 = table_read_ensure(&cache->gpos.table, subtable_offset,
3538 FIELD_OFFSET(struct ot_gpos_pairpos_format2,
3539 values[class1_count * class2_count * (value_len1 + value_len2)]));
3540 if (!format2)
3541 continue;
3542
3543 class1 = opentype_layout_get_glyph_class(&cache->gpos.table, subtable_offset + GET_BE_WORD(format2->class_def1),
3544 context->u.pos.glyphs[first_glyph]);
3545 class2 = opentype_layout_get_glyph_class(&cache->gpos.table, subtable_offset + GET_BE_WORD(format2->class_def2),
3546 context->u.pos.glyphs[second_glyph]);
3547
3548 if (class1 < class1_count && class2 < class2_count)
3549 {
3550 const WCHAR *values = &format2->values[(class1 * class2_count + class2) * (value_len1 + value_len2)];
3551 opentype_layout_apply_gpos_value(context, subtable_offset, value_format1, values, first_glyph);
3552 opentype_layout_apply_gpos_value(context, subtable_offset, value_format2, values + value_len1,
3553 second_glyph);
3554
3555 iter->pos = iter_pair.pos;
3556 if (value_len2)
3557 iter->pos++;
3558
3559 return TRUE;
3560 }
3561 }
3562 else
3563 {
3564 WARN("Unknown pair adjustment format %u.\n", format);
3565 continue;
3566 }
3567 }
3568
3569 return FALSE;
3570 }
3571
3572 static void opentype_layout_gpos_get_anchor(const struct scriptshaping_context *context, unsigned int anchor_offset,
3573 unsigned int glyph_index, float *x, float *y)
3574 {
3575 const struct scriptshaping_cache *cache = context->cache;
3576
3577 WORD format = table_read_be_word(&cache->gpos.table, anchor_offset);
3578
3579 *x = *y = 0.0f;
3580
3581 if (format == 1)
3582 {
3583 const struct ot_gpos_anchor_format1 *format1 = table_read_ensure(&cache->gpos.table, anchor_offset,
3584 sizeof(*format1));
3585
3586 if (format1)
3587 {
3588 *x = opentype_scale_gpos_be_value(format1->x_coord, context->emsize, cache->upem);
3589 *y = opentype_scale_gpos_be_value(format1->y_coord, context->emsize, cache->upem);
3590 }
3591 }
3592 else if (format == 2)
3593 {
3594 const struct ot_gpos_anchor_format2 *format2 = table_read_ensure(&cache->gpos.table, anchor_offset,
3595 sizeof(*format2));
3596
3597 if (format2)
3598 {
3599 if (context->measuring_mode != DWRITE_MEASURING_MODE_NATURAL)
3600 FIXME("Use outline anchor point for glyph %u.\n", context->u.pos.glyphs[glyph_index]);
3601
3602 *x = opentype_scale_gpos_be_value(format2->x_coord, context->emsize, cache->upem);
3603 *y = opentype_scale_gpos_be_value(format2->y_coord, context->emsize, cache->upem);
3604 }
3605 }
3606 else if (format == 3)
3607 {
3608 const struct ot_gpos_anchor_format3 *format3 = table_read_ensure(&cache->gpos.table, anchor_offset,
3609 sizeof(*format3));
3610
3611 if (format3)
3612 {
3613 *x = opentype_scale_gpos_be_value(format3->x_coord, context->emsize, cache->upem);
3614 *y = opentype_scale_gpos_be_value(format3->y_coord, context->emsize, cache->upem);
3615
3616 if (context->measuring_mode != DWRITE_MEASURING_MODE_NATURAL)
3617 {
3618 if (format3->x_dev_offset)
3619 *x += opentype_layout_gpos_get_dev_value(context, anchor_offset + GET_BE_WORD(format3->x_dev_offset));
3620 if (format3->y_dev_offset)
3621 *y += opentype_layout_gpos_get_dev_value(context, anchor_offset + GET_BE_WORD(format3->y_dev_offset));
3622 }
3623 }
3624 }
3625 else
3626 WARN("Unknown anchor format %u.\n", format);
3627 }
3628
3629 static BOOL opentype_layout_apply_gpos_cursive_attachment(struct scriptshaping_context *context,
3630 struct glyph_iterator *iter, const struct lookup *lookup)
3631 {
3632 struct scriptshaping_cache *cache = context->cache;
3633 unsigned int i;
3634
3635 for (i = 0; i < lookup->subtable_count; ++i)
3636 {
3637 unsigned int subtable_offset = opentype_layout_get_gpos_subtable(cache, lookup->offset, i);
3638 WORD format;
3639
3640 format = table_read_be_word(&cache->gpos.table, subtable_offset);
3641
3642 if (format == 1)
3643 {
3644 WORD coverage_offset = table_read_be_word(&cache->gpos.table, subtable_offset +
3645 FIELD_OFFSET(struct ot_gpos_cursive_format1, coverage));
3646 unsigned int glyph_index, entry_count, entry_anchor, exit_anchor;
3647 float entry_x, entry_y, exit_x, exit_y, delta;
3648 struct glyph_iterator prev_iter;
3649
3650 if (!coverage_offset)
3651 continue;
3652
3653 entry_count = table_read_be_word(&cache->gpos.table, subtable_offset +
3654 FIELD_OFFSET(struct ot_gpos_cursive_format1, count));
3655
3656 glyph_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3657 coverage_offset, context->u.pos.glyphs[iter->pos]);
3658 if (glyph_index == GLYPH_NOT_COVERED || glyph_index >= entry_count)
3659 continue;
3660
3661 entry_anchor = table_read_be_word(&cache->gpos.table, subtable_offset +
3662 FIELD_OFFSET(struct ot_gpos_cursive_format1, anchors[glyph_index * 2]));
3663 if (!entry_anchor)
3664 continue;
3665
3666 glyph_iterator_init(context, iter->flags, iter->pos, 1, &prev_iter);
3667 if (!glyph_iterator_prev(&prev_iter))
3668 continue;
3669
3670 glyph_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3671 coverage_offset, context->u.pos.glyphs[prev_iter.pos]);
3672 if (glyph_index == GLYPH_NOT_COVERED || glyph_index >= entry_count)
3673 continue;
3674
3675 exit_anchor = table_read_be_word(&cache->gpos.table, subtable_offset +
3676 FIELD_OFFSET(struct ot_gpos_cursive_format1, anchors[glyph_index * 2 + 1]));
3677 if (!exit_anchor)
3678 continue;
3679
3680 opentype_layout_gpos_get_anchor(context, subtable_offset + exit_anchor, prev_iter.pos, &exit_x, &exit_y);
3681 opentype_layout_gpos_get_anchor(context, subtable_offset + entry_anchor, iter->pos, &entry_x, &entry_y);
3682
3683 if (context->is_rtl)
3684 {
3685 delta = exit_x + context->offsets[prev_iter.pos].advanceOffset;
3686 context->advances[prev_iter.pos] -= delta;
3687 context->advances[iter->pos] = entry_x + context->offsets[iter->pos].advanceOffset;
3688 context->offsets[prev_iter.pos].advanceOffset -= delta;
3689 }
3690 else
3691 {
3692 delta = entry_x + context->offsets[iter->pos].advanceOffset;
3693 context->advances[prev_iter.pos] = exit_x + context->offsets[prev_iter.pos].advanceOffset;
3694 context->advances[iter->pos] -= delta;
3695 context->offsets[iter->pos].advanceOffset -= delta;
3696 }
3697
3698 if (lookup->flags & LOOKUP_FLAG_RTL)
3699 context->offsets[prev_iter.pos].ascenderOffset = entry_y - exit_y;
3700 else
3701 context->offsets[iter->pos].ascenderOffset = exit_y - entry_y;
3702
3703 break;
3704 }
3705 else
3706 WARN("Unknown cursive attachment format %u.\n", format);
3707
3708 }
3709
3710 return FALSE;
3711 }
3712
3713 static BOOL opentype_layout_apply_gpos_mark_to_base_attachment(const struct scriptshaping_context *context,
3714 struct glyph_iterator *iter, const struct lookup *lookup)
3715 {
3716 struct scriptshaping_cache *cache = context->cache;
3717 unsigned int i;
3718 WORD format;
3719
3720 for (i = 0; i < lookup->subtable_count; ++i)
3721 {
3722 unsigned int subtable_offset = opentype_layout_get_gpos_subtable(cache, lookup->offset, i);
3723
3724 format = table_read_be_word(&cache->gpos.table, subtable_offset);
3725
3726 if (format == 1)
3727 {
3728 const struct ot_gpos_mark_to_base_format1 *format1 = table_read_ensure(&cache->gpos.table, subtable_offset,
3729 sizeof(*format1));
3730 unsigned int mark_class_count, count, mark_array_offset, base_array_offset;
3731 const struct ot_gpos_mark_array *mark_array;
3732 const struct ot_gpos_base_array *base_array;
3733 float mark_x, mark_y, base_x, base_y;
3734 unsigned int base_index, mark_index;
3735 struct glyph_iterator base_iter;
3736 unsigned int base_anchor;
3737
3738 if (!format1)
3739 continue;
3740
3741 mark_array_offset = subtable_offset + GET_BE_WORD(format1->mark_array);
3742 if (!(count = table_read_be_word(&cache->gpos.table, mark_array_offset)))
3743 continue;
3744
3745 mark_array = table_read_ensure(&cache->gpos.table, mark_array_offset,
3746 FIELD_OFFSET(struct ot_gpos_mark_array, records[count]));
3747 if (!mark_array)
3748 continue;
3749
3750 base_array_offset = subtable_offset + GET_BE_WORD(format1->base_array);
3751 if (!(count = table_read_be_word(&cache->gpos.table, base_array_offset)))
3752 continue;
3753
3754 base_array = table_read_ensure(&cache->gpos.table, base_array_offset,
3755 FIELD_OFFSET(struct ot_gpos_base_array, offsets[count * GET_BE_WORD(format1->mark_class_count)]));
3756 if (!base_array)
3757 continue;
3758
3759 mark_class_count = GET_BE_WORD(format1->mark_class_count);
3760
3761 mark_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3762 GET_BE_WORD(format1->mark_coverage), context->u.pos.glyphs[iter->pos]);
3763
3764 if (mark_index == GLYPH_NOT_COVERED || mark_index >= GET_BE_WORD(mark_array->count))
3765 continue;
3766
3767 /* Look back for first base glyph. */
3768 glyph_iterator_init(context, LOOKUP_FLAG_IGNORE_MARKS, iter->pos, 1, &base_iter);
3769 if (!glyph_iterator_prev(&base_iter))
3770 continue;
3771
3772 base_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3773 GET_BE_WORD(format1->base_coverage), context->u.pos.glyphs[base_iter.pos]);
3774 if (base_index == GLYPH_NOT_COVERED || base_index >= GET_BE_WORD(base_array->count))
3775 continue;
3776
3777 base_anchor = GET_BE_WORD(base_array->offsets[base_index * mark_class_count +
3778 GET_BE_WORD(mark_array->records[mark_index].mark_class)]);
3779
3780 opentype_layout_gpos_get_anchor(context, mark_array_offset +
3781 GET_BE_WORD(mark_array->records[mark_index].mark_anchor), iter->pos, &mark_x, &mark_y);
3782 opentype_layout_gpos_get_anchor(context, base_array_offset + base_anchor, base_iter.pos, &base_x, &base_y);
3783
3784 context->offsets[iter->pos].advanceOffset = (context->is_rtl ? -1.0f : 1.0f) * (base_x - mark_x);
3785 context->offsets[iter->pos].ascenderOffset = base_y - mark_y;
3786
3787 break;
3788 }
3789 else
3790 WARN("Unknown mark-to-base format %u.\n", format);
3791 }
3792
3793 return FALSE;
3794 }
3795
3796 static BOOL opentype_layout_apply_gpos_mark_to_lig_attachment(const struct scriptshaping_context *context,
3797 struct glyph_iterator *iter, const struct lookup *lookup)
3798 {
3799 struct scriptshaping_cache *cache = context->cache;
3800 unsigned int i;
3801 WORD format;
3802
3803 for (i = 0; i < lookup->subtable_count; ++i)
3804 {
3805 unsigned int subtable_offset = opentype_layout_get_gpos_subtable(cache, lookup->offset, i);
3806
3807 format = table_read_be_word(&cache->gpos.table, subtable_offset);
3808
3809 if (format == 1)
3810 {
3811 const struct ot_gpos_mark_to_lig_format1 *format1 = table_read_ensure(&cache->gpos.table,
3812 subtable_offset, sizeof(*format1));
3813 unsigned int mark_index, lig_index;
3814 struct glyph_iterator lig_iter;
3815
3816 if (!format1)
3817 continue;
3818
3819 mark_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3820 GET_BE_WORD(format1->mark_coverage), context->u.pos.glyphs[iter->pos]);
3821 if (mark_index == GLYPH_NOT_COVERED)
3822 continue;
3823
3824 glyph_iterator_init(context, LOOKUP_FLAG_IGNORE_MARKS, iter->pos, 1, &lig_iter);
3825 if (!glyph_iterator_prev(&lig_iter))
3826 continue;
3827
3828 lig_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3829 GET_BE_WORD(format1->lig_coverage), context->u.pos.glyphs[lig_iter.pos]);
3830 if (lig_index == GLYPH_NOT_COVERED)
3831 continue;
3832
3833 FIXME("Unimplemented.\n");
3834 }
3835 else
3836 WARN("Unknown mark-to-ligature format %u.\n", format);
3837 }
3838
3839 return FALSE;
3840 }
3841
3842 static BOOL opentype_layout_apply_gpos_mark_to_mark_attachment(const struct scriptshaping_context *context,
3843 struct glyph_iterator *iter, const struct lookup *lookup)
3844 {
3845 struct scriptshaping_cache *cache = context->cache;
3846 unsigned int i;
3847 WORD format;
3848
3849 for (i = 0; i < lookup->subtable_count; ++i)
3850 {
3851 unsigned int subtable_offset = opentype_layout_get_gpos_subtable(cache, lookup->offset, i);
3852
3853 format = table_read_be_word(&cache->gpos.table, subtable_offset);
3854
3855 if (format == 1)
3856 {
3857 const struct ot_gpos_mark_to_mark_format1 *format1 = table_read_ensure(&cache->gpos.table,
3858 subtable_offset, sizeof(*format1));
3859 unsigned int count, mark1_array_offset, mark2_array_offset, mark_class_count;
3860 unsigned int mark1_index, mark2_index, mark2_anchor;
3861 const struct ot_gpos_mark_array *mark1_array;
3862 const struct ot_gpos_base_array *mark2_array;
3863 float mark1_x, mark1_y, mark2_x, mark2_y;
3864 struct glyph_iterator mark_iter;
3865
3866 if (!format1)
3867 continue;
3868
3869 mark1_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3870 GET_BE_WORD(format1->mark1_coverage), context->u.pos.glyphs[iter->pos]);
3871
3872 mark1_array_offset = subtable_offset + GET_BE_WORD(format1->mark1_array);
3873 if (!(count = table_read_be_word(&cache->gpos.table, mark1_array_offset)))
3874 continue;
3875
3876 mark1_array = table_read_ensure(&cache->gpos.table, mark1_array_offset,
3877 FIELD_OFFSET(struct ot_gpos_mark_array, records[count]));
3878 if (!mark1_array)
3879 continue;
3880
3881 if (mark1_index == GLYPH_NOT_COVERED || mark1_index >= count)
3882 continue;
3883
3884 glyph_iterator_init(context, lookup->flags & ~LOOKUP_FLAG_IGNORE_MASK, iter->pos, 1, &mark_iter);
3885 if (!glyph_iterator_prev(&mark_iter))
3886 continue;
3887
3888 if (!context->u.pos.glyph_props[mark_iter.pos].isDiacritic)
3889 continue;
3890
3891 mark2_array_offset = subtable_offset + GET_BE_WORD(format1->mark2_array);
3892 if (!(count = table_read_be_word(&cache->gpos.table, mark2_array_offset)))
3893 continue;
3894
3895 mark_class_count = GET_BE_WORD(format1->mark_class_count);
3896
3897 mark2_array = table_read_ensure(&cache->gpos.table, mark2_array_offset,
3898 FIELD_OFFSET(struct ot_gpos_base_array, offsets[count * mark_class_count]));
3899 if (!mark2_array)
3900 continue;
3901
3902 mark2_index = opentype_layout_is_glyph_covered(&cache->gpos.table, subtable_offset +
3903 GET_BE_WORD(format1->mark2_coverage), context->u.pos.glyphs[mark_iter.pos]);
3904
3905 if (mark2_index == GLYPH_NOT_COVERED || mark2_index >= count)
3906 continue;
3907
3908 mark2_anchor = GET_BE_WORD(mark2_array->offsets[mark2_index * mark_class_count +
3909 GET_BE_WORD(mark1_array->records[mark1_index].mark_class)]);
3910 opentype_layout_gpos_get_anchor(context, mark1_array_offset +
3911 GET_BE_WORD(mark1_array->records[mark1_index].mark_anchor), iter->pos, &mark1_x, &mark1_y);
3912 opentype_layout_gpos_get_anchor(context, mark2_array_offset + mark2_anchor, mark_iter.pos,
3913 &mark2_x, &mark2_y);
3914
3915 context->offsets[iter->pos].advanceOffset = mark2_x - mark1_x;
3916 context->offsets[iter->pos].ascenderOffset = mark2_y - mark1_y;
3917
3918 break;
3919 }
3920 else
3921 WARN("Unknown mark-to-mark format %u.\n", format);
3922 }
3923
3924 return FALSE;
3925 }
3926
3927 static BOOL opentype_layout_apply_gpos_contextual_positioning(const struct scriptshaping_context *context,
3928 struct glyph_iterator *iter, const struct lookup *lookup)
3929 {
3930 return FALSE;
3931 }
3932
3933 static BOOL opentype_layout_apply_gpos_chaining_contextual_positioning(const struct scriptshaping_context *context,
3934 struct glyph_iterator *iter, const struct lookup *lookup)
3935 {
3936 return FALSE;
3937 }
3938
3939 static void opentype_layout_apply_gpos_lookup(struct scriptshaping_context *context, int lookup_index)
3940 {
3941 struct scriptshaping_cache *cache = context->cache;
3942 const struct ot_lookup_table *lookup_table;
3943 struct glyph_iterator iter;
3944 struct lookup lookup;
3945 WORD lookup_type;
3946
3947 lookup.offset = table_read_be_word(&cache->gpos.table, cache->gpos.lookup_list +
3948 FIELD_OFFSET(struct ot_lookup_list, lookup[lookup_index]));
3949 if (!lookup.offset)
3950 return;
3951
3952 lookup.offset += cache->gpos.lookup_list;
3953
3954 if (!(lookup_table = table_read_ensure(&cache->gpos.table, lookup.offset, sizeof(*lookup_table))))
3955 return;
3956
3957 lookup.subtable_count = GET_BE_WORD(lookup_table->subtable_count);
3958 if (!lookup.subtable_count)
3959 return;
3960
3961 lookup_type = GET_BE_WORD(lookup_table->lookup_type);
3962 if (lookup_type == GPOS_LOOKUP_EXTENSION_POSITION)
3963 {
3964 const struct ot_gpos_extensionpos_format1 *extension = table_read_ensure(&cache->gpos.table,
3965 lookup.offset + GET_BE_WORD(lookup_table->subtable[0]), sizeof(*extension));
3966 WORD format;
3967
3968 if (!extension)
3969 return;
3970
3971 format = GET_BE_WORD(extension->format);
3972 if (format != 1)
3973 {
3974 WARN("Unexpected extension table format %u.\n", format);
3975 return;
3976 }
3977
3978 lookup_type = GET_BE_WORD(extension->lookup_type);
3979 }
3980 lookup.flags = GET_BE_WORD(lookup_table->flags);
3981
3982 glyph_iterator_init(context, lookup.flags, 0, context->glyph_count, &iter);
3983
3984 while (iter.pos < context->glyph_count)
3985 {
3986 BOOL ret;
3987
3988 if (!glyph_iterator_match(&iter))
3989 {
3990 ++iter.pos;
3991 continue;
3992 }
3993
3994 switch (lookup_type)
3995 {
3996 case GPOS_LOOKUP_SINGLE_ADJUSTMENT:
3997 ret = opentype_layout_apply_gpos_single_adjustment(context, &iter, &lookup);
3998 break;
3999 case GPOS_LOOKUP_PAIR_ADJUSTMENT:
4000 ret = opentype_layout_apply_gpos_pair_adjustment(context, &iter, &lookup);
4001 break;
4002 case GPOS_LOOKUP_CURSIVE_ATTACHMENT:
4003 ret = opentype_layout_apply_gpos_cursive_attachment(context, &iter, &lookup);
4004 break;
4005 case GPOS_LOOKUP_MARK_TO_BASE_ATTACHMENT:
4006 ret = opentype_layout_apply_gpos_mark_to_base_attachment(context, &iter, &lookup);
4007 break;
4008 case GPOS_LOOKUP_MARK_TO_LIGATURE_ATTACHMENT:
4009 ret = opentype_layout_apply_gpos_mark_to_lig_attachment(context, &iter, &lookup);
4010 break;
4011 case GPOS_LOOKUP_MARK_TO_MARK_ATTACHMENT:
4012 ret = opentype_layout_apply_gpos_mark_to_mark_attachment(context, &iter, &lookup);
4013 break;
4014 case GPOS_LOOKUP_CONTEXTUAL_POSITION:
4015 ret = opentype_layout_apply_gpos_contextual_positioning(context, &iter, &lookup);
4016 break;
4017 case GPOS_LOOKUP_CONTEXTUAL_CHAINING_POSITION:
4018 ret = opentype_layout_apply_gpos_chaining_contextual_positioning(context, &iter, &lookup);
4019 break;
4020 case GPOS_LOOKUP_EXTENSION_POSITION:
4021 WARN("Recursive extension lookup.\n");
4022 ret = FALSE;
4023 break;
4024 default:
4025 WARN("Unknown lookup type %u.\n", lookup_type);
4026 return;
4027 }
4028
4029 /* Some lookups update position after making changes. */
4030 if (!ret)
4031 ++iter.pos;
4032 }
4033 }
4034
4035 struct lookups
4036 {
4037 int *indexes;
4038 size_t capacity;
4039 size_t count;
4040 };
4041
4042 static int lookups_sorting_compare(const void *left, const void *right)
4043 {
4044 return *(int *)left - *(int *)right;
4045 };
4046
4047 void opentype_layout_apply_gpos_features(struct scriptshaping_context *context,
4048 unsigned int script_index, unsigned int language_index, const struct shaping_features *features)
4049 {
4050 WORD table_offset, langsys_offset, script_feature_count, total_feature_count, total_lookup_count;
4051 struct scriptshaping_cache *cache = context->cache;
4052 const struct ot_feature_list *feature_list;
4053 struct lookups lookups = { 0 };
4054 unsigned int i, j, l;
4055
4056 /* ScriptTable offset. */
4057 table_offset = table_read_be_word(&cache->gpos.table, cache->gpos.script_list +
4058 FIELD_OFFSET(struct ot_script_list, scripts) + script_index * sizeof(struct ot_script_record) +
4059 FIELD_OFFSET(struct ot_script_record, script));
4060 if (!table_offset)
4061 return;
4062
4063 if (language_index == ~0u)
4064 langsys_offset = table_read_be_word(&cache->gpos.table, cache->gpos.script_list + table_offset);
4065 else
4066 langsys_offset = table_read_be_word(&cache->gpos.table, cache->gpos.script_list + table_offset +
4067 FIELD_OFFSET(struct ot_script, langsys) + language_index * sizeof(struct ot_langsys_record) +
4068 FIELD_OFFSET(struct ot_langsys_record, langsys));
4069
4070 script_feature_count = table_read_be_word(&cache->gpos.table, cache->gpos.script_list + table_offset +
4071 langsys_offset + FIELD_OFFSET(struct ot_langsys, feature_count));
4072 if (!script_feature_count)
4073 return;
4074
4075 total_feature_count = table_read_be_word(&cache->gpos.table, cache->gpos.feature_list);
4076 if (!total_feature_count)
4077 return;
4078
4079 total_lookup_count = table_read_be_word(&cache->gpos.table, cache->gpos.lookup_list);
4080 if (!total_lookup_count)
4081 return;
4082
4083 feature_list = table_read_ensure(&cache->gpos.table, cache->gpos.feature_list,
4084 FIELD_OFFSET(struct ot_feature_list, features[total_feature_count]));
4085 if (!feature_list)
4086 return;
4087
4088 /* Collect lookups for all given features. */
4089 for (i = 0; i < features->count; ++i)
4090 {
4091 for (j = 0; j < script_feature_count; ++j)
4092 {
4093 WORD feature_index = table_read_be_word(&cache->gpos.table, cache->gpos.script_list + table_offset +
4094 langsys_offset + FIELD_OFFSET(struct ot_langsys, feature_index[j]));
4095 if (feature_index >= total_feature_count)
4096 continue;
4097
4098 if (feature_list->features[feature_index].tag == features->tags[i])
4099 {
4100 WORD feature_offset = GET_BE_WORD(feature_list->features[feature_index].offset);
4101 WORD lookup_count;
4102
4103 lookup_count = table_read_be_word(&cache->gpos.table, cache->gpos.feature_list + feature_offset +
4104 FIELD_OFFSET(struct ot_feature, lookup_count));
4105 if (!lookup_count)
4106 continue;
4107
4108 if (!dwrite_array_reserve((void **)&lookups.indexes, &lookups.capacity, lookups.count + lookup_count,
4109 sizeof(*lookups.indexes)))
4110 {
4111 heap_free(lookups.indexes);
4112 return;
4113 }
4114
4115 for (l = 0; l < lookup_count; ++l)
4116 {
4117 WORD lookup_index = table_read_be_word(&cache->gpos.table, cache->gpos.feature_list +
4118 feature_offset + FIELD_OFFSET(struct ot_feature, lookuplist_index[l]));
4119
4120 if (lookup_index >= total_lookup_count)
4121 continue;
4122
4123 lookups.indexes[lookups.count++] = lookup_index;
4124 }
4125 }
4126 }
4127 }
4128
4129 /* Sort lookups. */
4130 qsort(lookups.indexes, lookups.count, sizeof(*lookups.indexes), lookups_sorting_compare);
4131
4132 for (l = 0; l < lookups.count; ++l)
4133 {
4134 /* Skip duplicates. */
4135 if (l && lookups.indexes[l] == lookups.indexes[l - 1])
4136 continue;
4137
4138 opentype_layout_apply_gpos_lookup(context, lookups.indexes[l]);
4139 }
4140
4141 heap_free(lookups.indexes);
4142 }
Zebediah Figura's local tree