1 /*
2 * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include "jni.h"
27 #include "jni_util.h"
28 #include "jlong.h"
29 #include "sunfontids.h"
30 #include "sun_font_FreetypeFontScaler.h"
31
32 #include<stdlib.h>
33 #include <math.h>
34 #include "ft2build.h"
35 #include FT_FREETYPE_H
36 #include FT_GLYPH_H
37 #include FT_BBOX_H
38 #include FT_SIZES_H
39 #include FT_OUTLINE_H
40 #include FT_SYNTHESIS_H
41
42 #include "fontscaler.h"
43
44 #define ftFixed1 (FT_Fixed) (1 << 16)
45 #define FloatToFTFixed(f) (FT_Fixed)((f) * (float)(ftFixed1))
46 #define FTFixedToFloat(x) ((x) / (float)(ftFixed1))
47 #define FT26Dot6ToFloat(x) ((x) / ((float) (1<<6)))
48 #define FT26Dot6ToInt(x) (((int)(x)) >> 6)
49
50 typedef struct {
51 /* Important note:
52 JNI forbids sharing same env between different threads.
53 We are safe, because pointer is overwritten every time we get into
54 JNI call (see setupFTContext).
55
56 Pointer is used by font data reading callbacks
57 such as ReadTTFontFileFunc.
58
59 NB: We may consider switching to JNI_GetEnv. */
60 JNIEnv* env;
61 FT_Library library;
62 FT_Face face;
63 FT_Stream faceStream;
64 jobject font2D;
65 jobject directBuffer;
66
67 unsigned char* fontData;
68 unsigned fontDataOffset;
69 unsigned fontDataLength;
70 unsigned fileSize;
71 TTLayoutTableCache* layoutTables;
72 } FTScalerInfo;
73
74 typedef struct FTScalerContext {
75 FT_Matrix transform; /* glyph transform, including device transform */
76 jboolean useSbits; /* sbit usage enabled? */
77 jint aaType; /* antialiasing mode (off/on/grey/lcd) */
78 jint fmType; /* fractional metrics - on/off */
79 jboolean doBold; /* perform algorithmic bolding? */
80 jboolean doItalize; /* perform algorithmic italicizing? */
81 int renderFlags; /* configuration specific to particular engine */
82 int pathType;
83 int ptsz; /* size in points */
84 } FTScalerContext;
85
86 #ifdef DEBUG
87 /* These are referenced in the freetype sources if DEBUG macro is defined.
88 To simplify work with debuging version of freetype we define
89 them here. */
90 int z_verbose;
91 void z_error(char *s) {}
92 #endif
93
94 /**************** Error handling utilities *****************/
95
96 static jmethodID invalidateScalerMID;
97
98 JNIEXPORT void JNICALL
99 Java_sun_font_FreetypeFontScaler_initIDs(
100 JNIEnv *env, jobject scaler, jclass FFSClass) {
101 invalidateScalerMID =
102 (*env)->GetMethodID(env, FFSClass, "invalidateScaler", "()V");
103 }
104
105 static void freeNativeResources(JNIEnv *env, FTScalerInfo* scalerInfo) {
106
107 if (scalerInfo == NULL)
108 return;
109
110 // FT_Done_Face always closes the stream, but only frees the memory
111 // of the data structure if it was internally allocated by FT.
112 // We hold on to a pointer to the stream structure if we provide it
113 // ourselves, so that we can free it here.
114 FT_Done_Face(scalerInfo->face);
115 FT_Done_FreeType(scalerInfo->library);
116
117 if (scalerInfo->directBuffer != NULL) {
118 (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);
119 }
120
121 if (scalerInfo->fontData != NULL) {
122 free(scalerInfo->fontData);
123 }
124
125 if (scalerInfo->faceStream != NULL) {
126 free(scalerInfo->faceStream);
127 }
128 free(scalerInfo);
129 }
130
131 /* invalidates state of java scaler object */
132 static void invalidateJavaScaler(JNIEnv *env,
133 jobject scaler,
134 FTScalerInfo* scalerInfo) {
135 freeNativeResources(env, scalerInfo);
136 (*env)->CallVoidMethod(env, scaler, invalidateScalerMID);
137 }
138
139 /******************* I/O handlers ***************************/
140
141 #define FILEDATACACHESIZE 1024
142
143 static unsigned long ReadTTFontFileFunc(FT_Stream stream,
144 unsigned long offset,
145 unsigned char* destBuffer,
146 unsigned long numBytes)
147 {
148 FTScalerInfo *scalerInfo = (FTScalerInfo *) stream->pathname.pointer;
149 JNIEnv* env = scalerInfo->env;
150 jobject bBuffer;
151 int bread = 0;
152
153 if (numBytes == 0) return 0;
154
155 /* Large reads will bypass the cache and data copying */
156 if (numBytes > FILEDATACACHESIZE) {
157 bBuffer = (*env)->NewDirectByteBuffer(env, destBuffer, numBytes);
158 if (bBuffer != NULL) {
159 bread = (*env)->CallIntMethod(env,
160 scalerInfo->font2D,
161 sunFontIDs.ttReadBlockMID,
162 bBuffer, offset, numBytes);
163 return bread;
164 } else {
165 /* We probably hit bug 4845371. For reasons that
166 * are currently unclear, the call stacks after the initial
167 * createScaler call that read large amounts of data seem to
168 * be OK and can create the byte buffer above, but this code
169 * is here just in case.
170 * 4845371 is fixed now so I don't expect this code path to
171 * ever get called but its harmless to leave it here on the
172 * small chance its needed.
173 */
174 jbyteArray byteArray = (jbyteArray)
175 (*env)->CallObjectMethod(env, scalerInfo->font2D,
176 sunFontIDs.ttReadBytesMID,
177 offset, numBytes);
178 (*env)->GetByteArrayRegion(env, byteArray,
179 0, numBytes, (jbyte*)destBuffer);
180 return numBytes;
181 }
182 } /* Do we have a cache hit? */
183 else if (scalerInfo->fontDataOffset <= offset &&
184 scalerInfo->fontDataOffset + scalerInfo->fontDataLength >=
185 offset + numBytes)
186 {
187 unsigned cacheOffset = offset - scalerInfo->fontDataOffset;
188
189 memcpy(destBuffer, scalerInfo->fontData+(size_t)cacheOffset, numBytes);
190 return numBytes;
191 } else {
192 /* Must fill the cache */
193 scalerInfo->fontDataOffset = offset;
194 scalerInfo->fontDataLength =
195 (offset + FILEDATACACHESIZE > scalerInfo->fileSize) ?
196 scalerInfo->fileSize - offset : FILEDATACACHESIZE;
197 bBuffer = scalerInfo->directBuffer;
198 bread = (*env)->CallIntMethod(env, scalerInfo->font2D,
199 sunFontIDs.ttReadBlockMID,
200 bBuffer, offset,
201 scalerInfo->fontDataLength);
202 memcpy(destBuffer, scalerInfo->fontData, numBytes);
203 return numBytes;
204 }
205 }
206
207 /*
208 * Class: sun_font_FreetypeFontScaler
209 * Method: initNativeScaler
210 * Signature: (Lsun/font/Font2D;IIZI)J
211 */
212 JNIEXPORT jlong JNICALL
213 Java_sun_font_FreetypeFontScaler_initNativeScaler(
214 JNIEnv *env, jobject scaler, jobject font2D, jint type,
215 jint indexInCollection, jboolean supportsCJK, jint filesize) {
216 FTScalerInfo* scalerInfo = NULL;
217 FT_Open_Args ft_open_args;
218 int error;
219 jobject bBuffer;
220 scalerInfo = (FTScalerInfo*) calloc(1, sizeof(FTScalerInfo));
221
222 if (scalerInfo == NULL)
223 return 0;
224
225 scalerInfo->env = env;
226 scalerInfo->font2D = font2D;
227 scalerInfo->fontDataOffset = 0;
228 scalerInfo->fontDataLength = 0;
229 scalerInfo->fileSize = filesize;
230
231 /*
232 We can consider sharing freetype library between different
233 scalers. However, Freetype docs suggest to use different libraries
234 for different threads. Also, our architecture implies that single
235 FontScaler object is shared for different sizes/transforms/styles
236 of the same font.
237
238 On other hand these methods can not be concurrently executed
239 becaused they are "synchronized" in java.
240 */
241 error = FT_Init_FreeType(&scalerInfo->library);
242 if (error) {
243 free(scalerInfo);
244 return 0;
245 }
246
247 #define TYPE1_FROM_JAVA 2
248
249 error = 1; /* triggers memory freeing unless we clear it */
250 if (type == TYPE1_FROM_JAVA) { /* TYPE1 */
251 scalerInfo->fontData = (unsigned char*) malloc(filesize);
252 scalerInfo->directBuffer = NULL;
253 scalerInfo->layoutTables = NULL;
254 scalerInfo->fontDataLength = filesize;
255
256 if (scalerInfo->fontData != NULL) {
257 bBuffer = (*env)->NewDirectByteBuffer(env,
258 scalerInfo->fontData,
259 scalerInfo->fontDataLength);
260 if (bBuffer != NULL) {
261 (*env)->CallVoidMethod(env, font2D,
262 sunFontIDs.readFileMID, bBuffer);
263
264 error = FT_New_Memory_Face(scalerInfo->library,
265 scalerInfo->fontData,
266 scalerInfo->fontDataLength,
267 indexInCollection,
268 &scalerInfo->face);
269 }
270 }
271 } else { /* Truetype */
272 scalerInfo->fontData = (unsigned char*) malloc(FILEDATACACHESIZE);
273
274 if (scalerInfo->fontData != NULL) {
275 FT_Stream ftstream = (FT_Stream) calloc(1, sizeof(FT_StreamRec));
276 if (ftstream != NULL) {
277 scalerInfo->directBuffer = (*env)->NewDirectByteBuffer(env,
278 scalerInfo->fontData,
279 FILEDATACACHESIZE);
280 if (scalerInfo->directBuffer != NULL) {
281 scalerInfo->directBuffer = (*env)->NewGlobalRef(env,
282 scalerInfo->directBuffer);
283 ftstream->base = NULL;
284 ftstream->size = filesize;
285 ftstream->pos = 0;
286 ftstream->read = (FT_Stream_IoFunc) ReadTTFontFileFunc;
287 ftstream->close = NULL;
288 ftstream->pathname.pointer = (void *) scalerInfo;
289
290 memset(&ft_open_args, 0, sizeof(FT_Open_Args));
291 ft_open_args.flags = FT_OPEN_STREAM;
292 ft_open_args.stream = ftstream;
293
294 error = FT_Open_Face(scalerInfo->library,
295 &ft_open_args,
296 indexInCollection,
297 &scalerInfo->face);
298 if (!error) {
299 scalerInfo->faceStream = ftstream;
300 }
301 }
302 if (error || scalerInfo->directBuffer == NULL) {
303 free(ftstream);
304 }
305 }
306 }
307 }
308
309 if (error) {
310 FT_Done_FreeType(scalerInfo->library);
311 if (scalerInfo->directBuffer != NULL) {
312 (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);
313 }
314 if (scalerInfo->fontData != NULL)
315 free(scalerInfo->fontData);
316 free(scalerInfo);
317 return 0;
318 }
319
320 return ptr_to_jlong(scalerInfo);
321 }
322
323 static double euclidianDistance(double a, double b) {
324 if (a < 0) a=-a;
325 if (b < 0) b=-b;
326
327 if (a == 0) return b;
328 if (b == 0) return a;
329
330 return sqrt(a*a+b*b);
331 }
332
333 JNIEXPORT jlong JNICALL
334 Java_sun_font_FreetypeFontScaler_createScalerContextNative(
335 JNIEnv *env, jobject scaler, jlong pScaler, jdoubleArray matrix,
336 jint aa, jint fm, jfloat boldness, jfloat italic) {
337 double dmat[4], ptsz;
338 FTScalerContext *context =
339 (FTScalerContext*) calloc(1, sizeof(FTScalerContext));
340 FTScalerInfo *scalerInfo =
341 (FTScalerInfo*) jlong_to_ptr(pScaler);
342
343 if (context == NULL) {
344 invalidateJavaScaler(env, scaler, NULL);
345 return (jlong) 0;
346 }
347 (*env)->GetDoubleArrayRegion(env, matrix, 0, 4, dmat);
348 ptsz = euclidianDistance(dmat[2], dmat[3]); //i.e. y-size
349 if (ptsz < 1.0) {
350 //text can not be smaller than 1 point
351 ptsz = 1.0;
352 }
353 context->ptsz = (int)(ptsz * 64);
354 context->transform.xx = FloatToFTFixed((float)dmat[0]/ptsz);
355 context->transform.yx = -FloatToFTFixed((float)dmat[1]/ptsz);
356 context->transform.xy = -FloatToFTFixed((float)dmat[2]/ptsz);
357 context->transform.yy = FloatToFTFixed((float)dmat[3]/ptsz);
358 context->aaType = aa;
359 context->fmType = fm;
360
361 /* If using algorithmic styling, the base values are
362 * boldness = 1.0, italic = 0.0.
363 */
364 context->doBold = (boldness != 1.0);
365 context->doItalize = (italic != 0);
366
367 /* freetype is very keen to use embedded bitmaps, even if it knows
368 * there is a rotation or you asked for antialiasing.
369 * In the rendering path we will check useSBits and disable
370 * bitmaps unless it is set. And here we set it only if none
371 * of the conditions invalidate using it.
372 * Note that we allow embedded bitmaps for the LCD case.
373 */
374 if ((aa != TEXT_AA_ON) && (fm != TEXT_FM_ON) &&
375 !context->doBold && !context->doItalize &&
376 (context->transform.yx == 0) && (context->transform.xy == 0))
377 {
378 context->useSbits = 1;
379 }
380 return ptr_to_jlong(context);
381 }
382
383 static int setupFTContext(JNIEnv *env,
384 jobject font2D,
385 FTScalerInfo *scalerInfo,
386 FTScalerContext *context) {
387 int errCode = 0;
388
389 scalerInfo->env = env;
390 scalerInfo->font2D = font2D;
391
392 if (context != NULL) {
393 FT_Set_Transform(scalerInfo->face, &context->transform, NULL);
394
395 errCode = FT_Set_Char_Size(scalerInfo->face, 0, context->ptsz, 72, 72);
396
397 if (errCode == 0) {
398 errCode = FT_Activate_Size(scalerInfo->face->size);
399 }
400 }
401
402 return errCode;
403 }
404
405 /* ftsynth.c uses (0x10000, 0x06000, 0x0, 0x10000) matrix to get oblique
406 outline. Therefore x coordinate will change by 0x06000*y.
407 Note that y coordinate does not change. */
408 #define OBLIQUE_MODIFIER(y) (context->doItalize ? ((y)*6/16) : 0)
409
410 /*
411 * Class: sun_font_FreetypeFontScaler
412 * Method: getFontMetricsNative
413 * Signature: (Lsun/font/Font2D;J)Lsun/font/StrikeMetrics;
414 */
415 JNIEXPORT jobject JNICALL
416 Java_sun_font_FreetypeFontScaler_getFontMetricsNative(
417 JNIEnv *env, jobject scaler, jobject font2D,
418 jlong pScalerContext, jlong pScaler) {
419
420 jobject metrics;
421 jfloat ax, ay, dx, dy, bx, by, lx, ly, mx, my;
422 jfloat f0 = 0.0;
423 FTScalerContext *context =
424 (FTScalerContext*) jlong_to_ptr(pScalerContext);
425 FTScalerInfo *scalerInfo =
426 (FTScalerInfo*) jlong_to_ptr(pScaler);
427
428 int errCode;
429
430 if (isNullScalerContext(context) || scalerInfo == NULL) {
431 return (*env)->NewObject(env,
432 sunFontIDs.strikeMetricsClass,
433 sunFontIDs.strikeMetricsCtr,
434 f0, f0, f0, f0, f0, f0, f0, f0, f0, f0);
435 }
436
437 errCode = setupFTContext(env, font2D, scalerInfo, context);
438
439 if (errCode) {
440 metrics = (*env)->NewObject(env,
441 sunFontIDs.strikeMetricsClass,
442 sunFontIDs.strikeMetricsCtr,
443 f0, f0, f0, f0, f0, f0, f0, f0, f0, f0);
444 invalidateJavaScaler(env, scaler, scalerInfo);
445 return metrics;
446 }
447
448 /* This is ugly and has to be reworked.
449 Freetype provide means to add style to glyph but
450 it seems there is no way to adjust metrics accordingly.
451
452 So, we have to do adust them explicitly and stay consistent with what
453 freetype does to outlines. */
454
455
456 /**** Note: only some metrics are affected by styling ***/
457
458 /* See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=657854 */
459 #define FT_MulFixFloatShift6(a, b) (((float) (a)) * ((float) (b)) / 65536.0 / 64.0)
460
461 /*
462 * See FreeType source code: src/base/ftobjs.c ft_recompute_scaled_metrics()
463 * http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=1659
464 */
465 /* ascent */
466 ax = 0;
467 ay = -(jfloat) (FT_MulFixFloatShift6(
468 ((jlong) scalerInfo->face->ascender),
469 (jlong) scalerInfo->face->size->metrics.y_scale));
470 /* descent */
471 dx = 0;
472 dy = -(jfloat) (FT_MulFixFloatShift6(
473 ((jlong) scalerInfo->face->descender),
474 (jlong) scalerInfo->face->size->metrics.y_scale));
475 /* baseline */
476 bx = by = 0;
477
478 /* leading */
479 lx = 0;
480 ly = (jfloat) (FT_MulFixFloatShift6(
481 (jlong) scalerInfo->face->height,
482 (jlong) scalerInfo->face->size->metrics.y_scale))
483 + ay - dy;
484 /* max advance */
485 mx = (jfloat) FT26Dot6ToFloat(
486 scalerInfo->face->size->metrics.max_advance +
487 OBLIQUE_MODIFIER(scalerInfo->face->size->metrics.height));
488 my = 0;
489
490 metrics = (*env)->NewObject(env,
491 sunFontIDs.strikeMetricsClass,
492 sunFontIDs.strikeMetricsCtr,
493 ax, ay, dx, dy, bx, by, lx, ly, mx, my);
494
495 return metrics;
496 }
497
498 /*
499 * Class: sun_font_FreetypeFontScaler
500 * Method: getGlyphAdvanceNative
501 * Signature: (Lsun/font/Font2D;JI)F
502 */
503 JNIEXPORT jfloat JNICALL
504 Java_sun_font_FreetypeFontScaler_getGlyphAdvanceNative(
505 JNIEnv *env, jobject scaler, jobject font2D,
506 jlong pScalerContext, jlong pScaler, jint glyphCode) {
507
508 /* This method is rarely used because requests for metrics are usually
509 coupled with request for bitmap and to large extend work can be reused
510 (to find out metrics we need to hint glyph).
511 So, we typically go through getGlyphImage code path.
512
513 For initial freetype implementation we delegate
514 all work to getGlyphImage but drop result image.
515 This is waste of work related to scan conversion and conversion from
516 freetype format to our format but for now this seems to be ok.
517
518 NB: investigate performance benefits of refactoring code
519 to avoid unnecesary work with bitmaps. */
520
521 GlyphInfo *info;
522 jfloat advance;
523 jlong image;
524
525 image = Java_sun_font_FreetypeFontScaler_getGlyphImageNative(
526 env, scaler, font2D, pScalerContext, pScaler, glyphCode);
527 info = (GlyphInfo*) jlong_to_ptr(image);
528
529 advance = info->advanceX;
530
531 free(info);
532
533 return advance;
534 }
535
536 /*
537 * Class: sun_font_FreetypeFontScaler
538 * Method: getGlyphMetricsNative
539 * Signature: (Lsun/font/Font2D;JILjava/awt/geom/Point2D/Float;)V
540 */
541 JNIEXPORT void JNICALL
542 Java_sun_font_FreetypeFontScaler_getGlyphMetricsNative(
543 JNIEnv *env, jobject scaler, jobject font2D, jlong pScalerContext,
544 jlong pScaler, jint glyphCode, jobject metrics) {
545
546 /* As initial implementation we delegate all work to getGlyphImage
547 but drop result image. This is clearly waste of resorces.
548
549 TODO: investigate performance benefits of refactoring code
550 by avoiding bitmap generation and conversion from FT
551 bitmap format. */
552 GlyphInfo *info;
553
554 jlong image = Java_sun_font_FreetypeFontScaler_getGlyphImageNative(
555 env, scaler, font2D,
556 pScalerContext, pScaler, glyphCode);
557 info = (GlyphInfo*) jlong_to_ptr(image);
558
559 (*env)->SetFloatField(env, metrics, sunFontIDs.xFID, info->advanceX);
560 (*env)->SetFloatField(env, metrics, sunFontIDs.yFID, info->advanceY);
561
562 free(info);
563 }
564
565
566 static GlyphInfo* getNullGlyphImage() {
567 GlyphInfo *glyphInfo = (GlyphInfo*) calloc(1, sizeof(GlyphInfo));
568 return glyphInfo;
569 }
570
571 static void CopyBW2Grey8(const void* srcImage, int srcRowBytes,
572 void* dstImage, int dstRowBytes,
573 int width, int height) {
574 const UInt8* srcRow = (UInt8*)srcImage;
575 UInt8* dstRow = (UInt8*)dstImage;
576 int wholeByteCount = width >> 3;
577 int remainingBitsCount = width & 7;
578 int i, j;
579
580 while (height--) {
581 const UInt8* src8 = srcRow;
582 UInt8* dstByte = dstRow;
583 unsigned srcValue;
584
585 srcRow += srcRowBytes;
586 dstRow += dstRowBytes;
587
588 for (i = 0; i < wholeByteCount; i++) {
589 srcValue = *src8++;
590 for (j = 0; j < 8; j++) {
591 *dstByte++ = (srcValue & 0x80) ? 0xFF : 0;
592 srcValue <<= 1;
593 }
594 }
595 if (remainingBitsCount) {
596 srcValue = *src8;
597 for (j = 0; j < remainingBitsCount; j++) {
598 *dstByte++ = (srcValue & 0x80) ? 0xFF : 0;
599 srcValue <<= 1;
600 }
601 }
602 }
603 }
604
605 #define Grey4ToAlpha255(value) (((value) << 4) + ((value) >> 3))
606
607 static void CopyGrey4ToGrey8(const void* srcImage, int srcRowBytes,
608 void* dstImage, int dstRowBytes, int width, int height) {
609 const UInt8* srcRow = (UInt8*) srcImage;
610 UInt8* dstRow = (UInt8*) dstImage;
611 int i;
612
613 while (height--) {
614 const UInt8* src8 = srcRow;
615 UInt8* dstByte = dstRow;
616 unsigned srcValue;
617
618 srcRow += srcRowBytes;
619 dstRow += dstRowBytes;
620
621 for (i = 0; i < width; i++) {
622 srcValue = *src8++;
623 *dstByte++ = Grey4ToAlpha255(srcValue & 0x0f);
624 *dstByte++ = Grey4ToAlpha255(srcValue >> 4);
625 }
626 }
627 }
628
629 /* We need it because FT rows are often padded to 4 byte boundaries
630 and our internal format is not padded */
631 static void CopyFTSubpixelToSubpixel(const void* srcImage, int srcRowBytes,
632 void* dstImage, int dstRowBytes,
633 int width, int height) {
634 unsigned char *srcRow = (unsigned char *) srcImage;
635 unsigned char *dstRow = (unsigned char *) dstImage;
636
637 while (height--) {
638 memcpy(dstRow, srcRow, width);
639 srcRow += srcRowBytes;
640 dstRow += dstRowBytes;
641 }
642 }
643
644 /* We need it because FT rows are often padded to 4 byte boundaries
645 and our internal format is not padded */
646 static void CopyFTSubpixelVToSubpixel(const void* srcImage, int srcRowBytes,
647 void* dstImage, int dstRowBytes,
648 int width, int height) {
649 unsigned char *srcRow = (unsigned char *) srcImage, *srcByte;
650 unsigned char *dstRow = (unsigned char *) dstImage, *dstByte;
651 int i;
652
653 while (height > 0) {
654 srcByte = srcRow;
655 dstByte = dstRow;
656 for (i = 0; i < width; i++) {
657 *dstByte++ = *srcByte;
658 *dstByte++ = *(srcByte + srcRowBytes);
659 *dstByte++ = *(srcByte + 2*srcRowBytes);
660 srcByte++;
661 }
662 srcRow += 3*srcRowBytes;
663 dstRow += dstRowBytes;
664 height -= 3;
665 }
666 }
667
668
669 /*
670 * Class: sun_font_FreetypeFontScaler
671 * Method: getGlyphImageNative
672 * Signature: (Lsun/font/Font2D;JI)J
673 */
674 JNIEXPORT jlong JNICALL
675 Java_sun_font_FreetypeFontScaler_getGlyphImageNative(
676 JNIEnv *env, jobject scaler, jobject font2D,
677 jlong pScalerContext, jlong pScaler, jint glyphCode) {
678
679 int error, imageSize;
680 UInt16 width, height;
681 GlyphInfo *glyphInfo;
682 int glyph_index;
683 int renderFlags = FT_LOAD_RENDER, target;
684 FT_GlyphSlot ftglyph;
685
686 FTScalerContext* context =
687 (FTScalerContext*) jlong_to_ptr(pScalerContext);
688 FTScalerInfo *scalerInfo =
689 (FTScalerInfo*) jlong_to_ptr(pScaler);
690
691 if (isNullScalerContext(context) || scalerInfo == NULL) {
692 return ptr_to_jlong(getNullGlyphImage());
693 }
694
695 error = setupFTContext(env, font2D, scalerInfo, context);
696 if (error) {
697 invalidateJavaScaler(env, scaler, scalerInfo);
698 return ptr_to_jlong(getNullGlyphImage());
699 }
700
701 if (!context->useSbits) {
702 renderFlags |= FT_LOAD_NO_BITMAP;
703 }
704
705 /* NB: in case of non identity transform
706 we might also prefer to disable transform before hinting,
707 and apply it explicitly after hinting is performed.
708 Or we can disable hinting. */
709
710 /* select appropriate hinting mode */
711 if (context->aaType == TEXT_AA_OFF) {
712 target = FT_LOAD_TARGET_MONO;
713 } else if (context->aaType == TEXT_AA_ON) {
714 target = FT_LOAD_TARGET_NORMAL;
715 } else if (context->aaType == TEXT_AA_LCD_HRGB ||
716 context->aaType == TEXT_AA_LCD_HBGR) {
717 target = FT_LOAD_TARGET_LCD;
718 } else {
719 target = FT_LOAD_TARGET_LCD_V;
720 }
721 renderFlags |= target;
722
723 glyph_index = FT_Get_Char_Index(scalerInfo->face, glyphCode);
724
725 error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderFlags);
726 if (error) {
727 //do not destroy scaler yet.
728 //this can be problem of particular context (e.g. with bad transform)
729 return ptr_to_jlong(getNullGlyphImage());
730 }
731
732 ftglyph = scalerInfo->face->glyph;
733
734 /* apply styles */
735 if (context->doBold) { /* if bold style */
736 FT_GlyphSlot_Embolden(ftglyph);
737 }
738 if (context->doItalize) { /* if oblique */
739 FT_GlyphSlot_Oblique(ftglyph);
740 }
741
742 /* generate bitmap if it is not done yet
743 e.g. if algorithmic styling is performed and style was added to outline */
744 if (ftglyph->format == FT_GLYPH_FORMAT_OUTLINE) {
745 FT_Render_Glyph(ftglyph, FT_LOAD_TARGET_MODE(target));
746 }
747
748 width = (UInt16) ftglyph->bitmap.width;
749 height = (UInt16) ftglyph->bitmap.rows;
750
751 imageSize = width*height;
752 glyphInfo = (GlyphInfo*) malloc(sizeof(GlyphInfo) + imageSize);
753 if (glyphInfo == NULL) {
754 glyphInfo = getNullGlyphImage();
755 return ptr_to_jlong(glyphInfo);
756 }
757 glyphInfo->cellInfo = NULL;
758 glyphInfo->managed = UNMANAGED_GLYPH;
759 glyphInfo->rowBytes = width;
760 glyphInfo->width = width;
761 glyphInfo->height = height;
762 glyphInfo->topLeftX = (float) ftglyph->bitmap_left;
763 glyphInfo->topLeftY = (float) -ftglyph->bitmap_top;
764
765 if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD) {
766 glyphInfo->width = width/3;
767 } else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD_V) {
768 glyphInfo->height = glyphInfo->height/3;
769 }
770
771 if (context->fmType == TEXT_FM_ON) {
772 double advh = FTFixedToFloat(ftglyph->linearHoriAdvance);
773 glyphInfo->advanceX =
774 (float) (advh * FTFixedToFloat(context->transform.xx));
775 glyphInfo->advanceY =
776 (float) (advh * FTFixedToFloat(context->transform.xy));
777 } else {
778 if (!ftglyph->advance.y) {
779 glyphInfo->advanceX =
780 (float) FT26Dot6ToInt(ftglyph->advance.x);
781 glyphInfo->advanceY = 0;
782 } else if (!ftglyph->advance.x) {
783 glyphInfo->advanceX = 0;
784 glyphInfo->advanceY =
785 (float) FT26Dot6ToInt(-ftglyph->advance.y);
786 } else {
787 glyphInfo->advanceX = FT26Dot6ToFloat(ftglyph->advance.x);
788 glyphInfo->advanceY = FT26Dot6ToFloat(-ftglyph->advance.y);
789 }
790 }
791
792 if (imageSize == 0) {
793 glyphInfo->image = NULL;
794 } else {
795 glyphInfo->image = (unsigned char*) glyphInfo + sizeof(GlyphInfo);
796 //convert result to output format
797 //output format is either 3 bytes per pixel (for subpixel modes)
798 // or 1 byte per pixel for AA and B&W
799 if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) {
800 /* convert from 8 pixels per byte to 1 byte per pixel */
801 CopyBW2Grey8(ftglyph->bitmap.buffer,
802 ftglyph->bitmap.pitch,
803 (void *) glyphInfo->image,
804 width,
805 width,
806 height);
807 } else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY) {
808 /* byte per pixel to byte per pixel => just copy */
809 memcpy(glyphInfo->image, ftglyph->bitmap.buffer, imageSize);
810 } else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY4) {
811 /* 4 bits per pixel to byte per pixel */
812 CopyGrey4ToGrey8(ftglyph->bitmap.buffer,
813 ftglyph->bitmap.pitch,
814 (void *) glyphInfo->image,
815 width,
816 width,
817 height);
818 } else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD) {
819 /* 3 bytes per pixel to 3 bytes per pixel */
820 CopyFTSubpixelToSubpixel(ftglyph->bitmap.buffer,
821 ftglyph->bitmap.pitch,
822 (void *) glyphInfo->image,
823 width,
824 width,
825 height);
826 } else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD_V) {
827 /* 3 bytes per pixel to 3 bytes per pixel */
828 CopyFTSubpixelVToSubpixel(ftglyph->bitmap.buffer,
829 ftglyph->bitmap.pitch,
830 (void *) glyphInfo->image,
831 width*3,
832 width,
833 height);
834 glyphInfo->rowBytes *=3;
835 } else {
836 free(glyphInfo);
837 glyphInfo = getNullGlyphImage();
838 }
839 }
840
841 return ptr_to_jlong(glyphInfo);
842 }
843
844
845 /*
846 * Class: sun_font_FreetypeFontScaler
847 * Method: getLayoutTableCacheNative
848 * Signature: (J)J
849 */
850 JNIEXPORT jlong JNICALL
851 Java_sun_font_FreetypeFontScaler_getLayoutTableCacheNative(
852 JNIEnv *env, jobject scaler, jlong pScaler) {
853 FTScalerInfo *scalerInfo = (FTScalerInfo*) jlong_to_ptr(pScaler);
854
855 if (scalerInfo == NULL) {
856 invalidateJavaScaler(env, scaler, scalerInfo);
857 return 0L;
858 }
859
860 // init layout table cache in font
861 // we're assuming the font is a file font and moreover it is Truetype font
862 // otherwise we shouldn't be able to get here...
863 if (scalerInfo->layoutTables == NULL) {
864 scalerInfo->layoutTables = newLayoutTableCache();
865 }
866
867 return ptr_to_jlong(scalerInfo->layoutTables);
868 }
869
870 /*
871 * Class: sun_font_FreetypeFontScaler
872 * Method: disposeNativeScaler
873 * Signature: (J)V
874 */
875 JNIEXPORT void JNICALL
876 Java_sun_font_FreetypeFontScaler_disposeNativeScaler(
877 JNIEnv *env, jobject scaler, jobject font2D, jlong pScaler) {
878 FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
879
880 /* Freetype functions *may* cause callback to java
881 that can use cached values. Make sure our cache is up to date.
882 NB: scaler context is not important at this point, can use NULL. */
883 int errCode = setupFTContext(env, font2D, scalerInfo, NULL);
884 if (errCode) {
885 return;
886 }
887
888 freeNativeResources(env, scalerInfo);
889 }
890
891 /*
892 * Class: sun_font_FreetypeFontScaler
893 * Method: getNumGlyphsNative
894 * Signature: ()I
895 */
896 JNIEXPORT jint JNICALL
897 Java_sun_font_FreetypeFontScaler_getNumGlyphsNative(
898 JNIEnv *env, jobject scaler, jlong pScaler) {
899 FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
900
901 if (scalerInfo == NULL || scalerInfo->face == NULL) { /* bad/null scaler */
902 /* null scaler can render 1 glyph - "missing glyph" with code 0
903 (all glyph codes requested by user are mapped to code 0 at
904 validation step) */
905 invalidateJavaScaler(env, scaler, scalerInfo);
906 return (jint) 1;
907 }
908
909 return (jint) scalerInfo->face->num_glyphs;
910 }
911
912 /*
913 * Class: sun_font_FreetypeFontScaler
914 * Method: getMissingGlyphCodeNative
915 * Signature: ()I
916 */
917 JNIEXPORT jint JNICALL
918 Java_sun_font_FreetypeFontScaler_getMissingGlyphCodeNative(
919 JNIEnv *env, jobject scaler, jlong pScaler) {
920
921 /* Is it always 0 for freetype? */
922 return 0;
923 }
924
925 /*
926 * Class: sun_font_FreetypeFontScaler
927 * Method: getGlyphCodeNative
928 * Signature: (C)I
929 */
930 JNIEXPORT jint JNICALL
931 Java_sun_font_FreetypeFontScaler_getGlyphCodeNative(
932 JNIEnv *env, jobject scaler,
933 jobject font2D, jlong pScaler, jchar charCode) {
934
935 FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
936 int errCode;
937
938 if (scaler == NULL || scalerInfo->face == NULL) { /* bad/null scaler */
939 invalidateJavaScaler(env, scaler, scalerInfo);
940 return 0;
941 }
942
943 /* Freetype functions *may* cause callback to java
944 that can use cached values. Make sure our cache is up to date.
945 Scaler context is not important here, can use NULL. */
946 errCode = setupFTContext(env, font2D, scalerInfo, NULL);
947 if (errCode) {
948 return 0;
949 }
950
951 return FT_Get_Char_Index(scalerInfo->face, charCode);
952 }
953
954
955 #define FloatToF26Dot6(x) ((unsigned int) ((x)*64))
956
957 static FT_Outline* getFTOutline(JNIEnv* env, jobject font2D,
958 FTScalerContext *context, FTScalerInfo* scalerInfo,
959 jint glyphCode, jfloat xpos, jfloat ypos) {
960 int renderFlags;
961 int glyph_index;
962 FT_Error error;
963 FT_GlyphSlot ftglyph;
964
965 if (glyphCode >= INVISIBLE_GLYPHS ||
966 isNullScalerContext(context) || scalerInfo == NULL) {
967 return NULL;
968 }
969
970 error = setupFTContext(env, font2D, scalerInfo, context);
971 if (error) {
972 return NULL;
973 }
974
975 renderFlags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
976
977 glyph_index = FT_Get_Char_Index(scalerInfo->face, glyphCode);
978
979 error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderFlags);
980 if (error) {
981 return NULL;
982 }
983
984 ftglyph = scalerInfo->face->glyph;
985
986 /* apply styles */
987 if (context->doBold) { /* if bold style */
988 FT_GlyphSlot_Embolden(ftglyph);
989 }
990 if (context->doItalize) { /* if oblique */
991 FT_GlyphSlot_Oblique(ftglyph);
992 }
993
994 FT_Outline_Translate(&ftglyph->outline,
995 FloatToF26Dot6(xpos),
996 -FloatToF26Dot6(ypos));
997
998 return &ftglyph->outline;
999 }
1000
1001 #define F26Dot6ToFloat(n) (((float)(n))/((float) 64))
1002
1003 /* Types of GeneralPath segments.
1004 TODO: pull constants from other place? */
1005
1006 #define SEG_UNKNOWN -1
1007 #define SEG_MOVETO 0
1008 #define SEG_LINETO 1
1009 #define SEG_QUADTO 2
1010 #define SEG_CUBICTO 3
1011 #define SEG_CLOSE 4
1012
1013 #define WIND_NON_ZERO 0
1014 #define WIND_EVEN_ODD 1
1015
1016 /* Placeholder to accumulate GeneralPath data */
1017 typedef struct {
1018 jint numTypes;
1019 jint numCoords;
1020 jint lenTypes;
1021 jint lenCoords;
1022 jint wr;
1023 jbyte* pointTypes;
1024 jfloat* pointCoords;
1025 } GPData;
1026
1027 /* returns 0 on failure */
1028 static int allocateSpaceForGP(GPData* gpdata, int npoints, int ncontours) {
1029 int maxTypes, maxCoords;
1030
1031 /* we may have up to N intermediate points per contour
1032 (and for each point can actually cause new curve to be generated)
1033 In addition we can also have 2 extra point per outline.
1034 */
1035 maxTypes = 2*npoints + 2*ncontours;
1036 maxCoords = 4*(npoints + 2*ncontours); //we may need to insert
1037 //up to n-1 intermediate points
1038
1039 /* first usage - allocate space and intialize all fields */
1040 if (gpdata->pointTypes == NULL || gpdata->pointCoords == NULL) {
1041 gpdata->lenTypes = maxTypes;
1042 gpdata->lenCoords = maxCoords;
1043 gpdata->pointTypes = (jbyte*)
1044 malloc(gpdata->lenTypes*sizeof(jbyte));
1045 gpdata->pointCoords = (jfloat*)
1046 malloc(gpdata->lenCoords*sizeof(jfloat));
1047 gpdata->numTypes = 0;
1048 gpdata->numCoords = 0;
1049 gpdata->wr = WIND_NON_ZERO; /* By default, outlines are filled
1050 using the non-zero winding rule. */
1051 } else {
1052 /* do we have enough space? */
1053 if (gpdata->lenTypes - gpdata->numTypes < maxTypes) {
1054 gpdata->lenTypes += maxTypes;
1055 gpdata->pointTypes = (jbyte*)
1056 realloc(gpdata->pointTypes, gpdata->lenTypes*sizeof(jbyte));
1057 }
1058
1059 if (gpdata->lenCoords - gpdata->numCoords < maxCoords) {
1060 gpdata->lenCoords += maxCoords;
1061 gpdata->pointCoords = (jfloat*)
1062 realloc(gpdata->pointCoords, gpdata->lenCoords*sizeof(jfloat));
1063 }
1064 }
1065
1066 /* failure if any of mallocs failed */
1067 if (gpdata->pointTypes == NULL || gpdata->pointCoords == NULL)
1068 return 0;
1069 else
1070 return 1;
1071 }
1072
1073 static void addSeg(GPData *gp, jbyte type) {
1074 gp->pointTypes[gp->numTypes++] = type;
1075 }
1076
1077 static void addCoords(GPData *gp, FT_Vector *p) {
1078 gp->pointCoords[gp->numCoords++] = F26Dot6ToFloat(p->x);
1079 gp->pointCoords[gp->numCoords++] = -F26Dot6ToFloat(p->y);
1080 }
1081
1082 static int moveTo(FT_Vector *to, GPData *gp) {
1083 if (gp->numCoords)
1084 addSeg(gp, SEG_CLOSE);
1085 addCoords(gp, to);
1086 addSeg(gp, SEG_MOVETO);
1087 return FT_Err_Ok;
1088 }
1089
1090 static int lineTo(FT_Vector *to, GPData *gp) {
1091 addCoords(gp, to);
1092 addSeg(gp, SEG_LINETO);
1093 return FT_Err_Ok;
1094 }
1095
1096 static int conicTo(FT_Vector *control, FT_Vector *to, GPData *gp) {
1097 addCoords(gp, control);
1098 addCoords(gp, to);
1099 addSeg(gp, SEG_QUADTO);
1100 return FT_Err_Ok;
1101 }
1102
1103 static int cubicTo(FT_Vector *control1,
1104 FT_Vector *control2,
1105 FT_Vector *to,
1106 GPData *gp) {
1107 addCoords(gp, control1);
1108 addCoords(gp, control2);
1109 addCoords(gp, to);
1110 addSeg(gp, SEG_CUBICTO);
1111 return FT_Err_Ok;
1112 }
1113
1114 static void addToGP(GPData* gpdata, FT_Outline*outline) {
1115 static const FT_Outline_Funcs outline_funcs = {
1116 (FT_Outline_MoveToFunc) moveTo,
1117 (FT_Outline_LineToFunc) lineTo,
1118 (FT_Outline_ConicToFunc) conicTo,
1119 (FT_Outline_CubicToFunc) cubicTo,
1120 0, /* shift */
1121 0, /* delta */
1122 };
1123
1124 FT_Outline_Decompose(outline, &outline_funcs, gpdata);
1125 if (gpdata->numCoords)
1126 addSeg(gpdata, SEG_CLOSE);
1127
1128 /* If set to 1, the outline will be filled using the even-odd fill rule */
1129 if (outline->flags & FT_OUTLINE_EVEN_ODD_FILL) {
1130 gpdata->wr = WIND_EVEN_ODD;
1131 }
1132 }
1133
1134 static void freeGP(GPData* gpdata) {
1135 if (gpdata->pointCoords != NULL) {
1136 free(gpdata->pointCoords);
1137 gpdata->pointCoords = NULL;
1138 gpdata->numCoords = 0;
1139 gpdata->lenCoords = 0;
1140 }
1141 if (gpdata->pointTypes != NULL) {
1142 free(gpdata->pointTypes);
1143 gpdata->pointTypes = NULL;
1144 gpdata->numTypes = 0;
1145 gpdata->lenTypes = 0;
1146 }
1147 }
1148
1149 static jobject getGlyphGeneralPath(JNIEnv* env, jobject font2D,
1150 FTScalerContext *context, FTScalerInfo *scalerInfo,
1151 jint glyphCode, jfloat xpos, jfloat ypos) {
1152
1153 FT_Outline* outline;
1154 jobject gp = NULL;
1155 jbyteArray types;
1156 jfloatArray coords;
1157 GPData gpdata;
1158
1159 outline = getFTOutline(env, font2D, context, scalerInfo,
1160 glyphCode, xpos, ypos);
1161
1162 if (outline == NULL || outline->n_points == 0) {
1163 return gp;
1164 }
1165
1166 gpdata.pointTypes = NULL;
1167 gpdata.pointCoords = NULL;
1168 if (!allocateSpaceForGP(&gpdata, outline->n_points, outline->n_contours)) {
1169 return gp;
1170 }
1171
1172 addToGP(&gpdata, outline);
1173
1174 types = (*env)->NewByteArray(env, gpdata.numTypes);
1175 coords = (*env)->NewFloatArray(env, gpdata.numCoords);
1176
1177 if (types && coords) {
1178 (*env)->SetByteArrayRegion(env, types, 0,
1179 gpdata.numTypes,
1180 gpdata.pointTypes);
1181 (*env)->SetFloatArrayRegion(env, coords, 0,
1182 gpdata.numCoords,
1183 gpdata.pointCoords);
1184 gp = (*env)->NewObject(env,
1185 sunFontIDs.gpClass,
1186 sunFontIDs.gpCtr,
1187 gpdata.wr,
1188 types,
1189 gpdata.numTypes,
1190 coords,
1191 gpdata.numCoords);
1192 }
1193
1194 freeGP(&gpdata);
1195
1196 return gp;
1197 }
1198
1199 /*
1200 * Class: sun_font_FreetypeFontScaler
1201 * Method: getGlyphOutlineNative
1202 * Signature: (Lsun/font/Font2D;JIFF)Ljava/awt/geom/GeneralPath;
1203 */
1204 JNIEXPORT jobject JNICALL
1205 Java_sun_font_FreetypeFontScaler_getGlyphOutlineNative(
1206 JNIEnv *env, jobject scaler, jobject font2D, jlong pScalerContext,
1207 jlong pScaler, jint glyphCode, jfloat xpos, jfloat ypos) {
1208
1209 FTScalerContext *context =
1210 (FTScalerContext*) jlong_to_ptr(pScalerContext);
1211 FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
1212
1213 jobject gp = getGlyphGeneralPath(env,
1214 font2D,
1215 context,
1216 scalerInfo,
1217 glyphCode,
1218 xpos,
1219 ypos);
1220 if (gp == NULL) { /* can be legal */
1221 gp = (*env)->NewObject(env,
1222 sunFontIDs.gpClass,
1223 sunFontIDs.gpCtrEmpty);
1224 }
1225 return gp;
1226 }
1227
1228 /*
1229 * Class: sun_font_FreetypeFontScaler
1230 * Method: getGlyphOutlineBoundsNative
1231 * Signature: (Lsun/font/Font2D;JI)Ljava/awt/geom/Rectangle2D/Float;
1232 */
1233 JNIEXPORT jobject JNICALL
1234 Java_sun_font_FreetypeFontScaler_getGlyphOutlineBoundsNative(
1235 JNIEnv *env, jobject scaler, jobject font2D,
1236 jlong pScalerContext, jlong pScaler, jint glyphCode) {
1237
1238 FT_Outline *outline;
1239 FT_BBox bbox;
1240 int error;
1241 jobject bounds;
1242
1243 FTScalerContext *context =
1244 (FTScalerContext*) jlong_to_ptr(pScalerContext);
1245 FTScalerInfo* scalerInfo = (FTScalerInfo *) jlong_to_ptr(pScaler);
1246
1247 outline = getFTOutline(env, font2D, context, scalerInfo, glyphCode, 0, 0);
1248 if (outline == NULL || outline->n_points == 0) {
1249 /* it is legal case, e.g. invisible glyph */
1250 bounds = (*env)->NewObject(env,
1251 sunFontIDs.rect2DFloatClass,
1252 sunFontIDs.rect2DFloatCtr);
1253 return bounds;
1254 }
1255
1256 error = FT_Outline_Get_BBox(outline, &bbox);
1257
1258 //convert bbox
1259 if (error || bbox.xMin >= bbox.xMax || bbox.yMin >= bbox.yMax) {
1260 bounds = (*env)->NewObject(env,
1261 sunFontIDs.rect2DFloatClass,
1262 sunFontIDs.rect2DFloatCtr);
1263 } else {
1264 bounds = (*env)->NewObject(env,
1265 sunFontIDs.rect2DFloatClass,
1266 sunFontIDs.rect2DFloatCtr4,
1267 F26Dot6ToFloat(bbox.xMin),
1268 F26Dot6ToFloat(-bbox.yMax),
1269 F26Dot6ToFloat(bbox.xMax-bbox.xMin),
1270 F26Dot6ToFloat(bbox.yMax-bbox.yMin));
1271 }
1272
1273 return bounds;
1274 }
1275
1276 /*
1277 * Class: sun_font_FreetypeFontScaler
1278 * Method: getGlyphVectorOutlineNative
1279 * Signature: (Lsun/font/Font2D;J[IIFF)Ljava/awt/geom/GeneralPath;
1280 */
1281 JNIEXPORT jobject
1282 JNICALL
1283 Java_sun_font_FreetypeFontScaler_getGlyphVectorOutlineNative(
1284 JNIEnv *env, jobject scaler, jobject font2D,
1285 jlong pScalerContext, jlong pScaler,
1286 jintArray glyphArray, jint numGlyphs, jfloat xpos, jfloat ypos) {
1287
1288 FT_Outline* outline;
1289 jobject gp = NULL;
1290 jbyteArray types;
1291 jfloatArray coords;
1292 GPData gpdata;
1293 int i;
1294 jint *glyphs;
1295
1296 FTScalerContext *context =
1297 (FTScalerContext*) jlong_to_ptr(pScalerContext);
1298 FTScalerInfo *scalerInfo =
1299 (FTScalerInfo*) jlong_to_ptr(pScaler);
1300
1301 glyphs = NULL;
1302 if (numGlyphs > 0 && 0xffffffffu / sizeof(jint) >= numGlyphs) {
1303 glyphs = (jint*) malloc(numGlyphs*sizeof(jint));
1304 }
1305 if (glyphs == NULL) {
1306 // We reach here if:
1307 // 1. numGlyphs <= 0,
1308 // 2. overflow check failed, or
1309 // 3. malloc failed.
1310 gp = (*env)->NewObject(env, sunFontIDs.gpClass, sunFontIDs.gpCtrEmpty);
1311 return gp;
1312 }
1313
1314 (*env)->GetIntArrayRegion(env, glyphArray, 0, numGlyphs, glyphs);
1315
1316 gpdata.numCoords = 0;
1317 for (i=0; i<numGlyphs;i++) {
1318 if (glyphs[i] >= INVISIBLE_GLYPHS) {
1319 continue;
1320 }
1321 outline = getFTOutline(env,
1322 font2D,
1323 context,
1324 scalerInfo,
1325 glyphs[i],
1326 xpos, ypos);
1327
1328 if (outline == NULL || outline->n_points == 0) {
1329 continue;
1330 }
1331
1332 gpdata.pointTypes = NULL;
1333 gpdata.pointCoords = NULL;
1334 if (!allocateSpaceForGP(&gpdata, outline->n_points,
1335 outline->n_contours)) {
1336 break;
1337 }
1338
1339 addToGP(&gpdata, outline);
1340 }
1341 free(glyphs);
1342
1343 if (gpdata.numCoords != 0) {
1344 types = (*env)->NewByteArray(env, gpdata.numTypes);
1345 coords = (*env)->NewFloatArray(env, gpdata.numCoords);
1346
1347 if (types && coords) {
1348 (*env)->SetByteArrayRegion(env, types, 0,
1349 gpdata.numTypes, gpdata.pointTypes);
1350 (*env)->SetFloatArrayRegion(env, coords, 0,
1351 gpdata.numCoords, gpdata.pointCoords);
1352
1353 gp=(*env)->NewObject(env,
1354 sunFontIDs.gpClass,
1355 sunFontIDs.gpCtr,
1356 gpdata.wr,
1357 types,
1358 gpdata.numTypes,
1359 coords,
1360 gpdata.numCoords);
1361 return gp;
1362 }
1363 }
1364 return (*env)->NewObject(env, sunFontIDs.gpClass, sunFontIDs.gpCtrEmpty);
1365 }
1366
1367 JNIEXPORT jlong JNICALL
1368 Java_sun_font_FreetypeFontScaler_getUnitsPerEMNative(
1369 JNIEnv *env, jobject scaler, jlong pScaler) {
1370
1371 FTScalerInfo *s = (FTScalerInfo* ) jlong_to_ptr(pScaler);
1372
1373 /* Freetype doc says:
1374 The number of font units per EM square for this face.
1375 This is typically 2048 for TrueType fonts, and 1000 for Type 1 fonts.
1376 Only relevant for scalable formats.
1377 However, layout engine might be not tested with anything but 2048.
1378
1379 NB: test it! */
1380 if (s != NULL) {
1381 return s->face->units_per_EM;
1382 }
1383 return 2048;
1384 }
1385
1386 /* This native method is called by the OpenType layout engine. */
1387 JNIEXPORT jobject JNICALL
1388 Java_sun_font_FreetypeFontScaler_getGlyphPointNative(
1389 JNIEnv *env, jobject scaler, jobject font2D, jlong pScalerContext,
1390 jlong pScaler, jint glyphCode, jint pointNumber) {
1391
1392 FT_Outline* outline;
1393 jobject point = NULL;
1394 jfloat x=0, y=0;
1395 FTScalerContext *context =
1396 (FTScalerContext*) jlong_to_ptr(pScalerContext);
1397 FTScalerInfo *scalerInfo = (FTScalerInfo*) jlong_to_ptr(pScaler);
1398
1399 outline = getFTOutline(env, font2D, context, scalerInfo, glyphCode, 0, 0);
1400
1401 if (outline != NULL && outline->n_points > pointNumber) {
1402 x = F26Dot6ToFloat(outline->points[pointNumber].x);
1403 y = -F26Dot6ToFloat(outline->points[pointNumber].y);
1404 }
1405
1406 return (*env)->NewObject(env, sunFontIDs.pt2DFloatClass,
1407 sunFontIDs.pt2DFloatCtr, x, y);
1408 }