ref: 529d4ea7a08021bfd2abcc703515f13f19d2f4ee
dir: /src/base/ftglyph.c/
/***************************************************************************/
/* */
/* ftglyph.c */
/* */
/* FreeType convenience functions to handle glyphs.. */
/* */
/* Copyright 1996-1999 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
/* modified and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/* This file contains the definition of several convenience functions */
/* that can be used by client applications to easily retrieve glyph */
/* bitmaps and outlines from a given face. */
/* */
/* These functions should be optional if you're writing a font server */
/* or text layout engine on top of FreeType. However, they are pretty */
/* handy for many other simple uses of the library.. */
/* */
/***************************************************************************/
#include <freetype/ftglyph.h>
#include <freetype/internal/ftobjs.h>
static
void ft_prepare_glyph( FT_Glyph glyph,
FT_Face face,
FT_Bool vertical )
{
FT_Glyph_Metrics* metrics = &face->glyph->metrics;
glyph->memory = face->memory;
glyph->width = metrics->width;
glyph->height = metrics->height;
if (vertical)
{
glyph->bearingX = metrics->vertBearingX;
glyph->bearingY = metrics->vertBearingY;
glyph->advance = metrics->vertAdvance;
}
else
{
glyph->bearingX = metrics->horiBearingX;
glyph->bearingY = metrics->horiBearingY;
glyph->advance = metrics->horiAdvance;
}
}
/***********************************************************************
*
* <Function>
* FT_Get_Glyph_Bitmap
*
* <Description>
* A function used to directly return a monochrome bitmap glyph image
* from a face.
*
* <Input>
* face :: handle to source face object
* glyph_index :: glyph index in face
* load_flags :: load flags, see FT_LOAD_FLAG_XXXX constants..
* grays :: number of gray levels for anti-aliased bitmaps,
* set to 0 if you want to render a monochrome bitmap
* origin :: a pointer to the origin's position. Set to 0
* if the current transform is the identity..
*
* <Output>
* bitglyph :: pointer to the new bitmap glyph
*
* <Return>
* Error code. 0 means success.
*
* <Note>
* If the font contains glyph outlines, these will be automatically
* converted to a bitmap according to the value of "grays"
*
* If "grays" is set to 0, the result is a 1-bit monochrome bitmap
* otherwise, it is an 8-bit gray-level bitmap
*
* The number of gray levels in the result anti-aliased bitmap might
* not be "grays", depending on the current scan-converter implementation
*
* Note that it is not possible to generate 8-bit monochrome bitmaps
* with this function. Rather, use FT_Get_Glyph_Outline, then
* FT_Glyph_Render_Outline and provide your own span callbacks..
*
* When the face doesn't contain scalable outlines, this function will
* fail if the current transform is not the identity, or if the glyph
* origin's phase to the pixel grid is not 0 in both directions !!
*
***********************************************************************/
EXPORT_FUNC(FT_Error) FT_Get_Glyph_Bitmap( FT_Face face,
FT_UInt glyph_index,
FT_UInt load_flags,
FT_Int grays,
FT_Vector* origin,
FT_BitmapGlyph *abitglyph )
{
FT_Error error;
FT_Memory memory;
FT_BitmapGlyph bitglyph;
FT_Glyph glyph;
FT_Pos origin_x = 0;
FT_Pos origin_y = 0;
*abitglyph = 0;
if (origin)
{
origin_x = origin->x & 63;
origin_y = origin->y & 63;
}
/* check arguments if the face's format is not scalable */
if ( !(face->face_flags & FT_FACE_FLAG_SCALABLE) && face->transform_flags )
{
/* we can't transform bitmaps, so return an error */
error = FT_Err_Unimplemented_Feature;
goto Exit;
}
/* check that NO_SCALE and NO_RECURSE are not set */
if (load_flags & (FT_LOAD_NO_SCALE|FT_LOAD_NO_RECURSE))
{
error = FT_Err_Invalid_Argument;
goto Exit;
}
/* disable embedded bitmaps for transformed images */
if ( face->face_flags & FT_FACE_FLAG_SCALABLE && face->transform_flags )
load_flags |= FT_LOAD_NO_BITMAP;
error = FT_Load_Glyph( face, glyph_index, load_flags );
if (error) goto Exit;
/* now, handle bitmap and outline glyph images */
memory = face->memory;
switch ( face->glyph->format )
{
case ft_glyph_format_bitmap:
{
FT_Long size;
FT_Bitmap* source;
if ( ALLOC( bitglyph, sizeof(*bitglyph) ) )
goto Exit;
glyph = (FT_Glyph)bitglyph;
glyph->glyph_type = ft_glyph_type_bitmap;
ft_prepare_glyph( glyph, face, 0 );
source = &face->glyph->bitmap;
size = source->rows * source->pitch;
if (size < 0) size = -size;
bitglyph->bitmap = *source;
if ( ALLOC( bitglyph->bitmap.buffer, size ) )
goto Fail;
/* copy the content of the source glyph */
MEM_Copy( bitglyph->bitmap.buffer, source->buffer, size );
}
break;
case ft_glyph_format_outline:
{
FT_BBox cbox;
FT_Int width, height, pitch;
FT_Long size;
/* transform the outline - note that the original metrics are NOT */
/* transformed by this.. only the outline points themselves.. */
FT_Outline_Transform( &face->glyph->outline, &face->transform_matrix );
FT_Outline_Translate( &face->glyph->outline,
face->transform_delta.x + origin_x,
face->transform_delta.y + origin_y );
/* compute the size in pixels of the outline */
FT_Outline_Get_CBox( &face->glyph->outline, &cbox );
cbox.xMin &= -64;
cbox.yMin &= -64;
cbox.xMax = (cbox.xMax+63) & -64;
cbox.yMax = (cbox.yMax+63) & -64;
width = (cbox.xMax - cbox.xMin) >> 6;
height = (cbox.yMax - cbox.yMin) >> 6;
/* allocate the pixel buffer for the glyph bitmap */
if (grays) pitch = (width+3) & -4; /* some raster implementation need this */
else pitch = (width+7) >> 3;
size = pitch * height;
if ( ALLOC( bitglyph, sizeof(*bitglyph) ) )
goto Exit;
glyph = (FT_Glyph)bitglyph;
glyph->glyph_type = ft_glyph_type_bitmap;
ft_prepare_glyph( glyph, face, 0 );
if ( ALLOC( bitglyph->bitmap.buffer, size ) )
goto Fail;
bitglyph->bitmap.width = width;
bitglyph->bitmap.rows = height;
bitglyph->bitmap.pitch = pitch;
bitglyph->bitmap.pixel_mode = grays ? ft_pixel_mode_grays
: ft_pixel_mode_mono;
bitglyph->bitmap.num_grays = (short)grays;
bitglyph->left = (cbox.xMin >> 6);
bitglyph->top = (cbox.yMax >> 6);
/* render the monochrome outline into the target buffer */
FT_Outline_Translate( &face->glyph->outline, -cbox.xMin, -cbox.yMin );
error = FT_Outline_Get_Bitmap( face->driver->library,
&face->glyph->outline,
&bitglyph->bitmap );
if (error)
{
FREE( bitglyph->bitmap.buffer );
goto Fail;
}
}
break;
default:
error = FT_Err_Invalid_Glyph_Index;
goto Exit;
}
*abitglyph = bitglyph;
Exit:
return error;
Fail:
FREE( glyph );
goto Exit;
}
/***********************************************************************
*
* <Function>
* FT_Get_Glyph_Outline
*
* <Description>
* A function used to directly return a bitmap glyph image from a
* face. This is faster than calling FT_Load_Glyph+FT_Get_Outline_Bitmap..
*
* <Input>
* face :: handle to source face object
* glyph_index :: glyph index in face
* load_flags :: load flags, see FT_LOAD_FLAG_XXXX constants..
*
* <Output>
* vecglyph :: pointer to the new outline glyph
*
* <Return>
* Error code. 0 means success.
*
* <Note>
* This function will fail if the load flags FT_LOAD_NO_OUTLINE and
* FT_LOAD_NO_RECURSE are set..
*
***********************************************************************/
EXPORT_FUNC(FT_Error) FT_Get_Glyph_Outline( FT_Face face,
FT_UInt glyph_index,
FT_UInt load_flags,
FT_OutlineGlyph *vecglyph )
{
FT_Error error;
FT_Memory memory;
FT_OutlineGlyph glyph;
*vecglyph = 0;
/* check that NO_OUTLINE and NO_RECURSE are not set */
if (load_flags & (FT_LOAD_NO_OUTLINE|FT_LOAD_NO_RECURSE))
{
error = FT_Err_Invalid_Argument;
goto Exit;
}
/* disable the loading of embedded bitmaps */
load_flags |= FT_LOAD_NO_BITMAP;
error = FT_Load_Glyph( face, glyph_index, load_flags );
if (error) goto Exit;
/* check that we really loaded an outline */
if ( face->glyph->format != ft_glyph_format_outline )
{
error = FT_Err_Invalid_Glyph_Index;
goto Exit;
}
/* transform the outline - note that the original metrics are NOT */
/* transformed by this.. only the outline points themselves.. */
if ( face->transform_flags )
{
FT_Outline_Transform( &face->glyph->outline, &face->transform_matrix );
FT_Outline_Translate( &face->glyph->outline,
face->transform_delta.x,
face->transform_delta.y );
}
/* now, create a new outline glyph and copy everything there */
memory = face->memory;
if ( ALLOC( glyph, sizeof(*glyph) ) )
goto Exit;
ft_prepare_glyph( (FT_Glyph)glyph, face, 0 );
glyph->metrics.glyph_type = ft_glyph_type_outline;
error = FT_Outline_New( face->driver->library,
face->glyph->outline.n_points,
face->glyph->outline.n_contours,
&glyph->outline );
if (!error)
error = FT_Outline_Copy( &face->glyph->outline, &glyph->outline );
if (error) goto Fail;
*vecglyph = glyph;
Exit:
return error;
Fail:
FREE( glyph );
goto Exit;
}
/***********************************************************************
*
* <Function>
* FT_Set_Transform
*
* <Description>
* A function used to set the transform that is applied to glyph images
* just after they're loaded in the face's glyph slot, and before they're
* returned by either FT_Get_Glyph_Bitmap or FT_Get_Glyph_Outline
*
* <Input>
* face :: handle to source face object
* matrix :: pointer to the transform's 2x2 matrix. 0 for identity
* delta :: pointer to the transform's translation. 0 for null vector
*
* <Note>
* The transform is only applied to glyph outlines when they are found
* in a font face. It is unable to transform embedded glyph bitmaps
*
***********************************************************************/
EXPORT_FUNC(void) FT_Set_Transform( FT_Face face,
FT_Matrix* matrix,
FT_Vector* delta )
{
face->transform_flags = 0;
if (!matrix)
{
face->transform_matrix.xx = 0x10000L;
face->transform_matrix.xy = 0;
face->transform_matrix.yx = 0L;
face->transform_matrix.yy = 0x10000L;
matrix = &face->transform_matrix;
}
else
face->transform_matrix = *matrix;
/* set transform_flags bit flag 0 if delta isn't the null vector */
if ( (matrix->xy | matrix->yx) ||
matrix->xx != 0x10000L ||
matrix->yy != 0x10000L )
face->transform_flags |= 1;
if (!delta)
{
face->transform_delta.x = 0;
face->transform_delta.y = 0;
delta = &face->transform_delta;
}
else
face->transform_delta = *delta;
/* set transform_flags bit flag 1 if delta isn't the null vector */
if ( delta->x | delta->y )
face->transform_flags |= 2;
}
/***********************************************************************
*
* <Function>
* FT_Done_Glyph
*
* <Description>
* Destroys a given glyph..
*
* <Input>
* glyph :: handle to target glyph object
*
***********************************************************************/
EXPORT_FUNC(void) FT_Done_Glyph( FT_Glyph glyph )
{
if (glyph)
{
FT_Memory memory = glyph->memory;
if ( glyph->glyph_type == ft_glyph_type_bitmap )
{
FT_BitmapGlyph bit = (FT_BitmapGlyph)glyph;
FREE( bit->bitmap.buffer );
}
else if ( glyph->glyph_type == ft_glyph_type_outline )
{
FT_OutlineGlyph out = (FT_OutlineGlyph)glyph;
if (out->outline.flags & ft_outline_owner)
{
FREE( out->outline.points );
FREE( out->outline.contours );
FREE( out->outline.tags );
}
}
FREE( glyph );
}
}
/***********************************************************************
*
* <Function>
* FT_Glyph_Get_Box
*
* <Description>
* Returns the glyph image's bounding box in pixels.
*
* <Input>
* glyph :: handle to target glyph object
*
* <Output>
* box :: the glyph bounding box. Coordinates are expressed in
* _integer_ pixels, with exclusive max bounds
*
* <Note>
* Coordinates are relative to the glyph origin, using the Y-upwards
* convention..
*
* The width of the box in pixels is box.xMax-box.xMin
* The height is box.yMax - box.yMin
*
***********************************************************************/
EXPORT_FUNC(void) FT_Glyph_Get_Box( FT_Glyph glyph,
FT_BBox *box )
{
box->xMin = box->xMax = 0;
box->yMin = box->yMax = 0;
if (glyph) switch (glyph->glyph_type)
{
case ft_glyph_type_bitmap:
{
FT_BitmapGlyph bit = (FT_BitmapGlyph)glyph;
box->xMin = bit->left;
box->xMax = box->xMin + bit->bitmap.width;
box->yMax = bit->top;
box->yMin = box->yMax - bit->bitmap.rows;
}
break;
case ft_glyph_type_outline:
{
FT_OutlineGlyph out = (FT_OutlineGlyph)glyph;
FT_Outline_Get_CBox( &out->outline, box );
box->xMin >>= 6;
box->yMin >>= 6;
box->xMax = (box->xMax+63) >> 6;
box->yMax = (box->yMax+63) >> 6;
}
break;
default:
;
}
}
/***************************************************************************/
/***************************************************************************/
/**** ****/
/**** EXPERIMENTAL EMBOLDENING/OUTLINING SUPPORT ****/
/**** ****/
/***************************************************************************/
/***************************************************************************/
#if 0
/* Compute the norm of a vector */
#ifdef FT_CONFIG_OPTION_OLD_CALCS
static
FT_Pos ft_norm( FT_Vector* vec )
{
FT_Int64 t1, t2;
MUL_64( vec->x, vec->x, t1 );
MUL_64( vec->y, vec->y, t2 );
ADD_64( t1, t2, t1 );
return (FT_Pos)SQRT_64(t1);
}
#else
static
FT_Pos ft_norm( FT_Vector* vec )
{
FT_F26Dot6 u, v, d;
FT_Int shift;
FT_ULong H, L, L2, hi, lo, med;
u = vec->x; if (u < 0) u = -u;
v = vec->y; if (v < 0) v = -v;
if (u < v)
{
d = u;
u = v;
v = d;
}
/* check that we're not trying to normalise zero !! */
if (u==0) return 0;
/* compute (u*u+v*v) on 64 bits with two 32-bit registers [H:L] */
hi = (FT_ULong)u >> 16;
lo = (FT_ULong)u & 0xFFFF;
med = hi*lo;
H = hi*hi + (med >> 15);
med <<= 17;
L = lo*lo + med;
if (L < med) H++;
hi = (FT_ULong)v >> 16;
lo = (FT_ULong)v & 0xFFFF;
med = hi*lo;
H += hi*hi + (med >> 15);
med <<= 17;
L2 = lo*lo + med;
if (L2 < med) H++;
L += L2;
if (L < L2) H++;
/* if the value is smaller than 32-bits */
shift = 0;
if (H == 0)
{
while ((L & 0xC0000000) == 0)
{
L <<= 2;
shift++;
}
return (FT_Sqrt32(L) >> shift);
}
else
{
while (H)
{
L = (L >> 2) | (H << 30);
H >>= 2;
shift++;
}
return (FT_Sqrt32(L) << shift);
}
}
#endif
static
int ft_test_extrema( FT_Outline* outline,
int n )
{
FT_Vector *prev, *cur, *next;
FT_Pos product;
FT_Int first, last;
/* we need to compute the "previous" and "next" point */
/* for this extrema.. */
cur = outline->points + n;
prev = cur - 1;
next = cur + 1;
first = 0;
for ( c = 0; c < outline->n_contours; c++ )
{
last = outline->contours[c];
if ( n == first )
prev = outline->points + last;
if ( n == last )
next = outline->points + first;
first = last + 1;
}
product = FT_MulDiv( cur->x - prev->x, /* in.x */
next->y - cur->y, /* out.y */
0x40 ) -
FT_MulDiv( cur->y - prev->y, /* in.y */
next->x - cur->x, /* out.x */
0x40 );
if (product)
product = ( product > 0 ? 1 : -1 );
return product;
}
/* Compute the orientation of path filling. It differs between TrueType */
/* and Type1 formats. We could use the 'ft_outline_reverse_fill' flag, */
/* but it's better to re-compute it directly (it seems that this flag */
/* isn't correctly set for some weird composite glyphs for now).. */
/* */
/* We do this by computing bounding box points, and computing their */
/* curvature.. the function returns either 1 or -1 */
/* */
static
int ft_get_orientation( FT_Outline* outline )
{
FT_BBox box;
FT_BBox indexes;
int n, last;
indexes.xMin = -1;
indexes.yMin = -1;
indexes.xMax = -1;
indexes.yMax = -1;
box.xMin = box.yMin = 32767;
box.xMax = box.yMax = -32768;
/* is it empty ? */
if ( outline->n_contours < 1 )
return 1;
last = outline->contours[outline->n_contours-1];
for ( n = 0; n <= last; n++ )
{
FT_Pos x, y;
x = outline->points[n].x;
if ( x < box.xMin )
{
box.xMin = x;
indexes.xMin = n;
}
if ( x > box.xMax )
{
box.xMax = x;
indexes.xMax = n;
}
y = outline->points[n].y;
if ( y < box.yMin )
{
box.yMin = y;
indexes.yMin = n;
}
if ( y > box.yMax )
{
box.yMax = y;
indexes.yMax = n;
}
}
/* test orientation of the xmin */
return ft_test_extrema( outline, indexes.xMin ) ||
ft_test_extrema( outline, indexes.yMin ) ||
ft_test_extrema( outline, indexes.xMax ) ||
ft_test_extrema( outline, indexes.yMax ) ||
1; /* this is an empty glyph ?? */
}
static
FT_Error ft_embolden( FT_Face original,
FT_Outline* outline,
FT_Pos* advance )
{
FT_Vector u, v;
FT_Vector* points;
FT_Vector cur, prev, next;
FT_Pos distance;
int c, n, first, orientation;
(void)advance;
/* compute control distance */
distance = FT_MulFix( original->em_size/60,
original->size->metrics.y_scale );
orientation = ft_get_orientation( &original->glyph->outline );
points = original->glyph->outline.points;
first = 0;
for ( c = 0; c < outline->n_contours; c++ )
{
int last = outline->contours[c];
prev = points[last];
for ( n = first; n <= last; n++ )
{
FT_Pos norme, delta, d;
FT_Vector in, out;
cur = points[n];
if ( n < last ) next = points[n+1];
else next = points[first];
/* compute the in and out vectors */
in.x = cur.x - prev.x;
in.y = cur.y - prev.y;
out.x = next.x - cur.x;
out.y = next.y - cur.y;
/* compute U and V */
norme = ft_norm( &in );
u.x = orientation * FT_DivFix( in.y, norme );
u.y = orientation * - FT_DivFix( in.x, norme );
norme = ft_norm( &out );
v.x = orientation * FT_DivFix( out.y, norme );
v.y = orientation * - FT_DivFix( out.x, norme );
d = distance;
if ( (outline->flags[n] & FT_Curve_Tag_On) == 0 )
d *= 2;
/* Check discriminant for parallel vectors */
delta = FT_MulFix( u.x, v.y ) - FT_MulFix( u.y, v.x );
if ( delta > FT_BOLD_THRESHOLD || delta < - FT_BOLD_THRESHOLD )
{
/* Move point - compute A and B */
FT_Pos x, y, A, B;
A = d + FT_MulFix( cur.x, u.x ) + FT_MulFix( cur.y, u.y );
B = d + FT_MulFix( cur.x, v.x ) + FT_MulFix( cur.y, v.y );
x = FT_MulFix( A, v.y ) - FT_MulFix( B, u.y );
y = FT_MulFix( B, u.x ) - FT_MulFix( A, v.x );
outline->points[n].x = distance + FT_DivFix( x, delta );
outline->points[n].y = distance + FT_DivFix( y, delta );
}
else
{
/* Vectors are nearly parallel */
FT_Pos x, y;
x = distance + cur.x + FT_MulFix( d, u.x + v.x )/2;
y = distance + cur.y + FT_MulFix( d, u.y + v.y )/2;
outline->points[n].x = x;
outline->points[n].y = y;
}
prev = cur;
}
first = last+1;
}
if (advance)
*advance = (*advance + distance*4) & -64;
return 0;
}
#endif /* 0 - EXPERIMENTAL STUFF !! */