No longer disable E_OLD_STYLE_FUNC_DEF.
/*
* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include "jlong.h"
#include "math.h"
#include "string.h"
#include "stdlib.h"
#include "sunfontids.h"
#include "fontscalerdefs.h"
#include "glyphblitting.h"
#include "GraphicsPrimitiveMgr.h"
#include "sun_java2d_loops_DrawGlyphList.h"
#include "sun_java2d_loops_DrawGlyphListAA.h"
/*
* Need to account for the rare case when (eg) repainting damaged
* areas results in the drawing location being negative, in which
* case (int) rounding always goes towards zero. We need to always
* round down instead, so that we paint at the correct position.
* We only call "floor" when value is < 0 (ie rarely).
* Storing the result of (eg) (x+ginfo->topLeftX) benchmarks is more
* expensive than repeating the calculation as we do here.
* "floor" shows up as a significant cost in app-level microbenchmarks.
* This macro avoids calling it on positive values, instead using an
* (int) cast.
*/
#define FLOOR_ASSIGN(l, r)\
if ((r)<0) (l) = ((int)floor(r)); else (l) = ((int)(r))
GlyphBlitVector* setupBlitVector(JNIEnv *env, jobject glyphlist) {
int g;
size_t bytesNeeded;
jlong *imagePtrs;
jfloat* positions = NULL;
GlyphInfo *ginfo;
GlyphBlitVector *gbv;
jfloat x = (*env)->GetFloatField(env, glyphlist, sunFontIDs.glyphListX);
jfloat y = (*env)->GetFloatField(env, glyphlist, sunFontIDs.glyphListY);
jint len = (*env)->GetIntField(env, glyphlist, sunFontIDs.glyphListLen);
jlongArray glyphImages = (jlongArray)
(*env)->GetObjectField(env, glyphlist, sunFontIDs.glyphImages);
jfloatArray glyphPositions =
(*env)->GetBooleanField(env, glyphlist, sunFontIDs.glyphListUsePos)
? (jfloatArray)
(*env)->GetObjectField(env, glyphlist, sunFontIDs.glyphListPos)
: NULL;
bytesNeeded = sizeof(GlyphBlitVector)+sizeof(ImageRef)*len;
gbv = (GlyphBlitVector*)malloc(bytesNeeded);
if (gbv == NULL) {
return NULL;
}
gbv->numGlyphs = len;
gbv->glyphs = (ImageRef*)((unsigned char*)gbv+sizeof(GlyphBlitVector));
imagePtrs = (*env)->GetPrimitiveArrayCritical(env, glyphImages, NULL);
if (imagePtrs == NULL) {
free(gbv);
return (GlyphBlitVector*)NULL;
}
/* Add 0.5 to x and y and then use floor (or an equivalent operation)
* to round down the glyph positions to integral pixel positions.
*/
x += 0.5f;
y += 0.5f;
if (glyphPositions) {
int n = -1;
positions =
(*env)->GetPrimitiveArrayCritical(env, glyphPositions, NULL);
if (positions == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, glyphImages,
imagePtrs, JNI_ABORT);
free(gbv);
return (GlyphBlitVector*)NULL;
}
for (g=0; g<len; g++) {
jfloat px = x + positions[++n];
jfloat py = y + positions[++n];
ginfo = (GlyphInfo*)imagePtrs[g];
gbv->glyphs[g].glyphInfo = ginfo;
gbv->glyphs[g].pixels = ginfo->image;
gbv->glyphs[g].width = ginfo->width;
gbv->glyphs[g].rowBytes = ginfo->rowBytes;
gbv->glyphs[g].height = ginfo->height;
FLOOR_ASSIGN(gbv->glyphs[g].x, px + ginfo->topLeftX);
FLOOR_ASSIGN(gbv->glyphs[g].y, py + ginfo->topLeftY);
}
(*env)->ReleasePrimitiveArrayCritical(env,glyphPositions,
positions, JNI_ABORT);
} else {
for (g=0; g<len; g++) {
ginfo = (GlyphInfo*)imagePtrs[g];
gbv->glyphs[g].glyphInfo = ginfo;
gbv->glyphs[g].pixels = ginfo->image;
gbv->glyphs[g].width = ginfo->width;
gbv->glyphs[g].rowBytes = ginfo->rowBytes;
gbv->glyphs[g].height = ginfo->height;
FLOOR_ASSIGN(gbv->glyphs[g].x, x + ginfo->topLeftX);
FLOOR_ASSIGN(gbv->glyphs[g].y, y + ginfo->topLeftY);
/* copy image data into this array at x/y locations */
x += ginfo->advanceX;
y += ginfo->advanceY;
}
}
(*env)->ReleasePrimitiveArrayCritical(env, glyphImages, imagePtrs,
JNI_ABORT);
return gbv;
}
jint RefineBounds(GlyphBlitVector *gbv, SurfaceDataBounds *bounds) {
int index;
jint dx1, dy1, dx2, dy2;
ImageRef glyphImage;
int num = gbv->numGlyphs;
SurfaceDataBounds glyphs;
glyphs.x1 = glyphs.y1 = 0x7fffffff;
glyphs.x2 = glyphs.y2 = 0x80000000;
for (index = 0; index < num; index++) {
glyphImage = gbv->glyphs[index];
dx1 = (jint) glyphImage.x;
dy1 = (jint) glyphImage.y;
dx2 = dx1 + glyphImage.width;
dy2 = dy1 + glyphImage.height;
if (glyphs.x1 > dx1) glyphs.x1 = dx1;
if (glyphs.y1 > dy1) glyphs.y1 = dy1;
if (glyphs.x2 < dx2) glyphs.x2 = dx2;
if (glyphs.y2 < dy2) glyphs.y2 = dy2;
}
SurfaceData_IntersectBounds(bounds, &glyphs);
return (bounds->x1 < bounds->x2 && bounds->y1 < bounds->y2);
}
/* since the AA and non-AA loop functions share a common method
* signature, can call both through this common function since
* there's no difference except for the inner loop.
* This could be a macro but there's enough of those already.
*/
static void drawGlyphList(JNIEnv *env, jobject self,
jobject sg2d, jobject sData,
GlyphBlitVector *gbv, jint pixel, jint color,
NativePrimitive *pPrim, DrawGlyphListFunc *func) {
SurfaceDataOps *sdOps;
SurfaceDataRasInfo rasInfo;
CompositeInfo compInfo;
int clipLeft, clipRight, clipTop, clipBottom;
int ret;
sdOps = SurfaceData_GetOps(env, sData);
if (sdOps == 0) {
return;
}
if (pPrim->pCompType->getCompInfo != NULL) {
GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);
}
GrPrim_Sg2dGetClip(env, sg2d, &rasInfo.bounds);
if (rasInfo.bounds.y2 <= rasInfo.bounds.y1 ||
rasInfo.bounds.x2 <= rasInfo.bounds.x1)
{
return;
}
ret = sdOps->Lock(env, sdOps, &rasInfo, pPrim->dstflags);
if (ret != SD_SUCCESS) {
if (ret == SD_SLOWLOCK) {
if (!RefineBounds(gbv, &rasInfo.bounds)) {
SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
return;
}
} else {
return;
}
}
sdOps->GetRasInfo(env, sdOps, &rasInfo);
if (!rasInfo.rasBase) {
SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
return;
}
clipLeft = rasInfo.bounds.x1;
clipRight = rasInfo.bounds.x2;
clipTop = rasInfo.bounds.y1;
clipBottom = rasInfo.bounds.y2;
if (clipRight > clipLeft && clipBottom > clipTop) {
(*func)(&rasInfo,
gbv->glyphs, gbv->numGlyphs,
pixel, color,
clipLeft, clipTop,
clipRight, clipBottom,
pPrim, &compInfo);
SurfaceData_InvokeRelease(env, sdOps, &rasInfo);
}
SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
}
static unsigned char* getLCDGammaLUT(int gamma);
static unsigned char* getInvLCDGammaLUT(int gamma);
static void drawGlyphListLCD(JNIEnv *env, jobject self,
jobject sg2d, jobject sData,
GlyphBlitVector *gbv, jint pixel, jint color,
jboolean rgbOrder, int contrast,
NativePrimitive *pPrim,
DrawGlyphListLCDFunc *func) {
SurfaceDataOps *sdOps;
SurfaceDataRasInfo rasInfo;
CompositeInfo compInfo;
int clipLeft, clipRight, clipTop, clipBottom;
int ret;
sdOps = SurfaceData_GetOps(env, sData);
if (sdOps == 0) {
return;
}
if (pPrim->pCompType->getCompInfo != NULL) {
GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);
}
GrPrim_Sg2dGetClip(env, sg2d, &rasInfo.bounds);
if (rasInfo.bounds.y2 <= rasInfo.bounds.y1 ||
rasInfo.bounds.x2 <= rasInfo.bounds.x1)
{
return;
}
ret = sdOps->Lock(env, sdOps, &rasInfo, pPrim->dstflags);
if (ret != SD_SUCCESS) {
if (ret == SD_SLOWLOCK) {
if (!RefineBounds(gbv, &rasInfo.bounds)) {
SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
return;
}
} else {
return;
}
}
sdOps->GetRasInfo(env, sdOps, &rasInfo);
if (!rasInfo.rasBase) {
SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
return;
}
clipLeft = rasInfo.bounds.x1;
clipRight = rasInfo.bounds.x2;
clipTop = rasInfo.bounds.y1;
clipBottom = rasInfo.bounds.y2;
if (clipRight > clipLeft && clipBottom > clipTop) {
(*func)(&rasInfo,
gbv->glyphs, gbv->numGlyphs,
pixel, color,
clipLeft, clipTop,
clipRight, clipBottom, (jint)rgbOrder,
getLCDGammaLUT(contrast), getInvLCDGammaLUT(contrast),
pPrim, &compInfo);
SurfaceData_InvokeRelease(env, sdOps, &rasInfo);
}
SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
}
/*
* Class: sun_java2d_loops_DrawGlyphList
* Method: DrawGlyphList
* Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;Lsun/java2d/font/GlyphList;J)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_loops_DrawGlyphList_DrawGlyphList
(JNIEnv *env, jobject self,
jobject sg2d, jobject sData, jobject glyphlist) {
jint pixel, color;
GlyphBlitVector* gbv;
NativePrimitive *pPrim;
if ((pPrim = GetNativePrim(env, self)) == NULL) {
return;
}
if ((gbv = setupBlitVector(env, glyphlist)) == NULL) {
return;
}
pixel = GrPrim_Sg2dGetPixel(env, sg2d);
color = GrPrim_Sg2dGetEaRGB(env, sg2d);
drawGlyphList(env, self, sg2d, sData, gbv, pixel, color,
pPrim, pPrim->funcs.drawglyphlist);
free(gbv);
}
/*
* Class: sun_java2d_loops_DrawGlyphListAA
* Method: DrawGlyphListAA
* Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;Lsun/java2d/font/GlyphList;J)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_loops_DrawGlyphListAA_DrawGlyphListAA
(JNIEnv *env, jobject self,
jobject sg2d, jobject sData, jobject glyphlist) {
jint pixel, color;
GlyphBlitVector* gbv;
NativePrimitive *pPrim;
if ((pPrim = GetNativePrim(env, self)) == NULL) {
return;
}
if ((gbv = setupBlitVector(env, glyphlist)) == NULL) {
return;
}
pixel = GrPrim_Sg2dGetPixel(env, sg2d);
color = GrPrim_Sg2dGetEaRGB(env, sg2d);
drawGlyphList(env, self, sg2d, sData, gbv, pixel, color,
pPrim, pPrim->funcs.drawglyphlistaa);
free(gbv);
}
/*
* Class: sun_java2d_loops_DrawGlyphListLCD
* Method: DrawGlyphListLCD
* Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;Lsun/java2d/font/GlyphList;J)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_loops_DrawGlyphListLCD_DrawGlyphListLCD
(JNIEnv *env, jobject self,
jobject sg2d, jobject sData, jobject glyphlist) {
jint pixel, color, contrast;
jboolean rgbOrder;
GlyphBlitVector* gbv;
NativePrimitive *pPrim;
if ((pPrim = GetNativePrim(env, self)) == NULL) {
return;
}
if ((gbv = setupLCDBlitVector(env, glyphlist)) == NULL) {
return;
}
pixel = GrPrim_Sg2dGetPixel(env, sg2d);
color = GrPrim_Sg2dGetEaRGB(env, sg2d);
contrast = GrPrim_Sg2dGetLCDTextContrast(env, sg2d);
rgbOrder = (*env)->GetBooleanField(env,glyphlist, sunFontIDs.lcdRGBOrder);
drawGlyphListLCD(env, self, sg2d, sData, gbv, pixel, color,
rgbOrder, contrast,
pPrim, pPrim->funcs.drawglyphlistlcd);
free(gbv);
}
/*
* LCD text utilises a filter which spreads energy to adjacent subpixels.
* So we add 3 bytes (one whole pixel) of padding at the start of every row
* to hold energy from the very leftmost sub-pixel.
* This is to the left of the intended glyph image position so LCD text also
* adjusts the top-left X position of the padded image one pixel to the left
* so a glyph image is drawn in the same place it would be if the padding
* were not present.
*
* So in the glyph cache for LCD text the first two bytes of every row are
* zero.
* We make use of this to be able to adjust the rendering position of the
* text when the client specifies a fractional metrics sub-pixel positioning
* rendering hint.
*
* So the first 6 bytes in a cache row looks like :
* 00 00 Ex G0 G1 G2
*
* where
* 00 are the always zero bytes
* Ex is extra energy spread from the glyph into the left padding pixel.
* Gn are the RGB component bytes of the first pixel of the glyph image
* For an RGB display G0 is the red component, etc.
*
* If a glyph is drawn at X=12 then the G0 G1 G2 pixel is placed at that
* position : ie G0 is drawn in the first sub-pixel at X=12
*
* Draw at X=12,0
* PIXEL POS 11 11 11 12 12 12 13 13 13
* SUBPX POS 0 1 2 0 1 2 0 1 2
* 00 00 Ex G0 G1 G2
*
* If a sub-pixel rounded glyph position is calculated as being X=12.33 -
* ie 12 and one-third pixels, we want the result to look like this :
* Draw at X=12,1
* PIXEL POS 11 11 11 12 12 12 13 13 13
* SUBPX POS 0 1 2 0 1 2 0 1 2
* 00 00 Ex G0 G1 G2
*
* ie the G0 byte is moved one sub-pixel to the right.
* To do this we need to make two adjustments :
* - set X=X+1
* - set start of scan row to start+2, ie index past the two zero bytes
* ie we don't need the 00 00 bytes at all any more. Rendering start X
* can skip over those.
*
* Lets look at the final case :
* If a sub-pixel rounded glyph position is calculated as being X=12.67 -
* ie 12 and two-third pixels, we want the result to look like this :
* Draw at X=12,2
* PIXEL POS 11 11 11 12 12 12 13 13 13
* SUBPX POS 0 1 2 0 1 2 0 1 2
* 00 00 Ex G0 G1 G2
*
* ie the G0 byte is moved two sub-pixels to the right, so that the image
* starts at 12.67
* To do this we need to make these two adjustments :
* - set X=X+1
* - set start of scan row to start+1, ie index past the first zero byte
* In this case the second of the 00 bytes is used as a no-op on the first
* red sub-pixel position.
*
* The final adjustment needed to make all this work is note that if
* we moved the start of row one or two bytes in we will go one or two bytes
* past the end of the row. So the glyph cache needs to have 2 bytes of
* zero padding at the end of each row. This is the extra memory cost to
* accommodate this algorithm.
*
* The resulting text is perhaps fractionally better in overall perception
* than rounding to the whole pixel grid, as a few issues arise.
*
* * the improvement in inter-glyph spacing as well as being limited
* to 1/3 pixel resolution, is also limited because the glyphs were hinted
* so they fit to the whole pixel grid. It may be worthwhile to pursue
* disabling x-axis gridfitting.
*
* * an LCD display may have gaps between the pixels that are greater
* than the subpixels. Thus for thin stemmed fonts, if the shift causes
* the "heart" of a stem to span whole pixels it may appear more diffuse -
* less sharp. Eliminating hinting would probably not make this worse - in
* effect we have already doing that here. But it would improve the spacing.
*
* * perhaps contradicting the above point in some ways, more diffuse glyphs
* are better at reducing colour fringing, but what appears to be more
* colour fringing in this FM case is more likely attributable to a greater
* likelihood for glyphs to abutt. In integer metrics or even whole pixel
* rendered fractional metrics, there's typically more space between the
* glyphs. Perhaps disabling X-axis grid-fitting will help with that.
*/
GlyphBlitVector* setupLCDBlitVector(JNIEnv *env, jobject glyphlist) {
int g;
size_t bytesNeeded;
jlong *imagePtrs;
jfloat* positions = NULL;
GlyphInfo *ginfo;
GlyphBlitVector *gbv;
jfloat x = (*env)->GetFloatField(env, glyphlist, sunFontIDs.glyphListX);
jfloat y = (*env)->GetFloatField(env, glyphlist, sunFontIDs.glyphListY);
jint len = (*env)->GetIntField(env, glyphlist, sunFontIDs.glyphListLen);
jlongArray glyphImages = (jlongArray)
(*env)->GetObjectField(env, glyphlist, sunFontIDs.glyphImages);
jfloatArray glyphPositions =
(*env)->GetBooleanField(env, glyphlist, sunFontIDs.glyphListUsePos)
? (jfloatArray)
(*env)->GetObjectField(env, glyphlist, sunFontIDs.glyphListPos)
: NULL;
jboolean subPixPos =
(*env)->GetBooleanField(env,glyphlist, sunFontIDs.lcdSubPixPos);
bytesNeeded = sizeof(GlyphBlitVector)+sizeof(ImageRef)*len;
gbv = (GlyphBlitVector*)malloc(bytesNeeded);
if (gbv == NULL) {
return NULL;
}
gbv->numGlyphs = len;
gbv->glyphs = (ImageRef*)((unsigned char*)gbv+sizeof(GlyphBlitVector));
imagePtrs = (*env)->GetPrimitiveArrayCritical(env, glyphImages, NULL);
if (imagePtrs == NULL) {
free(gbv);
return (GlyphBlitVector*)NULL;
}
/* The position of the start of the text is adjusted up so
* that we can round it to an integral pixel position for a
* bitmap glyph or non-subpixel positioning, and round it to an
* integral subpixel position for that case, hence 0.5/3 = 0.166667
* Presently subPixPos means FM, and FM disables embedded bitmaps
* Therefore if subPixPos is true we should never get embedded bitmaps
* and the glyphlist will be homogenous. This test and the position
* adjustments will need to be per glyph once this case becomes
* heterogenous.
* Also set subPixPos=false if detect a B&W bitmap as we only
* need to test that on a per glyph basis once the list becomes
* heterogenous
*/
if (subPixPos && len > 0) {
ginfo = (GlyphInfo*)imagePtrs[0];
/* rowBytes==width tests if its a B&W or LCD glyph */
if (ginfo->width == ginfo->rowBytes) {
subPixPos = JNI_FALSE;
}
}
if (subPixPos) {
x += 0.1666667f;
y += 0.1666667f;
} else {
x += 0.5f;
y += 0.5f;
}
if (glyphPositions) {
int n = -1;
positions =
(*env)->GetPrimitiveArrayCritical(env, glyphPositions, NULL);
if (positions == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, glyphImages,
imagePtrs, JNI_ABORT);
free(gbv);
return (GlyphBlitVector*)NULL;
}
for (g=0; g<len; g++) {
jfloat px, py;
ginfo = (GlyphInfo*)imagePtrs[g];
gbv->glyphs[g].glyphInfo = ginfo;
gbv->glyphs[g].pixels = ginfo->image;
gbv->glyphs[g].width = ginfo->width;
gbv->glyphs[g].rowBytes = ginfo->rowBytes;
gbv->glyphs[g].height = ginfo->height;
px = x + positions[++n];
py = y + positions[++n];
/*
* Subpixel positioning may be requested for LCD text.
*
* Subpixel positioning can take place only in the direction in
* which the subpixels increase the resolution.
* So this is useful for the typical case of vertical stripes
* increasing the resolution in the direction of the glyph
* advances - ie typical horizontally laid out text.
* If the subpixel stripes are horizontal, subpixel positioning
* can take place only in the vertical direction, which isn't
* as useful - you would have to be drawing rotated text on
* a display which actually had that organisation. A pretty
* unlikely combination.
* So this is supported only for vertical stripes which
* increase the horizontal resolution.
* If in this case the client also rotates the text then there
* will still be some benefit for small rotations. For 90 degree
* rotation there's no horizontal advance and less benefit
* from the subpixel rendering too.
* The test for width==rowBytes detects the case where the glyph
* is a B&W image obtained from an embedded bitmap. In that
* case we cannot apply sub-pixel positioning so ignore it.
* This is handled on a per glyph basis.
*/
if (subPixPos) {
int frac;
float pos = px + ginfo->topLeftX;
FLOOR_ASSIGN(gbv->glyphs[g].x, pos);
/* Calculate the fractional pixel position - ie the subpixel
* position within the RGB/BGR triple. We are rounding to
* the nearest, even though we just do (int) since at the
* start of the loop the position was already adjusted by
* 0.5 (sub)pixels to get rounding.
* Thus the "fractional" position will be 0, 1 or 2.
* eg 0->0.32 is 0, 0.33->0.66 is 1, > 0.66->0.99 is 2.
* We can use an (int) cast here since the floor operation
* above guarantees us that the value is positive.
*/
frac = (int)((pos - gbv->glyphs[g].x)*3);
if (frac == 0) {
/* frac rounded down to zero, so this is equivalent
* to no sub-pixel positioning.
*/
gbv->glyphs[g].rowBytesOffset = 0;
} else {
/* In this case we need to adjust both the position at
* which the glyph will be positioned by one pixel to the
* left and adjust the position in the glyph image row
* from which to extract the data
* Every glyph image row has 2 bytes padding
* on the right to account for this.
*/
gbv->glyphs[g].rowBytesOffset = 3-frac;
gbv->glyphs[g].x += 1;
}
} else {
FLOOR_ASSIGN(gbv->glyphs[g].x, px + ginfo->topLeftX);
gbv->glyphs[g].rowBytesOffset = 0;
}
FLOOR_ASSIGN(gbv->glyphs[g].y, py + ginfo->topLeftY);
}
(*env)->ReleasePrimitiveArrayCritical(env,glyphPositions,
positions, JNI_ABORT);
} else {
for (g=0; g<len; g++) {
ginfo = (GlyphInfo*)imagePtrs[g];
gbv->glyphs[g].glyphInfo = ginfo;
gbv->glyphs[g].pixels = ginfo->image;
gbv->glyphs[g].width = ginfo->width;
gbv->glyphs[g].rowBytes = ginfo->rowBytes;
gbv->glyphs[g].height = ginfo->height;
if (subPixPos) {
int frac;
float pos = x + ginfo->topLeftX;
FLOOR_ASSIGN(gbv->glyphs[g].x, pos);
frac = (int)((pos - gbv->glyphs[g].x)*3);
if (frac == 0) {
gbv->glyphs[g].rowBytesOffset = 0;
} else {
gbv->glyphs[g].rowBytesOffset = 3-frac;
gbv->glyphs[g].x += 1;
}
} else {
FLOOR_ASSIGN(gbv->glyphs[g].x, x + ginfo->topLeftX);
gbv->glyphs[g].rowBytesOffset = 0;
}
FLOOR_ASSIGN(gbv->glyphs[g].y, y + ginfo->topLeftY);
/* copy image data into this array at x/y locations */
x += ginfo->advanceX;
y += ginfo->advanceY;
}
}
(*env)->ReleasePrimitiveArrayCritical(env, glyphImages, imagePtrs,
JNI_ABORT);
return gbv;
}
/* LCD text needs to go through a gamma (contrast) adjustment.
* Gamma is constrained to the range 1.0->2.2 with a quantization of
* 0.01 (more than good enough). Representing as an integer with that
* precision yields a range 100->250 thus we need to store up to 151 LUTs
* and inverse LUTs.
* We allocate the actual LUTs on an as needed basis. Typically zero or
* one is what will be needed.
* Colour component values are in the range 0.0->1.0 represented as an integer
* in the range 0->255 (ie in a byte). It is assumed that even if we have 5
* bit colour components these are presented mapped on to 8 bit components.
* lcdGammaLUT references LUTs which convert linear colour components
* to a gamma adjusted space, and
* lcdInvGammaLUT references LUTs which convert gamma adjusted colour
* components to a linear space.
*/
#define MIN_GAMMA 100
#define MAX_GAMMA 250
#define LCDLUTCOUNT (MAX_GAMMA-MIN_GAMMA+1)
UInt8 *lcdGammaLUT[LCDLUTCOUNT];
UInt8 *lcdInvGammaLUT[LCDLUTCOUNT];
void initLUT(int gamma) {
int i,index;
double ig,g;
index = gamma-MIN_GAMMA;
lcdGammaLUT[index] = (UInt8*)malloc(256);
lcdInvGammaLUT[index] = (UInt8*)malloc(256);
if (gamma==100) {
for (i=0;i<256;i++) {
lcdGammaLUT[index][i] = (UInt8)i;
lcdInvGammaLUT[index][i] = (UInt8)i;
}
return;
}
ig = ((double)gamma)/100.0;
g = 1.0/ig;
lcdGammaLUT[index][0] = (UInt8)0;
lcdInvGammaLUT[index][0] = (UInt8)0;
lcdGammaLUT[index][255] = (UInt8)255;
lcdInvGammaLUT[index][255] = (UInt8)255;
for (i=1;i<255;i++) {
double val = ((double)i)/255.0;
double gval = pow(val, g);
double igval = pow(val, ig);
lcdGammaLUT[index][i] = (UInt8)(255*gval);
lcdInvGammaLUT[index][i] = (UInt8)(255*igval);
}
}
static unsigned char* getLCDGammaLUT(int gamma) {
int index;
if (gamma<MIN_GAMMA) {
gamma = MIN_GAMMA;
} else if (gamma>MAX_GAMMA) {
gamma = MAX_GAMMA;
}
index = gamma-MIN_GAMMA;
if (!lcdGammaLUT[index]) {
initLUT(gamma);
}
return (unsigned char*)lcdGammaLUT[index];
}
static unsigned char* getInvLCDGammaLUT(int gamma) {
int index;
if (gamma<MIN_GAMMA) {
gamma = MIN_GAMMA;
} else if (gamma>MAX_GAMMA) {
gamma = MAX_GAMMA;
}
index = gamma-MIN_GAMMA;
if (!lcdInvGammaLUT[index]) {
initLUT(gamma);
}
return (unsigned char*)lcdInvGammaLUT[index];
}
#if 0
void printDefaultTables(int gamma) {
int i;
UInt8 *g, *ig;
lcdGammaLUT[gamma-MIN_GAMMA] = NULL;
lcdInvGammaLUT[gamma-MIN_GAMMA] = NULL;
g = getLCDGammaLUT(gamma);
ig = getInvLCDGammaLUT(gamma);
printf("UInt8 defaultGammaLUT[256] = {\n");
for (i=0;i<256;i++) {
if (i % 8 == 0) {
printf(" /* %3d */ ", i);
}
printf("%4d, ",(int)(g[i]&0xff));
if ((i+1) % 8 == 0) {
printf("\n");
}
}
printf("};\n");
printf("UInt8 defaultInvGammaLUT[256] = {\n");
for (i=0;i<256;i++) {
if (i % 8 == 0) {
printf(" /* %3d */ ", i);
}
printf("%4d, ",(int)(ig[i]&0xff));
if ((i+1) % 8 == 0) {
printf("\n");
}
}
printf("};\n");
}
#endif
/* These tables are generated for a Gamma adjustment of 1.4 */
UInt8 defaultGammaLUT[256] = {
/* 0 */ 0, 4, 7, 10, 13, 15, 17, 19,
/* 8 */ 21, 23, 25, 27, 28, 30, 32, 33,
/* 16 */ 35, 36, 38, 39, 41, 42, 44, 45,
/* 24 */ 47, 48, 49, 51, 52, 53, 55, 56,
/* 32 */ 57, 59, 60, 61, 62, 64, 65, 66,
/* 40 */ 67, 69, 70, 71, 72, 73, 75, 76,
/* 48 */ 77, 78, 79, 80, 81, 83, 84, 85,
/* 56 */ 86, 87, 88, 89, 90, 91, 92, 93,
/* 64 */ 94, 96, 97, 98, 99, 100, 101, 102,
/* 72 */ 103, 104, 105, 106, 107, 108, 109, 110,
/* 80 */ 111, 112, 113, 114, 115, 116, 117, 118,
/* 88 */ 119, 120, 121, 122, 123, 124, 125, 125,
/* 96 */ 126, 127, 128, 129, 130, 131, 132, 133,
/* 104 */ 134, 135, 136, 137, 138, 138, 139, 140,
/* 112 */ 141, 142, 143, 144, 145, 146, 147, 147,
/* 120 */ 148, 149, 150, 151, 152, 153, 154, 154,
/* 128 */ 155, 156, 157, 158, 159, 160, 161, 161,
/* 136 */ 162, 163, 164, 165, 166, 167, 167, 168,
/* 144 */ 169, 170, 171, 172, 172, 173, 174, 175,
/* 152 */ 176, 177, 177, 178, 179, 180, 181, 181,
/* 160 */ 182, 183, 184, 185, 186, 186, 187, 188,
/* 168 */ 189, 190, 190, 191, 192, 193, 194, 194,
/* 176 */ 195, 196, 197, 198, 198, 199, 200, 201,
/* 184 */ 201, 202, 203, 204, 205, 205, 206, 207,
/* 192 */ 208, 208, 209, 210, 211, 212, 212, 213,
/* 200 */ 214, 215, 215, 216, 217, 218, 218, 219,
/* 208 */ 220, 221, 221, 222, 223, 224, 224, 225,
/* 216 */ 226, 227, 227, 228, 229, 230, 230, 231,
/* 224 */ 232, 233, 233, 234, 235, 236, 236, 237,
/* 232 */ 238, 239, 239, 240, 241, 242, 242, 243,
/* 240 */ 244, 244, 245, 246, 247, 247, 248, 249,
/* 248 */ 249, 250, 251, 252, 252, 253, 254, 255,
};
UInt8 defaultInvGammaLUT[256] = {
/* 0 */ 0, 0, 0, 0, 0, 1, 1, 1,
/* 8 */ 2, 2, 2, 3, 3, 3, 4, 4,
/* 16 */ 5, 5, 6, 6, 7, 7, 8, 8,
/* 24 */ 9, 9, 10, 10, 11, 12, 12, 13,
/* 32 */ 13, 14, 15, 15, 16, 17, 17, 18,
/* 40 */ 19, 19, 20, 21, 21, 22, 23, 23,
/* 48 */ 24, 25, 26, 26, 27, 28, 29, 29,
/* 56 */ 30, 31, 32, 32, 33, 34, 35, 36,
/* 64 */ 36, 37, 38, 39, 40, 40, 41, 42,
/* 72 */ 43, 44, 45, 45, 46, 47, 48, 49,
/* 80 */ 50, 51, 52, 52, 53, 54, 55, 56,
/* 88 */ 57, 58, 59, 60, 61, 62, 63, 64,
/* 96 */ 64, 65, 66, 67, 68, 69, 70, 71,
/* 104 */ 72, 73, 74, 75, 76, 77, 78, 79,
/* 112 */ 80, 81, 82, 83, 84, 85, 86, 87,
/* 120 */ 88, 89, 90, 91, 92, 93, 95, 96,
/* 128 */ 97, 98, 99, 100, 101, 102, 103, 104,
/* 136 */ 105, 106, 107, 109, 110, 111, 112, 113,
/* 144 */ 114, 115, 116, 117, 119, 120, 121, 122,
/* 152 */ 123, 124, 125, 127, 128, 129, 130, 131,
/* 160 */ 132, 133, 135, 136, 137, 138, 139, 140,
/* 168 */ 142, 143, 144, 145, 146, 148, 149, 150,
/* 176 */ 151, 152, 154, 155, 156, 157, 159, 160,
/* 184 */ 161, 162, 163, 165, 166, 167, 168, 170,
/* 192 */ 171, 172, 173, 175, 176, 177, 178, 180,
/* 200 */ 181, 182, 184, 185, 186, 187, 189, 190,
/* 208 */ 191, 193, 194, 195, 196, 198, 199, 200,
/* 216 */ 202, 203, 204, 206, 207, 208, 210, 211,
/* 224 */ 212, 214, 215, 216, 218, 219, 220, 222,
/* 232 */ 223, 224, 226, 227, 228, 230, 231, 232,
/* 240 */ 234, 235, 236, 238, 239, 241, 242, 243,
/* 248 */ 245, 246, 248, 249, 250, 252, 253, 255,
};
/* Since our default is 140, here we can populate that from pre-calculated
* data, it needs only 512 bytes - plus a few more of overhead - and saves
* about that many intrinsic function calls plus other FP calculations.
*/
void initLCDGammaTables(void) {
memset(lcdGammaLUT, 0, LCDLUTCOUNT * sizeof(UInt8*));
memset(lcdInvGammaLUT, 0, LCDLUTCOUNT * sizeof(UInt8*));
/* printDefaultTables(140); */
lcdGammaLUT[40] = defaultGammaLUT;
lcdInvGammaLUT[40] = defaultInvGammaLUT;
}