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 ROUND(x) ((int) (x+0.5))
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 jobject font2D;
64 jobject directBuffer;
65
66 unsigned char* fontData;
67 unsigned fontDataOffset;
68 unsigned fontDataLength;
69 unsigned fileSize;
70 TTLayoutTableCache* layoutTables;
71 } FTScalerInfo;
72
73 typedef struct FTScalerContext {
74 FT_Matrix transform; /* glyph transform, including device transform */
75 jboolean useSbits; /* sbit usage enabled? */
76 jint aaType; /* antialiasing mode (off/on/grey/lcd) */
77 jint fmType; /* fractional metrics - on/off */
78 jboolean doBold; /* perform algorithmic bolding? */
79 jboolean doItalize; /* perform algorithmic italicizing? */
80 int renderFlags; /* configuration specific to particular engine */
81 int pathType;
82 int ptsz; /* size in points */
90 void z_error(char *s) {}
91 #endif
92
93 /**************** Error handling utilities *****************/
94
95 static jmethodID invalidateScalerMID;
96
97 JNIEXPORT void JNICALL
98 Java_sun_font_FreetypeFontScaler_initIDs(
99 JNIEnv *env, jobject scaler, jclass FFSClass) {
100 invalidateScalerMID =
101 (*env)->GetMethodID(env, FFSClass, "invalidateScaler", "()V");
102 }
103
104 static void freeNativeResources(JNIEnv *env, FTScalerInfo* scalerInfo) {
105 void *stream;
106
107 if (scalerInfo == NULL)
108 return;
109
110 //apparently Done_Face will only close the stream
111 // but will not relase the memory of stream structure.
112 // We need to free it explicitly to avoid leak.
113 //Direct access to the stream field might be not ideal solution as
114 // it is considred to be "private".
115 //Alternatively we could have stored pointer to the structure
116 // in the scalerInfo but this will increase size of the structure
117 // for no good reason
118 stream = scalerInfo->face->stream;
119
120 FT_Done_Face(scalerInfo->face);
121 FT_Done_FreeType(scalerInfo->library);
122
123 if (scalerInfo->directBuffer != NULL) {
124 (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);
125 }
126
127 if (scalerInfo->fontData != NULL) {
128 free(scalerInfo->fontData);
129 }
130
131 if (stream != NULL) {
132 free(stream);
133 }
134
135 free(scalerInfo);
136 }
137
138 /* invalidates state of java scaler object */
139 static void invalidateJavaScaler(JNIEnv *env,
140 jobject scaler,
141 FTScalerInfo* scalerInfo) {
142 freeNativeResources(env, scalerInfo);
143 (*env)->CallVoidMethod(env, scaler, invalidateScalerMID);
144 }
145
146 /******************* I/O handlers ***************************/
147
148 #define FILEDATACACHESIZE 1024
149
150 static unsigned long ReadTTFontFileFunc(FT_Stream stream,
151 unsigned long offset,
152 unsigned char* destBuffer,
153 unsigned long numBytes)
154 {
285 scalerInfo->fontData,
286 FILEDATACACHESIZE);
287 if (scalerInfo->directBuffer != NULL) {
288 scalerInfo->directBuffer = (*env)->NewGlobalRef(env,
289 scalerInfo->directBuffer);
290 ftstream->base = NULL;
291 ftstream->size = filesize;
292 ftstream->pos = 0;
293 ftstream->read = (FT_Stream_IoFunc) ReadTTFontFileFunc;
294 ftstream->close = NULL;
295 ftstream->pathname.pointer = (void *) scalerInfo;
296
297 memset(&ft_open_args, 0, sizeof(FT_Open_Args));
298 ft_open_args.flags = FT_OPEN_STREAM;
299 ft_open_args.stream = ftstream;
300
301 error = FT_Open_Face(scalerInfo->library,
302 &ft_open_args,
303 indexInCollection,
304 &scalerInfo->face);
305 }
306 if (error || scalerInfo->directBuffer == NULL) {
307 free(ftstream);
308 }
309 }
310 }
311 }
312
313 if (error) {
314 FT_Done_FreeType(scalerInfo->library);
315 if (scalerInfo->directBuffer != NULL) {
316 (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);
317 }
318 if (scalerInfo->fontData != NULL)
319 free(scalerInfo->fontData);
320 free(scalerInfo);
321 return 0;
322 }
323
324 return ptr_to_jlong(scalerInfo);
|
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 ROUND(x) ((int) (x+0.5))
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 */
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 void *stream;
107
108 if (scalerInfo == NULL)
109 return;
110
111 // FT_Done_Face always closes the stream, but only frees the memory
112 // of the data structure if it was internally allocated by FT.
113 // We hold on to a pointer to the stream structure if we provide it
114 // ourselves, so that we can free it here.
115 FT_Done_Face(scalerInfo->face);
116 FT_Done_FreeType(scalerInfo->library);
117
118 if (scalerInfo->directBuffer != NULL) {
119 (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);
120 }
121
122 if (scalerInfo->fontData != NULL) {
123 free(scalerInfo->fontData);
124 }
125
126 if (scalerInfo->faceStream != NULL) {
127 free(scalerInfo->faceStream);
128 }
129 free(scalerInfo);
130 }
131
132 /* invalidates state of java scaler object */
133 static void invalidateJavaScaler(JNIEnv *env,
134 jobject scaler,
135 FTScalerInfo* scalerInfo) {
136 freeNativeResources(env, scalerInfo);
137 (*env)->CallVoidMethod(env, scaler, invalidateScalerMID);
138 }
139
140 /******************* I/O handlers ***************************/
141
142 #define FILEDATACACHESIZE 1024
143
144 static unsigned long ReadTTFontFileFunc(FT_Stream stream,
145 unsigned long offset,
146 unsigned char* destBuffer,
147 unsigned long numBytes)
148 {
279 scalerInfo->fontData,
280 FILEDATACACHESIZE);
281 if (scalerInfo->directBuffer != NULL) {
282 scalerInfo->directBuffer = (*env)->NewGlobalRef(env,
283 scalerInfo->directBuffer);
284 ftstream->base = NULL;
285 ftstream->size = filesize;
286 ftstream->pos = 0;
287 ftstream->read = (FT_Stream_IoFunc) ReadTTFontFileFunc;
288 ftstream->close = NULL;
289 ftstream->pathname.pointer = (void *) scalerInfo;
290
291 memset(&ft_open_args, 0, sizeof(FT_Open_Args));
292 ft_open_args.flags = FT_OPEN_STREAM;
293 ft_open_args.stream = ftstream;
294
295 error = FT_Open_Face(scalerInfo->library,
296 &ft_open_args,
297 indexInCollection,
298 &scalerInfo->face);
299 if (!error) {
300 scalerInfo->faceStream = ftstream;
301 }
302 }
303 if (error || scalerInfo->directBuffer == NULL) {
304 free(ftstream);
305 }
306 }
307 }
308 }
309
310 if (error) {
311 FT_Done_FreeType(scalerInfo->library);
312 if (scalerInfo->directBuffer != NULL) {
313 (*env)->DeleteGlobalRef(env, scalerInfo->directBuffer);
314 }
315 if (scalerInfo->fontData != NULL)
316 free(scalerInfo->fontData);
317 free(scalerInfo);
318 return 0;
319 }
320
321 return ptr_to_jlong(scalerInfo);
|