/*
* Class: sun_font_StrikeCache
* Method: freeIntMemory
* Signature: ([I)V
*/
JNIEXPORT void JNICALL Java_sun_font_StrikeCache_freeIntMemory
(JNIEnv *env, jclass cacheClass, jintArray jmemArray, jlong pContext) {
int len = (*env)->GetArrayLength(env, jmemArray);
jint* ptrs =
(jint*)(*env)->GetPrimitiveArrayCritical(env, jmemArray, NULL);
int i;
if (ptrs) {
for (i=0; i< len; i++) {
if (ptrs[i] != 0) {
GlyphInfo *ginfo = (GlyphInfo *)ptrs[i];
if (ginfo->cellInfo != NULL) {
// invalidate this glyph's accelerated cache cell
AccelGlyphCache_RemoveAllCellInfos(ginfo);
}
free((void*)ginfo);
}
}
(*env)->ReleasePrimitiveArrayCritical(env, jmemArray, ptrs, JNI_ABORT);
}
if (!isNullScalerContext(jlong_to_ptr(pContext))) {
free(jlong_to_ptr(pContext));
}
}
/*
* Class: sun_font_StrikeCache
* Method: freeLongMemory
* Signature: ([J)V
*/
JNIEXPORT void JNICALL Java_sun_font_StrikeCache_freeLongMemory
(JNIEnv *env, jclass cacheClass, jlongArray jmemArray, jlong pContext) {
int len = (*env)->GetArrayLength(env, jmemArray);
jlong* ptrs =
(jlong*)(*env)->GetPrimitiveArrayCritical(env, jmemArray, NULL);
int i;
if (ptrs) {
for (i=0; i< len; i++) {
if (ptrs[i] != 0L) {
GlyphInfo *ginfo = (GlyphInfo *) jlong_to_ptr(ptrs[i]);
if (ginfo->cellInfo != NULL &&
ginfo->managed == MANAGED_GLYPH) {
AccelGlyphCache_RemoveAllCellInfos(ginfo);
}
free((void*)ginfo);
}
}
(*env)->ReleasePrimitiveArrayCritical(env, jmemArray, ptrs, JNI_ABORT);
}
if (!isNullScalerContext(jlong_to_ptr(pContext))) {
free(jlong_to_ptr(pContext));
}
}
static FT_Outline* getFTOutline(JNIEnv* env, jobject font2D,
FTScalerContext *context, FTScalerInfo* scalerInfo,
jint glyphCode, jfloat xpos, jfloat ypos) {
int renderFlags;
int glyph_index;
FT_Error error;
FT_GlyphSlot ftglyph;
if (glyphCode >= INVISIBLE_GLYPHS ||
isNullScalerContext(context) || scalerInfo == NULL) {
return NULL;
}
error = setupFTContext(env, font2D, scalerInfo, context);
if (error) {
return NULL;
}
renderFlags = FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP;
glyph_index = FT_Get_Char_Index(scalerInfo->face, glyphCode);
error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderFlags);
if (error) {
return NULL;
}
ftglyph = scalerInfo->face->glyph;
/* apply styles */
if (context->doBold) { /* if bold style */
FT_GlyphSlot_Embolden(ftglyph);
}
if (context->doItalize) { /* if oblique */
FT_GlyphSlot_Oblique(ftglyph);
}
FT_Outline_Translate(&ftglyph->outline,
FloatToF26Dot6(xpos),
-FloatToF26Dot6(ypos));
return &ftglyph->outline;
}
/*
* Class: sun_font_FreetypeFontScaler
* Method: getGlyphImageNative
* Signature: (Lsun/font/Font2D;JI)J
*/
JNIEXPORT jlong JNICALL
Java_sun_font_FreetypeFontScaler_getGlyphImageNative(
JNIEnv *env, jobject scaler, jobject font2D,
jlong pScalerContext, jlong pScaler, jint glyphCode) {
int error, imageSize;
UInt16 width, height;
GlyphInfo *glyphInfo;
int glyph_index;
int renderFlags = FT_LOAD_RENDER, target;
FT_GlyphSlot ftglyph;
FTScalerContext* context =
(FTScalerContext*) jlong_to_ptr(pScalerContext);
FTScalerInfo *scalerInfo =
(FTScalerInfo*) jlong_to_ptr(pScaler);
if (isNullScalerContext(context) || scalerInfo == NULL) {
return ptr_to_jlong(getNullGlyphImage());
}
error = setupFTContext(env, font2D, scalerInfo, context);
if (error) {
invalidateJavaScaler(env, scaler, scalerInfo);
return ptr_to_jlong(getNullGlyphImage());
}
/* if algorithmic styling is required then we do not request bitmap */
if (context->doBold || context->doItalize) {
renderFlags = FT_LOAD_DEFAULT;
}
/* NB: in case of non identity transform
we might also prefer to disable transform before hinting,
and apply it explicitly after hinting is performed.
Or we can disable hinting. */
/* select appropriate hinting mode */
if (context->aaType == TEXT_AA_OFF) {
target = FT_LOAD_TARGET_MONO;
} else if (context->aaType == TEXT_AA_ON) {
target = FT_LOAD_TARGET_NORMAL;
} else if (context->aaType == TEXT_AA_LCD_HRGB ||
context->aaType == TEXT_AA_LCD_HBGR) {
target = FT_LOAD_TARGET_LCD;
} else {
target = FT_LOAD_TARGET_LCD_V;
}
renderFlags |= target;
glyph_index = FT_Get_Char_Index(scalerInfo->face, glyphCode);
error = FT_Load_Glyph(scalerInfo->face, glyphCode, renderFlags);
if (error) {
//do not destroy scaler yet.
//this can be problem of particular context (e.g. with bad transform)
return ptr_to_jlong(getNullGlyphImage());
}
ftglyph = scalerInfo->face->glyph;
/* apply styles */
if (context->doBold) { /* if bold style */
FT_GlyphSlot_Embolden(ftglyph);
}
if (context->doItalize) { /* if oblique */
FT_GlyphSlot_Oblique(ftglyph);
}
/* generate bitmap if it is not done yet
e.g. if algorithmic styling is performed and style was added to outline */
if (ftglyph->format == FT_GLYPH_FORMAT_OUTLINE) {
FT_Render_Glyph(ftglyph, FT_LOAD_TARGET_MODE(target));
}
width = (UInt16) ftglyph->bitmap.width;
height = (UInt16) ftglyph->bitmap.rows;
imageSize = width*height;
glyphInfo = (GlyphInfo*) malloc(sizeof(GlyphInfo) + imageSize);
if (glyphInfo == NULL) {
glyphInfo = getNullGlyphImage();
return ptr_to_jlong(glyphInfo);
}
glyphInfo->cellInfo = NULL;
glyphInfo->managed = UNMANAGED_GLYPH;
glyphInfo->rowBytes = width;
glyphInfo->width = width;
glyphInfo->height = height;
glyphInfo->topLeftX = (float) ftglyph->bitmap_left;
glyphInfo->topLeftY = (float) -ftglyph->bitmap_top;
if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD) {
glyphInfo->width = width/3;
} else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD_V) {
glyphInfo->height = glyphInfo->height/3;
}
if (context->fmType == TEXT_FM_ON) {
double advh = FTFixedToFloat(ftglyph->linearHoriAdvance);
glyphInfo->advanceX =
(float) (advh * FTFixedToFloat(context->transform.xx));
glyphInfo->advanceY =
(float) (advh * FTFixedToFloat(context->transform.xy));
} else {
if (!ftglyph->advance.y) {
glyphInfo->advanceX =
(float) ROUND(FT26Dot6ToFloat(ftglyph->advance.x));
glyphInfo->advanceY = 0;
} else if (!ftglyph->advance.x) {
glyphInfo->advanceX = 0;
glyphInfo->advanceY =
(float) ROUND(FT26Dot6ToFloat(-ftglyph->advance.y));
} else {
glyphInfo->advanceX = FT26Dot6ToFloat(ftglyph->advance.x);
glyphInfo->advanceY = FT26Dot6ToFloat(-ftglyph->advance.y);
}
}
if (imageSize == 0) {
glyphInfo->image = NULL;
} else {
glyphInfo->image = (unsigned char*) glyphInfo + sizeof(GlyphInfo);
//convert result to output format
//output format is either 3 bytes per pixel (for subpixel modes)
// or 1 byte per pixel for AA and B&W
if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) {
/* convert from 8 pixels per byte to 1 byte per pixel */
CopyBW2Grey8(ftglyph->bitmap.buffer,
ftglyph->bitmap.pitch,
(void *) glyphInfo->image,
width,
width,
height);
} else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY) {
/* byte per pixel to byte per pixel => just copy */
memcpy(glyphInfo->image, ftglyph->bitmap.buffer, imageSize);
} else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY4) {
/* 4 bits per pixel to byte per pixel */
CopyGrey4ToGrey8(ftglyph->bitmap.buffer,
ftglyph->bitmap.pitch,
(void *) glyphInfo->image,
width,
width,
height);
} else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD) {
/* 3 bytes per pixel to 3 bytes per pixel */
CopyFTSubpixelToSubpixel(ftglyph->bitmap.buffer,
ftglyph->bitmap.pitch,
(void *) glyphInfo->image,
width,
width,
height);
} else if (ftglyph->bitmap.pixel_mode == FT_PIXEL_MODE_LCD_V) {
/* 3 bytes per pixel to 3 bytes per pixel */
CopyFTSubpixelVToSubpixel(ftglyph->bitmap.buffer,
ftglyph->bitmap.pitch,
(void *) glyphInfo->image,
width*3,
width,
height);
glyphInfo->rowBytes *=3;
} else {
free(glyphInfo);
glyphInfo = getNullGlyphImage();
}
}
return ptr_to_jlong(glyphInfo);
}
/*
* Class: sun_font_FreetypeFontScaler
* Method: getFontMetricsNative
* Signature: (Lsun/font/Font2D;J)Lsun/font/StrikeMetrics;
*/
JNIEXPORT jobject JNICALL
Java_sun_font_FreetypeFontScaler_getFontMetricsNative(
JNIEnv *env, jobject scaler, jobject font2D,
jlong pScalerContext, jlong pScaler) {
jobject metrics;
jfloat ax, ay, dx, dy, bx, by, lx, ly, mx, my;
jfloat f0 = 0.0;
FTScalerContext *context =
(FTScalerContext*) jlong_to_ptr(pScalerContext);
FTScalerInfo *scalerInfo =
(FTScalerInfo*) jlong_to_ptr(pScaler);
int errCode;
if (isNullScalerContext(context) || scalerInfo == NULL) {
return (*env)->NewObject(env,
sunFontIDs.strikeMetricsClass,
sunFontIDs.strikeMetricsCtr,
f0, f0, f0, f0, f0, f0, f0, f0, f0, f0);
}
errCode = setupFTContext(env, font2D, scalerInfo, context);
if (errCode) {
metrics = (*env)->NewObject(env,
sunFontIDs.strikeMetricsClass,
sunFontIDs.strikeMetricsCtr,
f0, f0, f0, f0, f0, f0, f0, f0, f0, f0);
invalidateJavaScaler(env, scaler, scalerInfo);
return metrics;
}
/* This is ugly and has to be reworked.
Freetype provide means to add style to glyph but
it seems there is no way to adjust metrics accordingly.
So, we have to do adust them explicitly and stay consistent with what
freetype does to outlines. */
/**** Note: only some metrics are affected by styling ***/
/* See https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=657854 */
#define FT_MulFixFloatShift6(a, b) (((float) (a)) * ((float) (b)) / 65536.0 / 64.0)
/*
* See FreeType source code: src/base/ftobjs.c ft_recompute_scaled_metrics()
* http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=1659
*/
/* ascent */
ax = 0;
ay = -(jfloat) (FT_MulFixFloatShift6(
((jlong) scalerInfo->face->ascender),
(jlong) scalerInfo->face->size->metrics.y_scale));
/* descent */
dx = 0;
dy = -(jfloat) (FT_MulFixFloatShift6(
((jlong) scalerInfo->face->descender),
(jlong) scalerInfo->face->size->metrics.y_scale));
/* baseline */
bx = by = 0;
/* leading */
lx = 0;
ly = (jfloat) (FT_MulFixFloatShift6(
(jlong) scalerInfo->face->height,
(jlong) scalerInfo->face->size->metrics.y_scale))
+ ay - dy;
/* max advance */
mx = (jfloat) FT26Dot6ToFloat(
scalerInfo->face->size->metrics.max_advance +
OBLIQUE_MODIFIER(scalerInfo->face->size->metrics.height));
my = 0;
metrics = (*env)->NewObject(env,
sunFontIDs.strikeMetricsClass,
sunFontIDs.strikeMetricsCtr,
ax, ay, dx, dy, bx, by, lx, ly, mx, my);
return metrics;
}
