1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 /*
27 *
28 * (C) Copyright IBM Corp. 2003 - All Rights Reserved
29 */
30
31 package sun.font;
32
33 import sun.font.GlyphLayout.*;
34 import java.awt.geom.Point2D;
35 import java.lang.ref.SoftReference;
36 import java.util.concurrent.ConcurrentHashMap;
37 import java.util.Locale;
38
39 /*
40 * different ways to do this
41 * 1) each physical font2d keeps a hashtable mapping scripts to layout
42 * engines, we query and fill this cache.
43 * 2) we keep a mapping independent of font using the key Most likely
44 * few fonts will be used, so option 2 seems better
45 *
46 * Once we know which engine to use for a font, we always know, so we
47 * shouldn't have to recheck each time we do layout. So the cache is
48 * ok.
49 *
50 * Should we reuse engines? We could instantiate an engine for each
51 * font/script pair. The engine would hold onto the table(s) from the
52 * font that it needs. If we have multiple threads using the same
53 * engine, we still need to keep the state separate, so the native
54 * engines would still need to be allocated for each call, since they
55 * keep their state in themselves. If they used the passed-in GVData
56 * arrays directly (with some checks for space) then since each GVData
57 * is different per thread, we could reuse the layout engines. This
58 * still requires a separate layout engine per font, because of the
59 * table state in the engine. If we pushed that out too and passed it
60 * in with the native call as well, we'd be ok if the layout engines
61 * keep all their process state on the stack, but I don't know if this
62 * is true. Then we'd basically just be down to an engine index which
63 * we pass into native and then invoke the engine code (now a
64 * procedure call, not an object invocation) based on a switch on the
65 * index. There would be only half a dozen engine objects then, not
66 * potentially half a dozen per font. But we'd have to stack-allocate
67 * some state that included the pointer to the required font tables.
68 *
69 * Seems for now that the way to do things is to come in with a
70 * selector and the font. The selector indicates which engine to use,
71 * the engine is stack allocated and initialized with the required
72 * font tables (the selector indicates which). Then layout is called,
73 * the contents are copied (or not), and the stack is destroyed on
74 * exit. So the association is between the font/script (layout engine
75 * desc) and one of a few permanent engine objects, which are
76 * handed the key when they need to process something. In the native
77 * case, the engine holds an index, and just passes it together with
78 * the key info down to native. Some default cases are the 'default
79 * layout' case that just runs the c2gmapper, this stays in java and
80 * just uses the mapper from the font/strike. Another default case
81 * might be the unicode arabic shaper, since this doesn't care about
82 * the font (or script or lang?) it wouldn't need to extract this
83 * data. It could be (yikes) ported back to java even to avoid
84 * upcalls to check if the font supports a particular unicode
85 * character.
86 *
87 * I'd expect that the majority of scripts use the default mapper for
88 * a particular font. Loading the hastable with 40 or so keys 30+ of
89 * which all map to the same object is unfortunate. It might be worth
90 * instead having a per-font list of 'scripts with non-default
91 * engines', e.g. the factory has a hashtable mapping fonts to 'script
92 * lists' (the factory has this since the design potentially has other
93 * factories, though I admit there's no client for this yet and no
94 * public api) and then the script list is queried for the script in
95 * question. it can be preloaded at creation time with all the
96 * scripts that don't have default engines-- either a list or a hash
97 * table, so a null return from the table means 'default' and not 'i
98 * don't know yet'.
99 *
100 * On the other hand, in most all cases the number of unique
101 * script/font combinations will be small, so a flat hashtable should
102 * suffice.
103 * */
104 public final class SunLayoutEngine implements LayoutEngine, LayoutEngineFactory {
105 private static native void initGVIDs();
106 private static final boolean useICU;
107 static {
108 FontManagerNativeLibrary.load();
109 initGVIDs();
110 String le = java.security.AccessController.doPrivileged(
111 new sun.security.action.
112 GetPropertyAction("sun.font.layoutengine", ""));
113 useICU = le.equals("icu");
114 String verbose = java.security.AccessController.doPrivileged(
115 new sun.security.action.
116 GetPropertyAction("sun.font.layoutengine.verbose", ""));
117 if ("true".equalsIgnoreCase(verbose)) {
118 System.out.println("Using " + (useICU ? "icu." : "harfbuzz."));
119 }
120 }
121
122 private LayoutEngineKey key;
123
124 private static LayoutEngineFactory instance;
125
126 public static LayoutEngineFactory instance() {
127 if (instance == null) {
128 instance = new SunLayoutEngine();
129 }
130 return instance;
131 }
132
133 private SunLayoutEngine() {
134 // actually a factory, key is null so layout cannot be called on it
135 }
136
137 public LayoutEngine getEngine(Font2D font, int script, int lang) {
138 return getEngine(new LayoutEngineKey(font, script, lang));
139 }
140
141 // !!! don't need this unless we have more than one sun layout engine...
142 public LayoutEngine getEngine(LayoutEngineKey key) {
143 ConcurrentHashMap<LayoutEngineKey, LayoutEngine> cache = cacheref.get();
144 if (cache == null) {
145 cache = new ConcurrentHashMap<>();
146 cacheref = new SoftReference<>(cache);
147 }
148
149 LayoutEngine e = cache.get(key);
150 if (e == null) {
151 LayoutEngineKey copy = key.copy();
152 e = new SunLayoutEngine(copy);
153 cache.put(copy, e);
154 }
155 return e;
156 }
157 private SoftReference<ConcurrentHashMap<LayoutEngineKey, LayoutEngine>> cacheref =
158 new SoftReference<>(null);
159
160 private SunLayoutEngine(LayoutEngineKey key) {
161 this.key = key;
162 }
163
164 private boolean isAAT(Font2D font) {
165 if (font instanceof TrueTypeFont) {
166 TrueTypeFont ttf = (TrueTypeFont)font;
167 return ttf.getDirectoryEntry(TrueTypeFont.morxTag) != null ||
168 ttf.getDirectoryEntry(TrueTypeFont.mortTag) != null;
169 } else if (font instanceof PhysicalFont) {
170 PhysicalFont pf = (PhysicalFont)font;
171 return pf.getTableBytes(TrueTypeFont.morxTag) != null ||
172 pf.getTableBytes(TrueTypeFont.mortTag) != null;
173 }
174 return false;
175 }
176
177 public void layout(FontStrikeDesc desc, float[] mat, int gmask,
178 int baseIndex, TextRecord tr, int typo_flags,
179 Point2D.Float pt, GVData data) {
180 Font2D font = key.font();
181 FontStrike strike = font.getStrike(desc);
182 long layoutTables = font.getLayoutTableCache();
183 if (useICU) {
184 nativeLayout(font, strike, mat, gmask, baseIndex,
185 tr.text, tr.start, tr.limit, tr.min, tr.max,
186 key.script(), key.lang(), typo_flags, pt, data,
187 font.getUnitsPerEm(), layoutTables);
188 } else {
189 long pNativeFont = font.getPlatformNativeFontPtr(); // used on OSX
190 // pScaler probably not needed long term.
191 long pScaler = 0L;
192 if (font instanceof FileFont) {
193 pScaler = ((FileFont)font).getScaler().nativeScaler;
194 }
195 shape(font, strike, mat, pScaler, pNativeFont, isAAT(font),
196 tr.text, data, key.script(),
197 tr.start, tr.limit, baseIndex, pt,
198 typo_flags, gmask);
199 }
200 }
201
202 /* Native method to invoke ICU layout engine */
203 private static native void
204 nativeLayout(Font2D font, FontStrike strike, float[] mat, int gmask,
205 int baseIndex, char[] chars, int offset, int limit,
206 int min, int max, int script, int lang, int typo_flags,
207 Point2D.Float pt, GVData data, long upem, long layoutTables);
208
209
210 /* Native method to invoke harfbuzz layout engine */
211 private static native boolean
212 shape(Font2D font, FontStrike strike, float[] mat,
213 long pscaler, long pNativeFont, boolean aat,
214 char[] chars, GVData data,
215 int script, int offset, int limit,
216 int baseIndex, Point2D.Float pt, int typo_flags, int slot);
217 }