Open source Star Ruler 2 source code!
This commit is contained in:
@@ -0,0 +1,25 @@
|
||||
# FreeType 2 src Jamfile
|
||||
#
|
||||
# Copyright 2001, 2002 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.
|
||||
|
||||
SubDir FT2_TOP $(FT2_SRC_DIR) ;
|
||||
|
||||
# The file <freetype/internal/internal.h> is used to define macros that are
|
||||
# later used in #include statements. It needs to be parsed in order to
|
||||
# record these definitions.
|
||||
#
|
||||
HDRMACRO [ FT2_SubDir $(FT2_INCLUDE_DIR) internal internal.h ] ;
|
||||
|
||||
for xx in $(FT2_COMPONENTS)
|
||||
{
|
||||
SubInclude FT2_TOP $(FT2_SRC_DIR) $(xx) ;
|
||||
}
|
||||
|
||||
# end of src Jamfile
|
||||
@@ -0,0 +1,39 @@
|
||||
# FreeType 2 src/autofit Jamfile
|
||||
#
|
||||
# Copyright 2003, 2004, 2005, 2006, 2007, 2009 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.
|
||||
|
||||
SubDir FT2_TOP src autofit ;
|
||||
|
||||
{
|
||||
local _sources ;
|
||||
|
||||
# define FT2_AUTOFIT2 to enable experimental latin hinter replacement
|
||||
if $(FT2_AUTOFIT2)
|
||||
{
|
||||
DEFINES += FT_OPTION_AUTOFIT2 ;
|
||||
}
|
||||
if $(FT2_MULTI)
|
||||
{
|
||||
_sources = afangles afglobal afhints aflatin afcjk afindic afloader afmodule afdummy afwarp afpic ;
|
||||
|
||||
if $(FT2_AUTOFIT2)
|
||||
{
|
||||
_sources += aflatin2 ;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_sources = autofit ;
|
||||
}
|
||||
|
||||
Library $(FT2_LIB) : $(_sources).c ;
|
||||
}
|
||||
|
||||
# end of src/autofit Jamfile
|
||||
@@ -0,0 +1,292 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afangles.c */
|
||||
/* */
|
||||
/* Routines used to compute vector angles with limited accuracy */
|
||||
/* and very high speed. It also contains sorting routines (body). */
|
||||
/* */
|
||||
/* Copyright 2003-2006, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include "aftypes.h"
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
FT_LOCAL_DEF( FT_Int )
|
||||
af_corner_is_flat( FT_Pos x_in,
|
||||
FT_Pos y_in,
|
||||
FT_Pos x_out,
|
||||
FT_Pos y_out )
|
||||
{
|
||||
FT_Pos ax = x_in;
|
||||
FT_Pos ay = y_in;
|
||||
|
||||
FT_Pos d_in, d_out, d_corner;
|
||||
|
||||
|
||||
if ( ax < 0 )
|
||||
ax = -ax;
|
||||
if ( ay < 0 )
|
||||
ay = -ay;
|
||||
d_in = ax + ay;
|
||||
|
||||
ax = x_out;
|
||||
if ( ax < 0 )
|
||||
ax = -ax;
|
||||
ay = y_out;
|
||||
if ( ay < 0 )
|
||||
ay = -ay;
|
||||
d_out = ax + ay;
|
||||
|
||||
ax = x_out + x_in;
|
||||
if ( ax < 0 )
|
||||
ax = -ax;
|
||||
ay = y_out + y_in;
|
||||
if ( ay < 0 )
|
||||
ay = -ay;
|
||||
d_corner = ax + ay;
|
||||
|
||||
return ( d_in + d_out - d_corner ) < ( d_corner >> 4 );
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Int )
|
||||
af_corner_orientation( FT_Pos x_in,
|
||||
FT_Pos y_in,
|
||||
FT_Pos x_out,
|
||||
FT_Pos y_out )
|
||||
{
|
||||
FT_Pos delta;
|
||||
|
||||
|
||||
delta = x_in * y_out - y_in * x_out;
|
||||
|
||||
if ( delta == 0 )
|
||||
return 0;
|
||||
else
|
||||
return 1 - 2 * ( delta < 0 );
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
/*
|
||||
* We are not using `af_angle_atan' anymore, but we keep the source
|
||||
* code below just in case...
|
||||
*/
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
|
||||
/*
|
||||
* The trick here is to realize that we don't need a very accurate angle
|
||||
* approximation. We are going to use the result of `af_angle_atan' to
|
||||
* only compare the sign of angle differences, or check whether its
|
||||
* magnitude is very small.
|
||||
*
|
||||
* The approximation
|
||||
*
|
||||
* dy * PI / (|dx|+|dy|)
|
||||
*
|
||||
* should be enough, and much faster to compute.
|
||||
*/
|
||||
FT_LOCAL_DEF( AF_Angle )
|
||||
af_angle_atan( FT_Fixed dx,
|
||||
FT_Fixed dy )
|
||||
{
|
||||
AF_Angle angle;
|
||||
FT_Fixed ax = dx;
|
||||
FT_Fixed ay = dy;
|
||||
|
||||
|
||||
if ( ax < 0 )
|
||||
ax = -ax;
|
||||
if ( ay < 0 )
|
||||
ay = -ay;
|
||||
|
||||
ax += ay;
|
||||
|
||||
if ( ax == 0 )
|
||||
angle = 0;
|
||||
else
|
||||
{
|
||||
angle = ( AF_ANGLE_PI2 * dy ) / ( ax + ay );
|
||||
if ( dx < 0 )
|
||||
{
|
||||
if ( angle >= 0 )
|
||||
angle = AF_ANGLE_PI - angle;
|
||||
else
|
||||
angle = -AF_ANGLE_PI - angle;
|
||||
}
|
||||
}
|
||||
|
||||
return angle;
|
||||
}
|
||||
|
||||
|
||||
#elif 0
|
||||
|
||||
|
||||
/* the following table has been automatically generated with */
|
||||
/* the `mather.py' Python script */
|
||||
|
||||
#define AF_ATAN_BITS 8
|
||||
|
||||
static const FT_Byte af_arctan[1L << AF_ATAN_BITS] =
|
||||
{
|
||||
0, 0, 1, 1, 1, 2, 2, 2,
|
||||
3, 3, 3, 3, 4, 4, 4, 5,
|
||||
5, 5, 6, 6, 6, 7, 7, 7,
|
||||
8, 8, 8, 9, 9, 9, 10, 10,
|
||||
10, 10, 11, 11, 11, 12, 12, 12,
|
||||
13, 13, 13, 14, 14, 14, 14, 15,
|
||||
15, 15, 16, 16, 16, 17, 17, 17,
|
||||
18, 18, 18, 18, 19, 19, 19, 20,
|
||||
20, 20, 21, 21, 21, 21, 22, 22,
|
||||
22, 23, 23, 23, 24, 24, 24, 24,
|
||||
25, 25, 25, 26, 26, 26, 26, 27,
|
||||
27, 27, 28, 28, 28, 28, 29, 29,
|
||||
29, 30, 30, 30, 30, 31, 31, 31,
|
||||
31, 32, 32, 32, 33, 33, 33, 33,
|
||||
34, 34, 34, 34, 35, 35, 35, 35,
|
||||
36, 36, 36, 36, 37, 37, 37, 38,
|
||||
38, 38, 38, 39, 39, 39, 39, 40,
|
||||
40, 40, 40, 41, 41, 41, 41, 42,
|
||||
42, 42, 42, 42, 43, 43, 43, 43,
|
||||
44, 44, 44, 44, 45, 45, 45, 45,
|
||||
46, 46, 46, 46, 46, 47, 47, 47,
|
||||
47, 48, 48, 48, 48, 48, 49, 49,
|
||||
49, 49, 50, 50, 50, 50, 50, 51,
|
||||
51, 51, 51, 51, 52, 52, 52, 52,
|
||||
52, 53, 53, 53, 53, 53, 54, 54,
|
||||
54, 54, 54, 55, 55, 55, 55, 55,
|
||||
56, 56, 56, 56, 56, 57, 57, 57,
|
||||
57, 57, 57, 58, 58, 58, 58, 58,
|
||||
59, 59, 59, 59, 59, 59, 60, 60,
|
||||
60, 60, 60, 61, 61, 61, 61, 61,
|
||||
61, 62, 62, 62, 62, 62, 62, 63,
|
||||
63, 63, 63, 63, 63, 64, 64, 64
|
||||
};
|
||||
|
||||
|
||||
FT_LOCAL_DEF( AF_Angle )
|
||||
af_angle_atan( FT_Fixed dx,
|
||||
FT_Fixed dy )
|
||||
{
|
||||
AF_Angle angle;
|
||||
|
||||
|
||||
/* check trivial cases */
|
||||
if ( dy == 0 )
|
||||
{
|
||||
angle = 0;
|
||||
if ( dx < 0 )
|
||||
angle = AF_ANGLE_PI;
|
||||
return angle;
|
||||
}
|
||||
else if ( dx == 0 )
|
||||
{
|
||||
angle = AF_ANGLE_PI2;
|
||||
if ( dy < 0 )
|
||||
angle = -AF_ANGLE_PI2;
|
||||
return angle;
|
||||
}
|
||||
|
||||
angle = 0;
|
||||
if ( dx < 0 )
|
||||
{
|
||||
dx = -dx;
|
||||
dy = -dy;
|
||||
angle = AF_ANGLE_PI;
|
||||
}
|
||||
|
||||
if ( dy < 0 )
|
||||
{
|
||||
FT_Pos tmp;
|
||||
|
||||
|
||||
tmp = dx;
|
||||
dx = -dy;
|
||||
dy = tmp;
|
||||
angle -= AF_ANGLE_PI2;
|
||||
}
|
||||
|
||||
if ( dx == 0 && dy == 0 )
|
||||
return 0;
|
||||
|
||||
if ( dx == dy )
|
||||
angle += AF_ANGLE_PI4;
|
||||
else if ( dx > dy )
|
||||
angle += af_arctan[FT_DivFix( dy, dx ) >> ( 16 - AF_ATAN_BITS )];
|
||||
else
|
||||
angle += AF_ANGLE_PI2 -
|
||||
af_arctan[FT_DivFix( dx, dy ) >> ( 16 - AF_ATAN_BITS )];
|
||||
|
||||
if ( angle > AF_ANGLE_PI )
|
||||
angle -= AF_ANGLE_2PI;
|
||||
|
||||
return angle;
|
||||
}
|
||||
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
af_sort_pos( FT_UInt count,
|
||||
FT_Pos* table )
|
||||
{
|
||||
FT_UInt i, j;
|
||||
FT_Pos swap;
|
||||
|
||||
|
||||
for ( i = 1; i < count; i++ )
|
||||
{
|
||||
for ( j = i; j > 0; j-- )
|
||||
{
|
||||
if ( table[j] > table[j - 1] )
|
||||
break;
|
||||
|
||||
swap = table[j];
|
||||
table[j] = table[j - 1];
|
||||
table[j - 1] = swap;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
af_sort_widths( FT_UInt count,
|
||||
AF_Width table )
|
||||
{
|
||||
FT_UInt i, j;
|
||||
AF_WidthRec swap;
|
||||
|
||||
|
||||
for ( i = 1; i < count; i++ )
|
||||
{
|
||||
for ( j = i; j > 0; j-- )
|
||||
{
|
||||
if ( table[j].org > table[j - 1].org )
|
||||
break;
|
||||
|
||||
swap = table[j];
|
||||
table[j] = table[j - 1];
|
||||
table[j - 1] = swap;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,7 @@
|
||||
/*
|
||||
* afangles.h
|
||||
*
|
||||
* This is a dummy file, used to please the build system. It is never
|
||||
* included by the auto-fitter sources.
|
||||
*
|
||||
*/
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,141 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afcjk.h */
|
||||
/* */
|
||||
/* Auto-fitter hinting routines for CJK script (specification). */
|
||||
/* */
|
||||
/* Copyright 2006, 2007, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFCJK_H__
|
||||
#define __AFCJK_H__
|
||||
|
||||
#include "afhints.h"
|
||||
#include "aflatin.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/* the CJK-specific script class */
|
||||
|
||||
AF_DECLARE_SCRIPT_CLASS(af_cjk_script_class)
|
||||
|
||||
/* CJK (global) metrics management */
|
||||
|
||||
/*
|
||||
* CJK glyphs tend to fill the square. So we have both vertical and
|
||||
* horizontal blue zones. But some glyphs have flat bounding strokes that
|
||||
* leave some space between neighbour glyphs.
|
||||
*/
|
||||
enum
|
||||
{
|
||||
AF_CJK_BLUE_TOP,
|
||||
AF_CJK_BLUE_BOTTOM,
|
||||
AF_CJK_BLUE_LEFT,
|
||||
AF_CJK_BLUE_RIGHT,
|
||||
|
||||
AF_CJK_BLUE_MAX
|
||||
};
|
||||
|
||||
|
||||
#define AF_CJK_MAX_WIDTHS 16
|
||||
#define AF_CJK_MAX_BLUES AF_CJK_BLUE_MAX
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
AF_CJK_BLUE_ACTIVE = 1 << 0,
|
||||
AF_CJK_BLUE_IS_TOP = 1 << 1,
|
||||
AF_CJK_BLUE_IS_RIGHT = 1 << 2,
|
||||
AF_CJK_BLUE_ADJUSTMENT = 1 << 3, /* used for scale adjustment */
|
||||
/* optimization */
|
||||
AF_CJK_BLUE_FLAG_MAX
|
||||
};
|
||||
|
||||
|
||||
typedef struct AF_CJKBlueRec_
|
||||
{
|
||||
AF_WidthRec ref;
|
||||
AF_WidthRec shoot; /* undershoot */
|
||||
FT_UInt flags;
|
||||
|
||||
} AF_CJKBlueRec, *AF_CJKBlue;
|
||||
|
||||
|
||||
typedef struct AF_CJKAxisRec_
|
||||
{
|
||||
FT_Fixed scale;
|
||||
FT_Pos delta;
|
||||
|
||||
FT_UInt width_count;
|
||||
AF_WidthRec widths[AF_CJK_MAX_WIDTHS];
|
||||
FT_Pos edge_distance_threshold;
|
||||
FT_Pos standard_width;
|
||||
FT_Bool extra_light;
|
||||
|
||||
/* used for horizontal metrics too for CJK */
|
||||
FT_Bool control_overshoot;
|
||||
FT_UInt blue_count;
|
||||
AF_CJKBlueRec blues[AF_CJK_BLUE_MAX];
|
||||
|
||||
FT_Fixed org_scale;
|
||||
FT_Pos org_delta;
|
||||
|
||||
} AF_CJKAxisRec, *AF_CJKAxis;
|
||||
|
||||
|
||||
typedef struct AF_CJKMetricsRec_
|
||||
{
|
||||
AF_ScriptMetricsRec root;
|
||||
FT_UInt units_per_em;
|
||||
AF_CJKAxisRec axis[AF_DIMENSION_MAX];
|
||||
|
||||
} AF_CJKMetricsRec, *AF_CJKMetrics;
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_cjk_metrics_init( AF_CJKMetrics metrics,
|
||||
FT_Face face );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_cjk_metrics_scale( AF_CJKMetrics metrics,
|
||||
AF_Scaler scaler );
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_cjk_hints_init( AF_GlyphHints hints,
|
||||
AF_CJKMetrics metrics );
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_cjk_hints_apply( AF_GlyphHints hints,
|
||||
FT_Outline* outline,
|
||||
AF_CJKMetrics metrics );
|
||||
|
||||
/* Shared. called from afindic.c */
|
||||
FT_LOCAL( void )
|
||||
af_cjk_metrics_check_digits( AF_CJKMetrics metrics,
|
||||
FT_Face face );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_cjk_metrics_init_widths( AF_CJKMetrics metrics,
|
||||
FT_Face face,
|
||||
FT_ULong charcode );
|
||||
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFCJK_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,61 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afdummy.c */
|
||||
/* */
|
||||
/* Auto-fitter dummy routines to be used if no hinting should be */
|
||||
/* performed (body). */
|
||||
/* */
|
||||
/* Copyright 2003-2005, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include "afdummy.h"
|
||||
#include "afhints.h"
|
||||
#include "aferrors.h"
|
||||
|
||||
|
||||
static FT_Error
|
||||
af_dummy_hints_init( AF_GlyphHints hints,
|
||||
AF_ScriptMetrics metrics )
|
||||
{
|
||||
af_glyph_hints_rescale( hints,
|
||||
metrics );
|
||||
return AF_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
af_dummy_hints_apply( AF_GlyphHints hints,
|
||||
FT_Outline* outline )
|
||||
{
|
||||
FT_UNUSED( hints );
|
||||
FT_UNUSED( outline );
|
||||
|
||||
return AF_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
AF_DEFINE_SCRIPT_CLASS( af_dummy_script_class,
|
||||
AF_SCRIPT_NONE,
|
||||
NULL,
|
||||
|
||||
sizeof( AF_ScriptMetricsRec ),
|
||||
|
||||
(AF_Script_InitMetricsFunc) NULL,
|
||||
(AF_Script_ScaleMetricsFunc)NULL,
|
||||
(AF_Script_DoneMetricsFunc) NULL,
|
||||
|
||||
(AF_Script_InitHintsFunc) af_dummy_hints_init,
|
||||
(AF_Script_ApplyHintsFunc) af_dummy_hints_apply
|
||||
)
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,42 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afdummy.h */
|
||||
/* */
|
||||
/* Auto-fitter dummy routines to be used if no hinting should be */
|
||||
/* performed (specification). */
|
||||
/* */
|
||||
/* Copyright 2003-2005, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFDUMMY_H__
|
||||
#define __AFDUMMY_H__
|
||||
|
||||
#include "aftypes.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
/* A dummy script metrics class used when no hinting should
|
||||
* be performed. This is the default for non-latin glyphs!
|
||||
*/
|
||||
|
||||
AF_DECLARE_SCRIPT_CLASS( af_dummy_script_class )
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
|
||||
#endif /* __AFDUMMY_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,40 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* aferrors.h */
|
||||
/* */
|
||||
/* Autofitter error codes (specification only). */
|
||||
/* */
|
||||
/* Copyright 2005 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 is used to define the Autofitter error enumeration */
|
||||
/* constants. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef __AFERRORS_H__
|
||||
#define __AFERRORS_H__
|
||||
|
||||
#include FT_MODULE_ERRORS_H
|
||||
|
||||
#undef __FTERRORS_H__
|
||||
|
||||
#define FT_ERR_PREFIX AF_Err_
|
||||
#define FT_ERR_BASE FT_Mod_Err_Autofit
|
||||
|
||||
#include FT_ERRORS_H
|
||||
|
||||
#endif /* __AFERRORS_H__ */
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,319 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afglobal.c */
|
||||
/* */
|
||||
/* Auto-fitter routines to compute global hinting values (body). */
|
||||
/* */
|
||||
/* Copyright 2003-2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include "afglobal.h"
|
||||
#include "afdummy.h"
|
||||
#include "aflatin.h"
|
||||
#include "afcjk.h"
|
||||
#include "afindic.h"
|
||||
#include "afpic.h"
|
||||
|
||||
#include "aferrors.h"
|
||||
|
||||
#ifdef FT_OPTION_AUTOFIT2
|
||||
#include "aflatin2.h"
|
||||
#endif
|
||||
|
||||
#ifndef FT_CONFIG_OPTION_PIC
|
||||
|
||||
/* when updating this table, don't forget to update */
|
||||
/* AF_SCRIPT_CLASSES_COUNT and autofit_module_class_pic_init */
|
||||
|
||||
/* populate this list when you add new scripts */
|
||||
static AF_ScriptClass const af_script_classes[] =
|
||||
{
|
||||
&af_dummy_script_class,
|
||||
#ifdef FT_OPTION_AUTOFIT2
|
||||
&af_latin2_script_class,
|
||||
#endif
|
||||
&af_latin_script_class,
|
||||
&af_cjk_script_class,
|
||||
&af_indic_script_class,
|
||||
NULL /* do not remove */
|
||||
};
|
||||
|
||||
#endif /* !FT_CONFIG_OPTION_PIC */
|
||||
|
||||
/* index of default script in `af_script_classes' */
|
||||
#define AF_SCRIPT_LIST_DEFAULT 2
|
||||
/* a bit mask indicating an uncovered glyph */
|
||||
#define AF_SCRIPT_LIST_NONE 0x7F
|
||||
/* if this flag is set, we have an ASCII digit */
|
||||
#define AF_DIGIT 0x80
|
||||
|
||||
|
||||
/*
|
||||
* Note that glyph_scripts[] is used to map each glyph into
|
||||
* an index into the `af_script_classes' array.
|
||||
*
|
||||
*/
|
||||
typedef struct AF_FaceGlobalsRec_
|
||||
{
|
||||
FT_Face face;
|
||||
FT_Long glyph_count; /* same as face->num_glyphs */
|
||||
FT_Byte* glyph_scripts;
|
||||
|
||||
AF_ScriptMetrics metrics[AF_SCRIPT_MAX];
|
||||
|
||||
} AF_FaceGlobalsRec;
|
||||
|
||||
|
||||
/* Compute the script index of each glyph within a given face. */
|
||||
|
||||
static FT_Error
|
||||
af_face_globals_compute_script_coverage( AF_FaceGlobals globals )
|
||||
{
|
||||
FT_Error error = AF_Err_Ok;
|
||||
FT_Face face = globals->face;
|
||||
FT_CharMap old_charmap = face->charmap;
|
||||
FT_Byte* gscripts = globals->glyph_scripts;
|
||||
FT_UInt ss, i;
|
||||
|
||||
|
||||
/* the value AF_SCRIPT_LIST_NONE means `uncovered glyph' */
|
||||
FT_MEM_SET( globals->glyph_scripts,
|
||||
AF_SCRIPT_LIST_NONE,
|
||||
globals->glyph_count );
|
||||
|
||||
error = FT_Select_Charmap( face, FT_ENCODING_UNICODE );
|
||||
if ( error )
|
||||
{
|
||||
/*
|
||||
* Ignore this error; we simply use the default script.
|
||||
* XXX: Shouldn't we rather disable hinting?
|
||||
*/
|
||||
error = AF_Err_Ok;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* scan each script in a Unicode charmap */
|
||||
for ( ss = 0; AF_SCRIPT_CLASSES_GET[ss]; ss++ )
|
||||
{
|
||||
AF_ScriptClass clazz = AF_SCRIPT_CLASSES_GET[ss];
|
||||
AF_Script_UniRange range;
|
||||
|
||||
|
||||
if ( clazz->script_uni_ranges == NULL )
|
||||
continue;
|
||||
|
||||
/*
|
||||
* Scan all unicode points in the range and set the corresponding
|
||||
* glyph script index.
|
||||
*/
|
||||
for ( range = clazz->script_uni_ranges; range->first != 0; range++ )
|
||||
{
|
||||
FT_ULong charcode = range->first;
|
||||
FT_UInt gindex;
|
||||
|
||||
|
||||
gindex = FT_Get_Char_Index( face, charcode );
|
||||
|
||||
if ( gindex != 0 &&
|
||||
gindex < (FT_ULong)globals->glyph_count &&
|
||||
gscripts[gindex] == AF_SCRIPT_LIST_NONE )
|
||||
gscripts[gindex] = (FT_Byte)ss;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
charcode = FT_Get_Next_Char( face, charcode, &gindex );
|
||||
|
||||
if ( gindex == 0 || charcode > range->last )
|
||||
break;
|
||||
|
||||
if ( gindex < (FT_ULong)globals->glyph_count &&
|
||||
gscripts[gindex] == AF_SCRIPT_LIST_NONE )
|
||||
gscripts[gindex] = (FT_Byte)ss;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* mark ASCII digits */
|
||||
for ( i = 0x30; i <= 0x39; i++ )
|
||||
{
|
||||
FT_UInt gindex = FT_Get_Char_Index( face, i );
|
||||
|
||||
|
||||
if ( gindex != 0 && gindex < (FT_ULong)globals->glyph_count )
|
||||
gscripts[gindex] |= AF_DIGIT;
|
||||
}
|
||||
|
||||
Exit:
|
||||
/*
|
||||
* By default, all uncovered glyphs are set to the latin script.
|
||||
* XXX: Shouldn't we disable hinting or do something similar?
|
||||
*/
|
||||
{
|
||||
FT_Long nn;
|
||||
|
||||
|
||||
for ( nn = 0; nn < globals->glyph_count; nn++ )
|
||||
{
|
||||
if ( ( gscripts[nn] & ~AF_DIGIT ) == AF_SCRIPT_LIST_NONE )
|
||||
{
|
||||
gscripts[nn] &= ~AF_SCRIPT_LIST_NONE;
|
||||
gscripts[nn] |= AF_SCRIPT_LIST_DEFAULT;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
FT_Set_Charmap( face, old_charmap );
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
af_face_globals_new( FT_Face face,
|
||||
AF_FaceGlobals *aglobals )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
AF_FaceGlobals globals = NULL;
|
||||
|
||||
|
||||
memory = face->memory;
|
||||
|
||||
if ( !FT_ALLOC( globals, sizeof ( *globals ) +
|
||||
face->num_glyphs * sizeof ( FT_Byte ) ) )
|
||||
{
|
||||
globals->face = face;
|
||||
globals->glyph_count = face->num_glyphs;
|
||||
globals->glyph_scripts = (FT_Byte*)( globals + 1 );
|
||||
|
||||
error = af_face_globals_compute_script_coverage( globals );
|
||||
if ( error )
|
||||
{
|
||||
af_face_globals_free( globals );
|
||||
globals = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
*aglobals = globals;
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
af_face_globals_free( AF_FaceGlobals globals )
|
||||
{
|
||||
if ( globals )
|
||||
{
|
||||
FT_Memory memory = globals->face->memory;
|
||||
FT_UInt nn;
|
||||
|
||||
|
||||
for ( nn = 0; nn < AF_SCRIPT_MAX; nn++ )
|
||||
{
|
||||
if ( globals->metrics[nn] )
|
||||
{
|
||||
AF_ScriptClass clazz = AF_SCRIPT_CLASSES_GET[nn];
|
||||
|
||||
|
||||
FT_ASSERT( globals->metrics[nn]->clazz == clazz );
|
||||
|
||||
if ( clazz->script_metrics_done )
|
||||
clazz->script_metrics_done( globals->metrics[nn] );
|
||||
|
||||
FT_FREE( globals->metrics[nn] );
|
||||
}
|
||||
}
|
||||
|
||||
globals->glyph_count = 0;
|
||||
globals->glyph_scripts = NULL; /* no need to free this one! */
|
||||
globals->face = NULL;
|
||||
|
||||
FT_FREE( globals );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
af_face_globals_get_metrics( AF_FaceGlobals globals,
|
||||
FT_UInt gindex,
|
||||
FT_UInt options,
|
||||
AF_ScriptMetrics *ametrics )
|
||||
{
|
||||
AF_ScriptMetrics metrics = NULL;
|
||||
FT_UInt gidx;
|
||||
AF_ScriptClass clazz;
|
||||
FT_UInt script = options & 15;
|
||||
const FT_Offset script_max = sizeof ( AF_SCRIPT_CLASSES_GET ) /
|
||||
sizeof ( AF_SCRIPT_CLASSES_GET[0] );
|
||||
FT_Error error = AF_Err_Ok;
|
||||
|
||||
|
||||
if ( gindex >= (FT_ULong)globals->glyph_count )
|
||||
{
|
||||
error = AF_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
gidx = script;
|
||||
if ( gidx == 0 || gidx + 1 >= script_max )
|
||||
gidx = globals->glyph_scripts[gindex] & AF_SCRIPT_LIST_NONE;
|
||||
|
||||
clazz = AF_SCRIPT_CLASSES_GET[gidx];
|
||||
if ( script == 0 )
|
||||
script = clazz->script;
|
||||
|
||||
metrics = globals->metrics[clazz->script];
|
||||
if ( metrics == NULL )
|
||||
{
|
||||
/* create the global metrics object when needed */
|
||||
FT_Memory memory = globals->face->memory;
|
||||
|
||||
|
||||
if ( FT_ALLOC( metrics, clazz->script_metrics_size ) )
|
||||
goto Exit;
|
||||
|
||||
metrics->clazz = clazz;
|
||||
|
||||
if ( clazz->script_metrics_init )
|
||||
{
|
||||
error = clazz->script_metrics_init( metrics, globals->face );
|
||||
if ( error )
|
||||
{
|
||||
if ( clazz->script_metrics_done )
|
||||
clazz->script_metrics_done( metrics );
|
||||
|
||||
FT_FREE( metrics );
|
||||
goto Exit;
|
||||
}
|
||||
}
|
||||
|
||||
globals->metrics[clazz->script] = metrics;
|
||||
}
|
||||
|
||||
Exit:
|
||||
*ametrics = metrics;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Bool )
|
||||
af_face_globals_is_digit( AF_FaceGlobals globals,
|
||||
FT_UInt gindex )
|
||||
{
|
||||
if ( gindex < (FT_ULong)globals->glyph_count )
|
||||
return (FT_Bool)( globals->glyph_scripts[gindex] & AF_DIGIT );
|
||||
|
||||
return (FT_Bool)0;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,71 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afglobal.h */
|
||||
/* */
|
||||
/* Auto-fitter routines to compute global hinting values */
|
||||
/* (specification). */
|
||||
/* */
|
||||
/* Copyright 2003-2005, 2007, 2009, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFGLOBAL_H__
|
||||
#define __AFGLOBAL_H__
|
||||
|
||||
|
||||
#include "aftypes.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/************************************************************************/
|
||||
/************************************************************************/
|
||||
/***** *****/
|
||||
/***** F A C E G L O B A L S *****/
|
||||
/***** *****/
|
||||
/************************************************************************/
|
||||
/************************************************************************/
|
||||
|
||||
|
||||
/*
|
||||
* model the global hints data for a given face, decomposed into
|
||||
* script-specific items
|
||||
*/
|
||||
typedef struct AF_FaceGlobalsRec_* AF_FaceGlobals;
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_face_globals_new( FT_Face face,
|
||||
AF_FaceGlobals *aglobals );
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_face_globals_get_metrics( AF_FaceGlobals globals,
|
||||
FT_UInt gindex,
|
||||
FT_UInt options,
|
||||
AF_ScriptMetrics *ametrics );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_face_globals_free( AF_FaceGlobals globals );
|
||||
|
||||
FT_LOCAL_DEF( FT_Bool )
|
||||
af_face_globals_is_digit( AF_FaceGlobals globals,
|
||||
FT_UInt gindex );
|
||||
|
||||
/* */
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFGLOBAL_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,467 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afhints.h */
|
||||
/* */
|
||||
/* Auto-fitter hinting routines (specification). */
|
||||
/* */
|
||||
/* Copyright 2003-2008, 2010-2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFHINTS_H__
|
||||
#define __AFHINTS_H__
|
||||
|
||||
#include "aftypes.h"
|
||||
|
||||
#define xxAF_SORT_SEGMENTS
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
/*
|
||||
* The definition of outline glyph hints. These are shared by all
|
||||
* script analysis routines (until now).
|
||||
*/
|
||||
|
||||
typedef enum AF_Dimension_
|
||||
{
|
||||
AF_DIMENSION_HORZ = 0, /* x coordinates, */
|
||||
/* i.e., vertical segments & edges */
|
||||
AF_DIMENSION_VERT = 1, /* y coordinates, */
|
||||
/* i.e., horizontal segments & edges */
|
||||
|
||||
AF_DIMENSION_MAX /* do not remove */
|
||||
|
||||
} AF_Dimension;
|
||||
|
||||
|
||||
/* hint directions -- the values are computed so that two vectors are */
|
||||
/* in opposite directions iff `dir1 + dir2 == 0' */
|
||||
typedef enum AF_Direction_
|
||||
{
|
||||
AF_DIR_NONE = 4,
|
||||
AF_DIR_RIGHT = 1,
|
||||
AF_DIR_LEFT = -1,
|
||||
AF_DIR_UP = 2,
|
||||
AF_DIR_DOWN = -2
|
||||
|
||||
} AF_Direction;
|
||||
|
||||
|
||||
/*
|
||||
* The following explanations are mostly taken from the article
|
||||
*
|
||||
* Real-Time Grid Fitting of Typographic Outlines
|
||||
*
|
||||
* by David Turner and Werner Lemberg
|
||||
*
|
||||
* http://www.tug.org/TUGboat/Articles/tb24-3/lemberg.pdf
|
||||
*
|
||||
*
|
||||
* Segments
|
||||
*
|
||||
* `af_{cjk,latin,...}_hints_compute_segments' are the functions to
|
||||
* find segments in an outline. A segment is a series of consecutive
|
||||
* points that are approximately aligned along a coordinate axis. The
|
||||
* analysis to do so is specific to a script.
|
||||
*
|
||||
* A segment must have at least two points, except in the case of
|
||||
* `fake' segments that are generated to hint metrics appropriately,
|
||||
* and which consist of a single point.
|
||||
*
|
||||
*
|
||||
* Edges
|
||||
*
|
||||
* As soon as segments are defined, the auto-hinter groups them into
|
||||
* edges. An edge corresponds to a single position on the main
|
||||
* dimension that collects one or more segments (allowing for a small
|
||||
* threshold).
|
||||
*
|
||||
* The auto-hinter first tries to grid fit edges, then to align
|
||||
* segments on the edges unless it detects that they form a serif.
|
||||
*
|
||||
* `af_{cjk,latin,...}_hints_compute_edges' are the functions to find
|
||||
* edges; they are specific to a script.
|
||||
*
|
||||
*
|
||||
* A H
|
||||
* | |
|
||||
* | |
|
||||
* | |
|
||||
* | |
|
||||
* C | | F
|
||||
* +------<-----+ +-----<------+
|
||||
* | B G |
|
||||
* | |
|
||||
* | |
|
||||
* +--------------->------------------+
|
||||
* D E
|
||||
*
|
||||
*
|
||||
* Stems
|
||||
*
|
||||
* Segments need to be `linked' to other ones in order to detect stems.
|
||||
* A stem is made of two segments that face each other in opposite
|
||||
* directions and that are sufficiently close to each other. Using
|
||||
* vocabulary from the TrueType specification, stem segments form a
|
||||
* `black distance'.
|
||||
*
|
||||
* In the above ASCII drawing, the horizontal segments are BC, DE, and
|
||||
* FG; the vertical segments are AB, CD, EF, and GH.
|
||||
*
|
||||
* Each segment has at most one `best' candidate to form a black
|
||||
* distance, or no candidate at all. Notice that two distinct segments
|
||||
* can have the same candidate, which frequently means a serif.
|
||||
*
|
||||
* A stem is recognized by the following condition:
|
||||
*
|
||||
* best segment_1 = segment_2 && best segment_2 = segment_1
|
||||
*
|
||||
* The best candidate is stored in field `link' in structure
|
||||
* `AF_Segment'.
|
||||
*
|
||||
* Stems are detected by `af_{cjk,latin,...}_hint_edges'.
|
||||
*
|
||||
* In the above ASCII drawing, the best candidate for both AB and CD is
|
||||
* GH, while the best candidate for GH is AB. Similarly, the best
|
||||
* candidate for EF and GH is AB, while the best candidate for AB is
|
||||
* GH.
|
||||
*
|
||||
*
|
||||
* Serifs
|
||||
*
|
||||
* On the opposite, a serif has
|
||||
*
|
||||
* best segment_1 = segment_2 && best segment_2 != segment_1
|
||||
*
|
||||
* where segment_1 corresponds to the serif segment (CD and EF in the
|
||||
* above ASCII drawing).
|
||||
*
|
||||
* The best candidate is stored in field `serif' in structure
|
||||
* `AF_Segment' (and `link' is set to NULL).
|
||||
*
|
||||
* Serifs are detected by `af_{cjk,latin,...}_hint_edges'.
|
||||
*
|
||||
*
|
||||
* Touched points
|
||||
*
|
||||
* A point is called `touched' if it has been processed somehow by the
|
||||
* auto-hinter. It basically means that it shouldn't be moved again
|
||||
* (or moved only under certain constraints to preserve the already
|
||||
* applied processing).
|
||||
*
|
||||
*
|
||||
* Flat and round segments
|
||||
*
|
||||
* Segments are `round' or `flat', depending on the series of points
|
||||
* that define them. A segment is round if the next and previous point
|
||||
* of an extremum (which can be either a single point or sequence of
|
||||
* points) are both conic or cubic control points. Otherwise, a
|
||||
* segment with an extremum is flat.
|
||||
*
|
||||
*
|
||||
* Strong Points
|
||||
*
|
||||
* Experience has shown that points which are not part of an edge need
|
||||
* to be interpolated linearly between their two closest edges, even if
|
||||
* these are not part of the contour of those particular points.
|
||||
* Typical candidates for this are
|
||||
*
|
||||
* - angle points (i.e., points where the `in' and `out' direction
|
||||
* differ greatly)
|
||||
*
|
||||
* - inflection points (i.e., where the `in' and `out' angles are the
|
||||
* same, but the curvature changes sign)
|
||||
*
|
||||
* `af_glyph_hints_align_strong_points' is the function which takes
|
||||
* care of such situations; it is equivalent to the TrueType `IP'
|
||||
* hinting instruction.
|
||||
*
|
||||
*
|
||||
* Weak Points
|
||||
*
|
||||
* Other points in the outline must be interpolated using the
|
||||
* coordinates of their previous and next unfitted contour neighbours.
|
||||
* These are called `weak points' and are touched by the function
|
||||
* `af_glyph_hints_align_weak_points', equivalent to the TrueType `IUP'
|
||||
* hinting instruction. Typical candidates are control points and
|
||||
* points on the contour without a major direction.
|
||||
*
|
||||
* The major effect is to reduce possible distortion caused by
|
||||
* alignment of edges and strong points, thus weak points are processed
|
||||
* after strong points.
|
||||
*/
|
||||
|
||||
|
||||
/* point hint flags */
|
||||
typedef enum AF_Flags_
|
||||
{
|
||||
AF_FLAG_NONE = 0,
|
||||
|
||||
/* point type flags */
|
||||
AF_FLAG_CONIC = 1 << 0,
|
||||
AF_FLAG_CUBIC = 1 << 1,
|
||||
AF_FLAG_CONTROL = AF_FLAG_CONIC | AF_FLAG_CUBIC,
|
||||
|
||||
/* point extremum flags */
|
||||
AF_FLAG_EXTREMA_X = 1 << 2,
|
||||
AF_FLAG_EXTREMA_Y = 1 << 3,
|
||||
|
||||
/* point roundness flags */
|
||||
AF_FLAG_ROUND_X = 1 << 4,
|
||||
AF_FLAG_ROUND_Y = 1 << 5,
|
||||
|
||||
/* point touch flags */
|
||||
AF_FLAG_TOUCH_X = 1 << 6,
|
||||
AF_FLAG_TOUCH_Y = 1 << 7,
|
||||
|
||||
/* candidates for weak interpolation have this flag set */
|
||||
AF_FLAG_WEAK_INTERPOLATION = 1 << 8,
|
||||
|
||||
/* all inflection points in the outline have this flag set */
|
||||
AF_FLAG_INFLECTION = 1 << 9
|
||||
|
||||
} AF_Flags;
|
||||
|
||||
|
||||
/* edge hint flags */
|
||||
typedef enum AF_Edge_Flags_
|
||||
{
|
||||
AF_EDGE_NORMAL = 0,
|
||||
AF_EDGE_ROUND = 1 << 0,
|
||||
AF_EDGE_SERIF = 1 << 1,
|
||||
AF_EDGE_DONE = 1 << 2
|
||||
|
||||
} AF_Edge_Flags;
|
||||
|
||||
|
||||
typedef struct AF_PointRec_* AF_Point;
|
||||
typedef struct AF_SegmentRec_* AF_Segment;
|
||||
typedef struct AF_EdgeRec_* AF_Edge;
|
||||
|
||||
|
||||
typedef struct AF_PointRec_
|
||||
{
|
||||
FT_UShort flags; /* point flags used by hinter */
|
||||
FT_Char in_dir; /* direction of inwards vector */
|
||||
FT_Char out_dir; /* direction of outwards vector */
|
||||
|
||||
FT_Pos ox, oy; /* original, scaled position */
|
||||
FT_Short fx, fy; /* original, unscaled position (font units) */
|
||||
FT_Pos x, y; /* current position */
|
||||
FT_Pos u, v; /* current (x,y) or (y,x) depending on context */
|
||||
|
||||
AF_Point next; /* next point in contour */
|
||||
AF_Point prev; /* previous point in contour */
|
||||
|
||||
} AF_PointRec;
|
||||
|
||||
|
||||
typedef struct AF_SegmentRec_
|
||||
{
|
||||
FT_Byte flags; /* edge/segment flags for this segment */
|
||||
FT_Char dir; /* segment direction */
|
||||
FT_Short pos; /* position of segment */
|
||||
FT_Short min_coord; /* minimum coordinate of segment */
|
||||
FT_Short max_coord; /* maximum coordinate of segment */
|
||||
FT_Short height; /* the hinted segment height */
|
||||
|
||||
AF_Edge edge; /* the segment's parent edge */
|
||||
AF_Segment edge_next; /* link to next segment in parent edge */
|
||||
|
||||
AF_Segment link; /* (stem) link segment */
|
||||
AF_Segment serif; /* primary segment for serifs */
|
||||
FT_Pos num_linked; /* number of linked segments */
|
||||
FT_Pos score; /* used during stem matching */
|
||||
FT_Pos len; /* used during stem matching */
|
||||
|
||||
AF_Point first; /* first point in edge segment */
|
||||
AF_Point last; /* last point in edge segment */
|
||||
|
||||
} AF_SegmentRec;
|
||||
|
||||
|
||||
typedef struct AF_EdgeRec_
|
||||
{
|
||||
FT_Short fpos; /* original, unscaled position (font units) */
|
||||
FT_Pos opos; /* original, scaled position */
|
||||
FT_Pos pos; /* current position */
|
||||
|
||||
FT_Byte flags; /* edge flags */
|
||||
FT_Char dir; /* edge direction */
|
||||
FT_Fixed scale; /* used to speed up interpolation between edges */
|
||||
AF_Width blue_edge; /* non-NULL if this is a blue edge */
|
||||
|
||||
AF_Edge link; /* link edge */
|
||||
AF_Edge serif; /* primary edge for serifs */
|
||||
FT_Short num_linked; /* number of linked edges */
|
||||
FT_Int score; /* used during stem matching */
|
||||
|
||||
AF_Segment first; /* first segment in edge */
|
||||
AF_Segment last; /* last segment in edge */
|
||||
|
||||
} AF_EdgeRec;
|
||||
|
||||
|
||||
typedef struct AF_AxisHintsRec_
|
||||
{
|
||||
FT_Int num_segments; /* number of used segments */
|
||||
FT_Int max_segments; /* number of allocated segments */
|
||||
AF_Segment segments; /* segments array */
|
||||
#ifdef AF_SORT_SEGMENTS
|
||||
FT_Int mid_segments;
|
||||
#endif
|
||||
|
||||
FT_Int num_edges; /* number of used edges */
|
||||
FT_Int max_edges; /* number of allocated edges */
|
||||
AF_Edge edges; /* edges array */
|
||||
|
||||
AF_Direction major_dir; /* either vertical or horizontal */
|
||||
|
||||
} AF_AxisHintsRec, *AF_AxisHints;
|
||||
|
||||
|
||||
typedef struct AF_GlyphHintsRec_
|
||||
{
|
||||
FT_Memory memory;
|
||||
|
||||
FT_Fixed x_scale;
|
||||
FT_Pos x_delta;
|
||||
|
||||
FT_Fixed y_scale;
|
||||
FT_Pos y_delta;
|
||||
|
||||
FT_Int max_points; /* number of allocated points */
|
||||
FT_Int num_points; /* number of used points */
|
||||
AF_Point points; /* points array */
|
||||
|
||||
FT_Int max_contours; /* number of allocated contours */
|
||||
FT_Int num_contours; /* number of used contours */
|
||||
AF_Point* contours; /* contours array */
|
||||
|
||||
AF_AxisHintsRec axis[AF_DIMENSION_MAX];
|
||||
|
||||
FT_UInt32 scaler_flags; /* copy of scaler flags */
|
||||
FT_UInt32 other_flags; /* free for script-specific */
|
||||
/* implementations */
|
||||
AF_ScriptMetrics metrics;
|
||||
|
||||
FT_Pos xmin_delta; /* used for warping */
|
||||
FT_Pos xmax_delta;
|
||||
|
||||
} AF_GlyphHintsRec;
|
||||
|
||||
|
||||
#define AF_HINTS_TEST_SCALER( h, f ) ( (h)->scaler_flags & (f) )
|
||||
#define AF_HINTS_TEST_OTHER( h, f ) ( (h)->other_flags & (f) )
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_AUTOFIT
|
||||
|
||||
#define AF_HINTS_DO_HORIZONTAL( h ) \
|
||||
( !_af_debug_disable_horz_hints && \
|
||||
!AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_HORIZONTAL ) )
|
||||
|
||||
#define AF_HINTS_DO_VERTICAL( h ) \
|
||||
( !_af_debug_disable_vert_hints && \
|
||||
!AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_VERTICAL ) )
|
||||
|
||||
#define AF_HINTS_DO_ADVANCE( h ) \
|
||||
!AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_ADVANCE )
|
||||
|
||||
#define AF_HINTS_DO_BLUES( h ) ( !_af_debug_disable_blue_hints )
|
||||
|
||||
#else /* !FT_DEBUG_AUTOFIT */
|
||||
|
||||
#define AF_HINTS_DO_HORIZONTAL( h ) \
|
||||
!AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_HORIZONTAL )
|
||||
|
||||
#define AF_HINTS_DO_VERTICAL( h ) \
|
||||
!AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_VERTICAL )
|
||||
|
||||
#define AF_HINTS_DO_ADVANCE( h ) \
|
||||
!AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_ADVANCE )
|
||||
|
||||
#define AF_HINTS_DO_BLUES( h ) 1
|
||||
|
||||
#endif /* !FT_DEBUG_AUTOFIT */
|
||||
|
||||
|
||||
FT_LOCAL( AF_Direction )
|
||||
af_direction_compute( FT_Pos dx,
|
||||
FT_Pos dy );
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_axis_hints_new_segment( AF_AxisHints axis,
|
||||
FT_Memory memory,
|
||||
AF_Segment *asegment );
|
||||
|
||||
FT_LOCAL( FT_Error)
|
||||
af_axis_hints_new_edge( AF_AxisHints axis,
|
||||
FT_Int fpos,
|
||||
AF_Direction dir,
|
||||
FT_Memory memory,
|
||||
AF_Edge *edge );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_glyph_hints_init( AF_GlyphHints hints,
|
||||
FT_Memory memory );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_glyph_hints_rescale( AF_GlyphHints hints,
|
||||
AF_ScriptMetrics metrics );
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_glyph_hints_reload( AF_GlyphHints hints,
|
||||
FT_Outline* outline );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_glyph_hints_save( AF_GlyphHints hints,
|
||||
FT_Outline* outline );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_glyph_hints_align_edge_points( AF_GlyphHints hints,
|
||||
AF_Dimension dim );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_glyph_hints_align_strong_points( AF_GlyphHints hints,
|
||||
AF_Dimension dim );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_glyph_hints_align_weak_points( AF_GlyphHints hints,
|
||||
AF_Dimension dim );
|
||||
|
||||
#ifdef AF_CONFIG_OPTION_USE_WARPER
|
||||
FT_LOCAL( void )
|
||||
af_glyph_hints_scale_dim( AF_GlyphHints hints,
|
||||
AF_Dimension dim,
|
||||
FT_Fixed scale,
|
||||
FT_Pos delta );
|
||||
#endif
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_glyph_hints_done( AF_GlyphHints hints );
|
||||
|
||||
/* */
|
||||
|
||||
#define AF_SEGMENT_LEN( seg ) ( (seg)->max_coord - (seg)->min_coord )
|
||||
|
||||
#define AF_SEGMENT_DIST( seg1, seg2 ) ( ( (seg1)->pos > (seg2)->pos ) \
|
||||
? (seg1)->pos - (seg2)->pos \
|
||||
: (seg2)->pos - (seg1)->pos )
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFHINTS_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,155 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afindic.c */
|
||||
/* */
|
||||
/* Auto-fitter hinting routines for Indic scripts (body). */
|
||||
/* */
|
||||
/* Copyright 2007, 2011 by */
|
||||
/* Rahul Bhalerao <rahul.bhalerao@redhat.com>, <b.rahul.pm@gmail.com>. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include "aftypes.h"
|
||||
#include "aflatin.h"
|
||||
|
||||
|
||||
#ifdef AF_CONFIG_OPTION_INDIC
|
||||
|
||||
#include "afindic.h"
|
||||
#include "aferrors.h"
|
||||
#include "afcjk.h"
|
||||
|
||||
|
||||
#ifdef AF_CONFIG_OPTION_USE_WARPER
|
||||
#include "afwarp.h"
|
||||
#endif
|
||||
|
||||
|
||||
static FT_Error
|
||||
af_indic_metrics_init( AF_CJKMetrics metrics,
|
||||
FT_Face face )
|
||||
{
|
||||
/* skip blue zone init in CJK routines */
|
||||
FT_CharMap oldmap = face->charmap;
|
||||
|
||||
|
||||
metrics->units_per_em = face->units_per_EM;
|
||||
|
||||
if ( FT_Select_Charmap( face, FT_ENCODING_UNICODE ) )
|
||||
face->charmap = NULL;
|
||||
else
|
||||
{
|
||||
af_cjk_metrics_init_widths( metrics, face, 0x7530 );
|
||||
#if 0
|
||||
/* either need indic specific blue_chars[] or just skip blue zones */
|
||||
af_cjk_metrics_init_blues( metrics, face, af_cjk_blue_chars );
|
||||
#endif
|
||||
af_cjk_metrics_check_digits( metrics, face );
|
||||
}
|
||||
|
||||
FT_Set_Charmap( face, oldmap );
|
||||
|
||||
return AF_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
af_indic_metrics_scale( AF_CJKMetrics metrics,
|
||||
AF_Scaler scaler )
|
||||
{
|
||||
/* use CJK routines */
|
||||
af_cjk_metrics_scale( metrics, scaler );
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
af_indic_hints_init( AF_GlyphHints hints,
|
||||
AF_CJKMetrics metrics )
|
||||
{
|
||||
/* use CJK routines */
|
||||
return af_cjk_hints_init( hints, metrics );
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
af_indic_hints_apply( AF_GlyphHints hints,
|
||||
FT_Outline* outline,
|
||||
AF_CJKMetrics metrics )
|
||||
{
|
||||
/* use CJK routines */
|
||||
return af_cjk_hints_apply( hints, outline, metrics );
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** I N D I C S C R I P T C L A S S *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
static const AF_Script_UniRangeRec af_indic_uniranges[] =
|
||||
{
|
||||
#if 0
|
||||
AF_UNIRANGE_REC( 0x0100UL, 0xFFFFUL ), /* why this? */
|
||||
#endif
|
||||
AF_UNIRANGE_REC( 0x0900UL, 0x0DFFUL), /* Indic Range */
|
||||
AF_UNIRANGE_REC( 0x0F00UL, 0x0FFFUL), /* Tibetan */
|
||||
AF_UNIRANGE_REC( 0x1900UL, 0x194FUL), /* Limbu */
|
||||
AF_UNIRANGE_REC( 0x1B80UL, 0x1BBFUL), /* Sundanese */
|
||||
AF_UNIRANGE_REC( 0x1C80UL, 0x1CDFUL), /* Meetei Mayak */
|
||||
AF_UNIRANGE_REC( 0xA800UL, 0xA82FUL), /* Syloti Nagri */
|
||||
AF_UNIRANGE_REC( 0x11800UL, 0x118DFUL), /* Sharada */
|
||||
AF_UNIRANGE_REC( 0UL, 0UL)
|
||||
};
|
||||
|
||||
|
||||
AF_DEFINE_SCRIPT_CLASS(af_indic_script_class,
|
||||
AF_SCRIPT_INDIC,
|
||||
af_indic_uniranges,
|
||||
|
||||
sizeof( AF_CJKMetricsRec ),
|
||||
|
||||
(AF_Script_InitMetricsFunc) af_indic_metrics_init,
|
||||
(AF_Script_ScaleMetricsFunc)af_indic_metrics_scale,
|
||||
(AF_Script_DoneMetricsFunc) NULL,
|
||||
|
||||
(AF_Script_InitHintsFunc) af_indic_hints_init,
|
||||
(AF_Script_ApplyHintsFunc) af_indic_hints_apply
|
||||
)
|
||||
|
||||
#else /* !AF_CONFIG_OPTION_INDIC */
|
||||
|
||||
static const AF_Script_UniRangeRec af_indic_uniranges[] =
|
||||
{
|
||||
{ 0, 0 }
|
||||
};
|
||||
|
||||
|
||||
AF_DEFINE_SCRIPT_CLASS(af_indic_script_class,
|
||||
AF_SCRIPT_INDIC,
|
||||
af_indic_uniranges,
|
||||
|
||||
sizeof( AF_CJKMetricsRec ),
|
||||
|
||||
(AF_Script_InitMetricsFunc) NULL,
|
||||
(AF_Script_ScaleMetricsFunc)NULL,
|
||||
(AF_Script_DoneMetricsFunc) NULL,
|
||||
|
||||
(AF_Script_InitHintsFunc) NULL,
|
||||
(AF_Script_ApplyHintsFunc) NULL
|
||||
)
|
||||
|
||||
#endif /* !AF_CONFIG_OPTION_INDIC */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,40 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afindic.h */
|
||||
/* */
|
||||
/* Auto-fitter hinting routines for Indic scripts (specification). */
|
||||
/* */
|
||||
/* Copyright 2007 by */
|
||||
/* Rahul Bhalerao <rahul.bhalerao@redhat.com>, <b.rahul.pm@gmail.com>. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFINDIC_H__
|
||||
#define __AFINDIC_H__
|
||||
|
||||
#include "afhints.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/* the Indic-specific script class */
|
||||
|
||||
AF_DECLARE_SCRIPT_CLASS(af_indic_script_class)
|
||||
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFINDIC_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,211 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* aflatin.h */
|
||||
/* */
|
||||
/* Auto-fitter hinting routines for latin script (specification). */
|
||||
/* */
|
||||
/* Copyright 2003-2007, 2009, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFLATIN_H__
|
||||
#define __AFLATIN_H__
|
||||
|
||||
#include "afhints.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/* the latin-specific script class */
|
||||
|
||||
AF_DECLARE_SCRIPT_CLASS(af_latin_script_class)
|
||||
|
||||
|
||||
/* constants are given with units_per_em == 2048 in mind */
|
||||
#define AF_LATIN_CONSTANT( metrics, c ) \
|
||||
( ( (c) * (FT_Long)( (AF_LatinMetrics)(metrics) )->units_per_em ) / 2048 )
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** L A T I N G L O B A L M E T R I C S *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/*
|
||||
* The following declarations could be embedded in the file `aflatin.c';
|
||||
* they have been made semi-public to allow alternate script hinters to
|
||||
* re-use some of them.
|
||||
*/
|
||||
|
||||
|
||||
/* Latin (global) metrics management */
|
||||
|
||||
enum
|
||||
{
|
||||
AF_LATIN_BLUE_CAPITAL_TOP,
|
||||
AF_LATIN_BLUE_CAPITAL_BOTTOM,
|
||||
AF_LATIN_BLUE_SMALL_F_TOP,
|
||||
AF_LATIN_BLUE_SMALL_TOP,
|
||||
AF_LATIN_BLUE_SMALL_BOTTOM,
|
||||
AF_LATIN_BLUE_SMALL_MINOR,
|
||||
|
||||
AF_LATIN_BLUE_MAX
|
||||
};
|
||||
|
||||
|
||||
#define AF_LATIN_IS_TOP_BLUE( b ) ( (b) == AF_LATIN_BLUE_CAPITAL_TOP || \
|
||||
(b) == AF_LATIN_BLUE_SMALL_F_TOP || \
|
||||
(b) == AF_LATIN_BLUE_SMALL_TOP )
|
||||
|
||||
#define AF_LATIN_MAX_WIDTHS 16
|
||||
#define AF_LATIN_MAX_BLUES AF_LATIN_BLUE_MAX
|
||||
|
||||
|
||||
enum
|
||||
{
|
||||
AF_LATIN_BLUE_ACTIVE = 1 << 0, /* set if zone height is <= 3/4px */
|
||||
AF_LATIN_BLUE_TOP = 1 << 1, /* result of AF_LATIN_IS_TOP_BLUE */
|
||||
AF_LATIN_BLUE_ADJUSTMENT = 1 << 2, /* used for scale adjustment */
|
||||
/* optimization */
|
||||
AF_LATIN_BLUE_FLAG_MAX
|
||||
};
|
||||
|
||||
|
||||
typedef struct AF_LatinBlueRec_
|
||||
{
|
||||
AF_WidthRec ref;
|
||||
AF_WidthRec shoot;
|
||||
FT_UInt flags;
|
||||
|
||||
} AF_LatinBlueRec, *AF_LatinBlue;
|
||||
|
||||
|
||||
typedef struct AF_LatinAxisRec_
|
||||
{
|
||||
FT_Fixed scale;
|
||||
FT_Pos delta;
|
||||
|
||||
FT_UInt width_count; /* number of used widths */
|
||||
AF_WidthRec widths[AF_LATIN_MAX_WIDTHS]; /* widths array */
|
||||
FT_Pos edge_distance_threshold; /* used for creating edges */
|
||||
FT_Pos standard_width; /* the default stem thickness */
|
||||
FT_Bool extra_light; /* is standard width very light? */
|
||||
|
||||
/* ignored for horizontal metrics */
|
||||
FT_UInt blue_count;
|
||||
AF_LatinBlueRec blues[AF_LATIN_BLUE_MAX];
|
||||
|
||||
FT_Fixed org_scale;
|
||||
FT_Pos org_delta;
|
||||
|
||||
} AF_LatinAxisRec, *AF_LatinAxis;
|
||||
|
||||
|
||||
typedef struct AF_LatinMetricsRec_
|
||||
{
|
||||
AF_ScriptMetricsRec root;
|
||||
FT_UInt units_per_em;
|
||||
AF_LatinAxisRec axis[AF_DIMENSION_MAX];
|
||||
|
||||
} AF_LatinMetricsRec, *AF_LatinMetrics;
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_latin_metrics_init( AF_LatinMetrics metrics,
|
||||
FT_Face face );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_latin_metrics_scale( AF_LatinMetrics metrics,
|
||||
AF_Scaler scaler );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_latin_metrics_init_widths( AF_LatinMetrics metrics,
|
||||
FT_Face face,
|
||||
FT_ULong charcode );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_latin_metrics_check_digits( AF_LatinMetrics metrics,
|
||||
FT_Face face );
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** L A T I N G L Y P H A N A L Y S I S *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
enum
|
||||
{
|
||||
AF_LATIN_HINTS_HORZ_SNAP = 1 << 0, /* enable stem width snapping */
|
||||
AF_LATIN_HINTS_VERT_SNAP = 1 << 1, /* enable stem height snapping */
|
||||
AF_LATIN_HINTS_STEM_ADJUST = 1 << 2, /* enable stem width/height */
|
||||
/* adjustment */
|
||||
AF_LATIN_HINTS_MONO = 1 << 3 /* indicate monochrome */
|
||||
/* rendering */
|
||||
};
|
||||
|
||||
|
||||
#define AF_LATIN_HINTS_DO_HORZ_SNAP( h ) \
|
||||
AF_HINTS_TEST_OTHER( h, AF_LATIN_HINTS_HORZ_SNAP )
|
||||
|
||||
#define AF_LATIN_HINTS_DO_VERT_SNAP( h ) \
|
||||
AF_HINTS_TEST_OTHER( h, AF_LATIN_HINTS_VERT_SNAP )
|
||||
|
||||
#define AF_LATIN_HINTS_DO_STEM_ADJUST( h ) \
|
||||
AF_HINTS_TEST_OTHER( h, AF_LATIN_HINTS_STEM_ADJUST )
|
||||
|
||||
#define AF_LATIN_HINTS_DO_MONO( h ) \
|
||||
AF_HINTS_TEST_OTHER( h, AF_LATIN_HINTS_MONO )
|
||||
|
||||
|
||||
/*
|
||||
* This shouldn't normally be exported. However, other scripts might
|
||||
* like to use this function as-is.
|
||||
*/
|
||||
FT_LOCAL( FT_Error )
|
||||
af_latin_hints_compute_segments( AF_GlyphHints hints,
|
||||
AF_Dimension dim );
|
||||
|
||||
/*
|
||||
* This shouldn't normally be exported. However, other scripts might
|
||||
* want to use this function as-is.
|
||||
*/
|
||||
FT_LOCAL( void )
|
||||
af_latin_hints_link_segments( AF_GlyphHints hints,
|
||||
AF_Dimension dim );
|
||||
|
||||
/*
|
||||
* This shouldn't normally be exported. However, other scripts might
|
||||
* want to use this function as-is.
|
||||
*/
|
||||
FT_LOCAL( FT_Error )
|
||||
af_latin_hints_compute_edges( AF_GlyphHints hints,
|
||||
AF_Dimension dim );
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_latin_hints_detect_features( AF_GlyphHints hints,
|
||||
AF_Dimension dim );
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFLATIN_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,39 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* aflatin2.h */
|
||||
/* */
|
||||
/* Auto-fitter hinting routines for latin script (specification). */
|
||||
/* */
|
||||
/* Copyright 2003, 2004, 2005, 2006, 2007 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFLATIN2_H__
|
||||
#define __AFLATIN2_H__
|
||||
|
||||
#include "afhints.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/* the latin-specific script class */
|
||||
|
||||
AF_DECLARE_SCRIPT_CLASS(af_latin2_script_class)
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFLATIN_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,547 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afloader.c */
|
||||
/* */
|
||||
/* Auto-fitter glyph loading routines (body). */
|
||||
/* */
|
||||
/* Copyright 2003-2009, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include "afloader.h"
|
||||
#include "afhints.h"
|
||||
#include "afglobal.h"
|
||||
#include "aferrors.h"
|
||||
|
||||
|
||||
/* Initialize glyph loader. */
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
af_loader_init( AF_Loader loader,
|
||||
FT_Memory memory )
|
||||
{
|
||||
FT_ZERO( loader );
|
||||
|
||||
af_glyph_hints_init( &loader->hints, memory );
|
||||
#ifdef FT_DEBUG_AUTOFIT
|
||||
_af_debug_hints = &loader->hints;
|
||||
#endif
|
||||
return FT_GlyphLoader_New( memory, &loader->gloader );
|
||||
}
|
||||
|
||||
|
||||
/* Reset glyph loader and compute globals if necessary. */
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
af_loader_reset( AF_Loader loader,
|
||||
FT_Face face )
|
||||
{
|
||||
FT_Error error = AF_Err_Ok;
|
||||
|
||||
|
||||
loader->face = face;
|
||||
loader->globals = (AF_FaceGlobals)face->autohint.data;
|
||||
|
||||
FT_GlyphLoader_Rewind( loader->gloader );
|
||||
|
||||
if ( loader->globals == NULL )
|
||||
{
|
||||
error = af_face_globals_new( face, &loader->globals );
|
||||
if ( !error )
|
||||
{
|
||||
face->autohint.data =
|
||||
(FT_Pointer)loader->globals;
|
||||
face->autohint.finalizer =
|
||||
(FT_Generic_Finalizer)af_face_globals_free;
|
||||
}
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* Finalize glyph loader. */
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
af_loader_done( AF_Loader loader )
|
||||
{
|
||||
af_glyph_hints_done( &loader->hints );
|
||||
|
||||
loader->face = NULL;
|
||||
loader->globals = NULL;
|
||||
|
||||
#ifdef FT_DEBUG_AUTOFIT
|
||||
_af_debug_hints = NULL;
|
||||
#endif
|
||||
FT_GlyphLoader_Done( loader->gloader );
|
||||
loader->gloader = NULL;
|
||||
}
|
||||
|
||||
|
||||
/* Load a single glyph component. This routine calls itself */
|
||||
/* recursively, if necessary, and does the main work of */
|
||||
/* `af_loader_load_glyph.' */
|
||||
|
||||
static FT_Error
|
||||
af_loader_load_g( AF_Loader loader,
|
||||
AF_Scaler scaler,
|
||||
FT_UInt glyph_index,
|
||||
FT_Int32 load_flags,
|
||||
FT_UInt depth )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Face face = loader->face;
|
||||
FT_GlyphLoader gloader = loader->gloader;
|
||||
AF_ScriptMetrics metrics = loader->metrics;
|
||||
AF_GlyphHints hints = &loader->hints;
|
||||
FT_GlyphSlot slot = face->glyph;
|
||||
FT_Slot_Internal internal = slot->internal;
|
||||
|
||||
|
||||
error = FT_Load_Glyph( face, glyph_index, load_flags );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
loader->transformed = internal->glyph_transformed;
|
||||
if ( loader->transformed )
|
||||
{
|
||||
FT_Matrix inverse;
|
||||
|
||||
|
||||
loader->trans_matrix = internal->glyph_matrix;
|
||||
loader->trans_delta = internal->glyph_delta;
|
||||
|
||||
inverse = loader->trans_matrix;
|
||||
FT_Matrix_Invert( &inverse );
|
||||
FT_Vector_Transform( &loader->trans_delta, &inverse );
|
||||
}
|
||||
|
||||
/* set linear metrics */
|
||||
slot->linearHoriAdvance = slot->metrics.horiAdvance;
|
||||
slot->linearVertAdvance = slot->metrics.vertAdvance;
|
||||
|
||||
switch ( slot->format )
|
||||
{
|
||||
case FT_GLYPH_FORMAT_OUTLINE:
|
||||
/* translate the loaded glyph when an internal transform is needed */
|
||||
if ( loader->transformed )
|
||||
FT_Outline_Translate( &slot->outline,
|
||||
loader->trans_delta.x,
|
||||
loader->trans_delta.y );
|
||||
|
||||
/* copy the outline points in the loader's current */
|
||||
/* extra points which is used to keep original glyph coordinates */
|
||||
error = FT_GLYPHLOADER_CHECK_POINTS( gloader,
|
||||
slot->outline.n_points + 4,
|
||||
slot->outline.n_contours );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
FT_ARRAY_COPY( gloader->current.outline.points,
|
||||
slot->outline.points,
|
||||
slot->outline.n_points );
|
||||
|
||||
FT_ARRAY_COPY( gloader->current.outline.contours,
|
||||
slot->outline.contours,
|
||||
slot->outline.n_contours );
|
||||
|
||||
FT_ARRAY_COPY( gloader->current.outline.tags,
|
||||
slot->outline.tags,
|
||||
slot->outline.n_points );
|
||||
|
||||
gloader->current.outline.n_points = slot->outline.n_points;
|
||||
gloader->current.outline.n_contours = slot->outline.n_contours;
|
||||
|
||||
/* compute original horizontal phantom points (and ignore */
|
||||
/* vertical ones) */
|
||||
loader->pp1.x = hints->x_delta;
|
||||
loader->pp1.y = hints->y_delta;
|
||||
loader->pp2.x = FT_MulFix( slot->metrics.horiAdvance,
|
||||
hints->x_scale ) + hints->x_delta;
|
||||
loader->pp2.y = hints->y_delta;
|
||||
|
||||
/* be sure to check for spacing glyphs */
|
||||
if ( slot->outline.n_points == 0 )
|
||||
goto Hint_Metrics;
|
||||
|
||||
/* now load the slot image into the auto-outline and run the */
|
||||
/* automatic hinting process */
|
||||
if ( metrics->clazz->script_hints_apply )
|
||||
metrics->clazz->script_hints_apply( hints,
|
||||
&gloader->current.outline,
|
||||
metrics );
|
||||
|
||||
/* we now need to adjust the metrics according to the change in */
|
||||
/* width/positioning that occurred during the hinting process */
|
||||
if ( scaler->render_mode != FT_RENDER_MODE_LIGHT )
|
||||
{
|
||||
FT_Pos old_rsb, old_lsb, new_lsb;
|
||||
FT_Pos pp1x_uh, pp2x_uh;
|
||||
AF_AxisHints axis = &hints->axis[AF_DIMENSION_HORZ];
|
||||
AF_Edge edge1 = axis->edges; /* leftmost edge */
|
||||
AF_Edge edge2 = edge1 +
|
||||
axis->num_edges - 1; /* rightmost edge */
|
||||
|
||||
|
||||
if ( axis->num_edges > 1 && AF_HINTS_DO_ADVANCE( hints ) )
|
||||
{
|
||||
old_rsb = loader->pp2.x - edge2->opos;
|
||||
old_lsb = edge1->opos;
|
||||
new_lsb = edge1->pos;
|
||||
|
||||
/* remember unhinted values to later account */
|
||||
/* for rounding errors */
|
||||
|
||||
pp1x_uh = new_lsb - old_lsb;
|
||||
pp2x_uh = edge2->pos + old_rsb;
|
||||
|
||||
/* prefer too much space over too little space */
|
||||
/* for very small sizes */
|
||||
|
||||
if ( old_lsb < 24 )
|
||||
pp1x_uh -= 8;
|
||||
|
||||
if ( old_rsb < 24 )
|
||||
pp2x_uh += 8;
|
||||
|
||||
loader->pp1.x = FT_PIX_ROUND( pp1x_uh );
|
||||
loader->pp2.x = FT_PIX_ROUND( pp2x_uh );
|
||||
|
||||
if ( loader->pp1.x >= new_lsb && old_lsb > 0 )
|
||||
loader->pp1.x -= 64;
|
||||
|
||||
if ( loader->pp2.x <= edge2->pos && old_rsb > 0 )
|
||||
loader->pp2.x += 64;
|
||||
|
||||
slot->lsb_delta = loader->pp1.x - pp1x_uh;
|
||||
slot->rsb_delta = loader->pp2.x - pp2x_uh;
|
||||
}
|
||||
else
|
||||
{
|
||||
FT_Pos pp1x = loader->pp1.x;
|
||||
FT_Pos pp2x = loader->pp2.x;
|
||||
|
||||
|
||||
loader->pp1.x = FT_PIX_ROUND( pp1x );
|
||||
loader->pp2.x = FT_PIX_ROUND( pp2x );
|
||||
|
||||
slot->lsb_delta = loader->pp1.x - pp1x;
|
||||
slot->rsb_delta = loader->pp2.x - pp2x;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
FT_Pos pp1x = loader->pp1.x;
|
||||
FT_Pos pp2x = loader->pp2.x;
|
||||
|
||||
|
||||
loader->pp1.x = FT_PIX_ROUND( pp1x + hints->xmin_delta );
|
||||
loader->pp2.x = FT_PIX_ROUND( pp2x + hints->xmax_delta );
|
||||
|
||||
slot->lsb_delta = loader->pp1.x - pp1x;
|
||||
slot->rsb_delta = loader->pp2.x - pp2x;
|
||||
}
|
||||
|
||||
/* good, we simply add the glyph to our loader's base */
|
||||
FT_GlyphLoader_Add( gloader );
|
||||
break;
|
||||
|
||||
case FT_GLYPH_FORMAT_COMPOSITE:
|
||||
{
|
||||
FT_UInt nn, num_subglyphs = slot->num_subglyphs;
|
||||
FT_UInt num_base_subgs, start_point;
|
||||
FT_SubGlyph subglyph;
|
||||
|
||||
|
||||
start_point = gloader->base.outline.n_points;
|
||||
|
||||
/* first of all, copy the subglyph descriptors in the glyph loader */
|
||||
error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
FT_ARRAY_COPY( gloader->current.subglyphs,
|
||||
slot->subglyphs,
|
||||
num_subglyphs );
|
||||
|
||||
gloader->current.num_subglyphs = num_subglyphs;
|
||||
num_base_subgs = gloader->base.num_subglyphs;
|
||||
|
||||
/* now read each subglyph independently */
|
||||
for ( nn = 0; nn < num_subglyphs; nn++ )
|
||||
{
|
||||
FT_Vector pp1, pp2;
|
||||
FT_Pos x, y;
|
||||
FT_UInt num_points, num_new_points, num_base_points;
|
||||
|
||||
|
||||
/* gloader.current.subglyphs can change during glyph loading due */
|
||||
/* to re-allocation -- we must recompute the current subglyph on */
|
||||
/* each iteration */
|
||||
subglyph = gloader->base.subglyphs + num_base_subgs + nn;
|
||||
|
||||
pp1 = loader->pp1;
|
||||
pp2 = loader->pp2;
|
||||
|
||||
num_base_points = gloader->base.outline.n_points;
|
||||
|
||||
error = af_loader_load_g( loader, scaler, subglyph->index,
|
||||
load_flags, depth + 1 );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
/* recompute subglyph pointer */
|
||||
subglyph = gloader->base.subglyphs + num_base_subgs + nn;
|
||||
|
||||
if ( subglyph->flags & FT_SUBGLYPH_FLAG_USE_MY_METRICS )
|
||||
{
|
||||
pp1 = loader->pp1;
|
||||
pp2 = loader->pp2;
|
||||
}
|
||||
else
|
||||
{
|
||||
loader->pp1 = pp1;
|
||||
loader->pp2 = pp2;
|
||||
}
|
||||
|
||||
num_points = gloader->base.outline.n_points;
|
||||
num_new_points = num_points - num_base_points;
|
||||
|
||||
/* now perform the transformation required for this subglyph */
|
||||
|
||||
if ( subglyph->flags & ( FT_SUBGLYPH_FLAG_SCALE |
|
||||
FT_SUBGLYPH_FLAG_XY_SCALE |
|
||||
FT_SUBGLYPH_FLAG_2X2 ) )
|
||||
{
|
||||
FT_Vector* cur = gloader->base.outline.points +
|
||||
num_base_points;
|
||||
FT_Vector* limit = cur + num_new_points;
|
||||
|
||||
|
||||
for ( ; cur < limit; cur++ )
|
||||
FT_Vector_Transform( cur, &subglyph->transform );
|
||||
}
|
||||
|
||||
/* apply offset */
|
||||
|
||||
if ( !( subglyph->flags & FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES ) )
|
||||
{
|
||||
FT_Int k = subglyph->arg1;
|
||||
FT_UInt l = subglyph->arg2;
|
||||
FT_Vector* p1;
|
||||
FT_Vector* p2;
|
||||
|
||||
|
||||
if ( start_point + k >= num_base_points ||
|
||||
l >= (FT_UInt)num_new_points )
|
||||
{
|
||||
error = AF_Err_Invalid_Composite;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
l += num_base_points;
|
||||
|
||||
/* for now, only use the current point coordinates; */
|
||||
/* we may consider another approach in the near future */
|
||||
p1 = gloader->base.outline.points + start_point + k;
|
||||
p2 = gloader->base.outline.points + start_point + l;
|
||||
|
||||
x = p1->x - p2->x;
|
||||
y = p1->y - p2->y;
|
||||
}
|
||||
else
|
||||
{
|
||||
x = FT_MulFix( subglyph->arg1, hints->x_scale ) + hints->x_delta;
|
||||
y = FT_MulFix( subglyph->arg2, hints->y_scale ) + hints->y_delta;
|
||||
|
||||
x = FT_PIX_ROUND( x );
|
||||
y = FT_PIX_ROUND( y );
|
||||
}
|
||||
|
||||
{
|
||||
FT_Outline dummy = gloader->base.outline;
|
||||
|
||||
|
||||
dummy.points += num_base_points;
|
||||
dummy.n_points = (short)num_new_points;
|
||||
|
||||
FT_Outline_Translate( &dummy, x, y );
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
/* we don't support other formats (yet?) */
|
||||
error = AF_Err_Unimplemented_Feature;
|
||||
}
|
||||
|
||||
Hint_Metrics:
|
||||
if ( depth == 0 )
|
||||
{
|
||||
FT_BBox bbox;
|
||||
FT_Vector vvector;
|
||||
|
||||
|
||||
vvector.x = slot->metrics.vertBearingX - slot->metrics.horiBearingX;
|
||||
vvector.y = slot->metrics.vertBearingY - slot->metrics.horiBearingY;
|
||||
vvector.x = FT_MulFix( vvector.x, metrics->scaler.x_scale );
|
||||
vvector.y = FT_MulFix( vvector.y, metrics->scaler.y_scale );
|
||||
|
||||
/* transform the hinted outline if needed */
|
||||
if ( loader->transformed )
|
||||
{
|
||||
FT_Outline_Transform( &gloader->base.outline, &loader->trans_matrix );
|
||||
FT_Vector_Transform( &vvector, &loader->trans_matrix );
|
||||
}
|
||||
#if 1
|
||||
/* we must translate our final outline by -pp1.x and compute */
|
||||
/* the new metrics */
|
||||
if ( loader->pp1.x )
|
||||
FT_Outline_Translate( &gloader->base.outline, -loader->pp1.x, 0 );
|
||||
#endif
|
||||
FT_Outline_Get_CBox( &gloader->base.outline, &bbox );
|
||||
|
||||
bbox.xMin = FT_PIX_FLOOR( bbox.xMin );
|
||||
bbox.yMin = FT_PIX_FLOOR( bbox.yMin );
|
||||
bbox.xMax = FT_PIX_CEIL( bbox.xMax );
|
||||
bbox.yMax = FT_PIX_CEIL( bbox.yMax );
|
||||
|
||||
slot->metrics.width = bbox.xMax - bbox.xMin;
|
||||
slot->metrics.height = bbox.yMax - bbox.yMin;
|
||||
slot->metrics.horiBearingX = bbox.xMin;
|
||||
slot->metrics.horiBearingY = bbox.yMax;
|
||||
|
||||
slot->metrics.vertBearingX = FT_PIX_FLOOR( bbox.xMin + vvector.x );
|
||||
slot->metrics.vertBearingY = FT_PIX_FLOOR( bbox.yMax + vvector.y );
|
||||
|
||||
/* for mono-width fonts (like Andale, Courier, etc.) we need */
|
||||
/* to keep the original rounded advance width; ditto for */
|
||||
/* digits if all have the same advance width */
|
||||
#if 0
|
||||
if ( !FT_IS_FIXED_WIDTH( slot->face ) )
|
||||
slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
|
||||
else
|
||||
slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
|
||||
x_scale );
|
||||
#else
|
||||
if ( FT_IS_FIXED_WIDTH( slot->face ) ||
|
||||
( af_face_globals_is_digit( loader->globals, glyph_index ) &&
|
||||
metrics->digits_have_same_width ) )
|
||||
{
|
||||
slot->metrics.horiAdvance = FT_MulFix( slot->metrics.horiAdvance,
|
||||
metrics->scaler.x_scale );
|
||||
|
||||
/* Set delta values to 0. Otherwise code that uses them is */
|
||||
/* going to ruin the fixed advance width. */
|
||||
slot->lsb_delta = 0;
|
||||
slot->rsb_delta = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* non-spacing glyphs must stay as-is */
|
||||
if ( slot->metrics.horiAdvance )
|
||||
slot->metrics.horiAdvance = loader->pp2.x - loader->pp1.x;
|
||||
}
|
||||
#endif
|
||||
|
||||
slot->metrics.vertAdvance = FT_MulFix( slot->metrics.vertAdvance,
|
||||
metrics->scaler.y_scale );
|
||||
|
||||
slot->metrics.horiAdvance = FT_PIX_ROUND( slot->metrics.horiAdvance );
|
||||
slot->metrics.vertAdvance = FT_PIX_ROUND( slot->metrics.vertAdvance );
|
||||
|
||||
/* now copy outline into glyph slot */
|
||||
FT_GlyphLoader_Rewind( internal->loader );
|
||||
error = FT_GlyphLoader_CopyPoints( internal->loader, gloader );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
slot->outline = internal->loader->base.outline;
|
||||
slot->format = FT_GLYPH_FORMAT_OUTLINE;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* Load a glyph. */
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
af_loader_load_glyph( AF_Loader loader,
|
||||
FT_Face face,
|
||||
FT_UInt gindex,
|
||||
FT_UInt32 load_flags )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Size size = face->size;
|
||||
AF_ScalerRec scaler;
|
||||
|
||||
|
||||
if ( !size )
|
||||
return AF_Err_Invalid_Argument;
|
||||
|
||||
FT_ZERO( &scaler );
|
||||
|
||||
scaler.face = face;
|
||||
scaler.x_scale = size->metrics.x_scale;
|
||||
scaler.x_delta = 0; /* XXX: TODO: add support for sub-pixel hinting */
|
||||
scaler.y_scale = size->metrics.y_scale;
|
||||
scaler.y_delta = 0; /* XXX: TODO: add support for sub-pixel hinting */
|
||||
|
||||
scaler.render_mode = FT_LOAD_TARGET_MODE( load_flags );
|
||||
scaler.flags = 0; /* XXX: fix this */
|
||||
|
||||
error = af_loader_reset( loader, face );
|
||||
if ( !error )
|
||||
{
|
||||
AF_ScriptMetrics metrics;
|
||||
FT_UInt options = 0;
|
||||
|
||||
|
||||
#ifdef FT_OPTION_AUTOFIT2
|
||||
/* XXX: undocumented hook to activate the latin2 hinter */
|
||||
if ( load_flags & ( 1UL << 20 ) )
|
||||
options = 2;
|
||||
#endif
|
||||
|
||||
error = af_face_globals_get_metrics( loader->globals, gindex,
|
||||
options, &metrics );
|
||||
if ( !error )
|
||||
{
|
||||
loader->metrics = metrics;
|
||||
|
||||
if ( metrics->clazz->script_metrics_scale )
|
||||
metrics->clazz->script_metrics_scale( metrics, &scaler );
|
||||
else
|
||||
metrics->scaler = scaler;
|
||||
|
||||
load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_IGNORE_TRANSFORM;
|
||||
load_flags &= ~FT_LOAD_RENDER;
|
||||
|
||||
if ( metrics->clazz->script_hints_init )
|
||||
{
|
||||
error = metrics->clazz->script_hints_init( &loader->hints,
|
||||
metrics );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
error = af_loader_load_g( loader, &scaler, gindex, load_flags, 0 );
|
||||
}
|
||||
}
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,73 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afloader.h */
|
||||
/* */
|
||||
/* Auto-fitter glyph loading routines (specification). */
|
||||
/* */
|
||||
/* Copyright 2003-2005, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFLOADER_H__
|
||||
#define __AFLOADER_H__
|
||||
|
||||
#include "afhints.h"
|
||||
#include "afglobal.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
typedef struct AF_LoaderRec_
|
||||
{
|
||||
FT_Face face; /* current face */
|
||||
AF_FaceGlobals globals; /* current face globals */
|
||||
FT_GlyphLoader gloader; /* glyph loader */
|
||||
AF_GlyphHintsRec hints;
|
||||
AF_ScriptMetrics metrics;
|
||||
FT_Bool transformed;
|
||||
FT_Matrix trans_matrix;
|
||||
FT_Vector trans_delta;
|
||||
FT_Vector pp1;
|
||||
FT_Vector pp2;
|
||||
/* we don't handle vertical phantom points */
|
||||
|
||||
} AF_LoaderRec, *AF_Loader;
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_loader_init( AF_Loader loader,
|
||||
FT_Memory memory );
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_loader_reset( AF_Loader loader,
|
||||
FT_Face face );
|
||||
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_loader_done( AF_Loader loader );
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
af_loader_load_glyph( AF_Loader loader,
|
||||
FT_Face face,
|
||||
FT_UInt gindex,
|
||||
FT_UInt32 load_flags );
|
||||
|
||||
/* */
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFLOADER_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,93 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afmodule.c */
|
||||
/* */
|
||||
/* Auto-fitter module implementation (body). */
|
||||
/* */
|
||||
/* Copyright 2003-2006, 2009, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include "afmodule.h"
|
||||
#include "afloader.h"
|
||||
#include "afpic.h"
|
||||
|
||||
#ifdef FT_DEBUG_AUTOFIT
|
||||
int _af_debug_disable_horz_hints;
|
||||
int _af_debug_disable_vert_hints;
|
||||
int _af_debug_disable_blue_hints;
|
||||
void* _af_debug_hints;
|
||||
#endif
|
||||
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
|
||||
typedef struct FT_AutofitterRec_
|
||||
{
|
||||
FT_ModuleRec root;
|
||||
AF_LoaderRec loader[1];
|
||||
|
||||
} FT_AutofitterRec, *FT_Autofitter;
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
af_autofitter_init( FT_Autofitter module )
|
||||
{
|
||||
return af_loader_init( module->loader, module->root.library->memory );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
af_autofitter_done( FT_Autofitter module )
|
||||
{
|
||||
af_loader_done( module->loader );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
af_autofitter_load_glyph( FT_Autofitter module,
|
||||
FT_GlyphSlot slot,
|
||||
FT_Size size,
|
||||
FT_UInt glyph_index,
|
||||
FT_Int32 load_flags )
|
||||
{
|
||||
FT_UNUSED( size );
|
||||
|
||||
return af_loader_load_glyph( module->loader, slot->face,
|
||||
glyph_index, load_flags );
|
||||
}
|
||||
|
||||
|
||||
FT_DEFINE_AUTOHINTER_SERVICE(
|
||||
af_autofitter_service,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
(FT_AutoHinter_GlyphLoadFunc)af_autofitter_load_glyph )
|
||||
|
||||
FT_DEFINE_MODULE(
|
||||
autofit_module_class,
|
||||
|
||||
FT_MODULE_HINTER,
|
||||
sizeof ( FT_AutofitterRec ),
|
||||
|
||||
"autofitter",
|
||||
0x10000L, /* version 1.0 of the autofitter */
|
||||
0x20000L, /* requires FreeType 2.0 or above */
|
||||
|
||||
(const void*)&AF_AF_AUTOFITTER_SERVICE_GET,
|
||||
|
||||
(FT_Module_Constructor)af_autofitter_init,
|
||||
(FT_Module_Destructor) af_autofitter_done,
|
||||
(FT_Module_Requester) NULL )
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,37 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afmodule.h */
|
||||
/* */
|
||||
/* Auto-fitter module implementation (specification). */
|
||||
/* */
|
||||
/* Copyright 2003, 2004, 2005 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFMODULE_H__
|
||||
#define __AFMODULE_H__
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_MODULE_H
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
FT_DECLARE_MODULE(autofit_module_class)
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFMODULE_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,106 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afpic.c */
|
||||
/* */
|
||||
/* The FreeType position independent code services for autofit module. */
|
||||
/* */
|
||||
/* Copyright 2009, 2010, 2011 by */
|
||||
/* Oran Agra and Mickey Gabel. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include "afpic.h"
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_PIC
|
||||
|
||||
/* forward declaration of PIC init functions from afmodule.c */
|
||||
void FT_Init_Class_af_autofitter_service( FT_Library,
|
||||
FT_AutoHinter_ServiceRec* );
|
||||
|
||||
/* forward declaration of PIC init functions from script classes */
|
||||
#include "aflatin.h"
|
||||
#include "aflatin2.h"
|
||||
#include "afcjk.h"
|
||||
#include "afdummy.h"
|
||||
#include "afindic.h"
|
||||
|
||||
void
|
||||
autofit_module_class_pic_free( FT_Library library )
|
||||
{
|
||||
FT_PIC_Container* pic_container = &library->pic_container;
|
||||
FT_Memory memory = library->memory;
|
||||
|
||||
|
||||
if ( pic_container->autofit )
|
||||
{
|
||||
FT_FREE( pic_container->autofit );
|
||||
pic_container->autofit = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_Error
|
||||
autofit_module_class_pic_init( FT_Library library )
|
||||
{
|
||||
FT_PIC_Container* pic_container = &library->pic_container;
|
||||
FT_UInt ss;
|
||||
FT_Error error = AF_Err_Ok;
|
||||
AFModulePIC* container;
|
||||
FT_Memory memory = library->memory;
|
||||
|
||||
|
||||
/* allocate pointer, clear and set global container pointer */
|
||||
if ( FT_ALLOC ( container, sizeof ( *container ) ) )
|
||||
return error;
|
||||
FT_MEM_SET( container, 0, sizeof ( *container ) );
|
||||
pic_container->autofit = container;
|
||||
|
||||
/* initialize pointer table - */
|
||||
/* this is how the module usually expects this data */
|
||||
for ( ss = 0 ; ss < AF_SCRIPT_CLASSES_REC_COUNT ; ss++ )
|
||||
{
|
||||
container->af_script_classes[ss] =
|
||||
&container->af_script_classes_rec[ss];
|
||||
}
|
||||
container->af_script_classes[AF_SCRIPT_CLASSES_COUNT - 1] = NULL;
|
||||
|
||||
/* add call to initialization function when you add new scripts */
|
||||
ss = 0;
|
||||
FT_Init_Class_af_dummy_script_class(
|
||||
&container->af_script_classes_rec[ss++] );
|
||||
#ifdef FT_OPTION_AUTOFIT2
|
||||
FT_Init_Class_af_latin2_script_class(
|
||||
&container->af_script_classes_rec[ss++] );
|
||||
#endif
|
||||
FT_Init_Class_af_latin_script_class(
|
||||
&container->af_script_classes_rec[ss++] );
|
||||
FT_Init_Class_af_cjk_script_class(
|
||||
&container->af_script_classes_rec[ss++] );
|
||||
FT_Init_Class_af_indic_script_class(
|
||||
&container->af_script_classes_rec[ss++] );
|
||||
|
||||
FT_Init_Class_af_autofitter_service(
|
||||
library, &container->af_autofitter_service );
|
||||
|
||||
/* Exit: */
|
||||
|
||||
if ( error )
|
||||
autofit_module_class_pic_free( library );
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,69 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afpic.h */
|
||||
/* */
|
||||
/* The FreeType position independent code services for autofit module. */
|
||||
/* */
|
||||
/* Copyright 2009, 2011 by */
|
||||
/* Oran Agra and Mickey Gabel. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFPIC_H__
|
||||
#define __AFPIC_H__
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
#include FT_INTERNAL_PIC_H
|
||||
|
||||
#ifndef FT_CONFIG_OPTION_PIC
|
||||
|
||||
#define AF_SCRIPT_CLASSES_GET af_script_classes
|
||||
#define AF_AF_AUTOFITTER_SERVICE_GET af_autofitter_service
|
||||
|
||||
#else /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
#include "aftypes.h"
|
||||
|
||||
/* increase these when you add new scripts, */
|
||||
/* and update autofit_module_class_pic_init */
|
||||
#ifdef FT_OPTION_AUTOFIT2
|
||||
#define AF_SCRIPT_CLASSES_COUNT 6
|
||||
#else
|
||||
#define AF_SCRIPT_CLASSES_COUNT 5
|
||||
#endif
|
||||
#define AF_SCRIPT_CLASSES_REC_COUNT ( AF_SCRIPT_CLASSES_COUNT - 1 )
|
||||
|
||||
typedef struct AFModulePIC_
|
||||
{
|
||||
AF_ScriptClass af_script_classes[AF_SCRIPT_CLASSES_COUNT];
|
||||
AF_ScriptClassRec af_script_classes_rec[AF_SCRIPT_CLASSES_REC_COUNT];
|
||||
FT_AutoHinter_ServiceRec af_autofitter_service;
|
||||
|
||||
} AFModulePIC;
|
||||
|
||||
#define GET_PIC( lib ) \
|
||||
( (AFModulePIC*)((lib)->pic_container.autofit) )
|
||||
#define AF_SCRIPT_CLASSES_GET \
|
||||
( GET_PIC( FT_FACE_LIBRARY(globals->face) )->af_script_classes )
|
||||
#define AF_AF_AUTOFITTER_SERVICE_GET \
|
||||
( GET_PIC( library )->af_autofitter_service )
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFPIC_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,370 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* aftypes.h */
|
||||
/* */
|
||||
/* Auto-fitter types (specification only). */
|
||||
/* */
|
||||
/* Copyright 2003-2009, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
*
|
||||
* The auto-fitter is a complete rewrite of the old auto-hinter.
|
||||
* Its main feature is the ability to differentiate between different
|
||||
* scripts in order to apply language-specific rules.
|
||||
*
|
||||
* The code has also been compartmentized into several entities that
|
||||
* should make algorithmic experimentation easier than with the old
|
||||
* code.
|
||||
*
|
||||
* Finally, we get rid of the Catharon license, since this code is
|
||||
* released under the FreeType one.
|
||||
*
|
||||
*************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFTYPES_H__
|
||||
#define __AFTYPES_H__
|
||||
|
||||
#include <ft2build.h>
|
||||
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_OUTLINE_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** D E B U G G I N G *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
#ifdef FT_DEBUG_AUTOFIT
|
||||
|
||||
#include FT_CONFIG_STANDARD_LIBRARY_H
|
||||
|
||||
extern int _af_debug_disable_horz_hints;
|
||||
extern int _af_debug_disable_vert_hints;
|
||||
extern int _af_debug_disable_blue_hints;
|
||||
extern void* _af_debug_hints;
|
||||
|
||||
#endif /* FT_DEBUG_AUTOFIT */
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** U T I L I T Y S T U F F *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
typedef struct AF_WidthRec_
|
||||
{
|
||||
FT_Pos org; /* original position/width in font units */
|
||||
FT_Pos cur; /* current/scaled position/width in device sub-pixels */
|
||||
FT_Pos fit; /* current/fitted position/width in device sub-pixels */
|
||||
|
||||
} AF_WidthRec, *AF_Width;
|
||||
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_sort_pos( FT_UInt count,
|
||||
FT_Pos* table );
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_sort_widths( FT_UInt count,
|
||||
AF_Width widths );
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** A N G L E T Y P E S *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/*
|
||||
* The auto-fitter doesn't need a very high angular accuracy;
|
||||
* this allows us to speed up some computations considerably with a
|
||||
* light Cordic algorithm (see afangles.c).
|
||||
*/
|
||||
|
||||
typedef FT_Int AF_Angle;
|
||||
|
||||
|
||||
#define AF_ANGLE_PI 256
|
||||
#define AF_ANGLE_2PI ( AF_ANGLE_PI * 2 )
|
||||
#define AF_ANGLE_PI2 ( AF_ANGLE_PI / 2 )
|
||||
#define AF_ANGLE_PI4 ( AF_ANGLE_PI / 4 )
|
||||
|
||||
|
||||
#if 0
|
||||
/*
|
||||
* compute the angle of a given 2-D vector
|
||||
*/
|
||||
FT_LOCAL( AF_Angle )
|
||||
af_angle_atan( FT_Pos dx,
|
||||
FT_Pos dy );
|
||||
|
||||
|
||||
/*
|
||||
* compute `angle2 - angle1'; the result is always within
|
||||
* the range [-AF_ANGLE_PI .. AF_ANGLE_PI - 1]
|
||||
*/
|
||||
FT_LOCAL( AF_Angle )
|
||||
af_angle_diff( AF_Angle angle1,
|
||||
AF_Angle angle2 );
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
#define AF_ANGLE_DIFF( result, angle1, angle2 ) \
|
||||
FT_BEGIN_STMNT \
|
||||
AF_Angle _delta = (angle2) - (angle1); \
|
||||
\
|
||||
\
|
||||
_delta %= AF_ANGLE_2PI; \
|
||||
if ( _delta < 0 ) \
|
||||
_delta += AF_ANGLE_2PI; \
|
||||
\
|
||||
if ( _delta > AF_ANGLE_PI ) \
|
||||
_delta -= AF_ANGLE_2PI; \
|
||||
\
|
||||
result = _delta; \
|
||||
FT_END_STMNT
|
||||
|
||||
|
||||
/* opaque handle to glyph-specific hints -- see `afhints.h' for more
|
||||
* details
|
||||
*/
|
||||
typedef struct AF_GlyphHintsRec_* AF_GlyphHints;
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** S C A L E R S *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/*
|
||||
* A scaler models the target pixel device that will receive the
|
||||
* auto-hinted glyph image.
|
||||
*/
|
||||
|
||||
typedef enum AF_ScalerFlags_
|
||||
{
|
||||
AF_SCALER_FLAG_NO_HORIZONTAL = 1, /* disable horizontal hinting */
|
||||
AF_SCALER_FLAG_NO_VERTICAL = 2, /* disable vertical hinting */
|
||||
AF_SCALER_FLAG_NO_ADVANCE = 4 /* disable advance hinting */
|
||||
|
||||
} AF_ScalerFlags;
|
||||
|
||||
|
||||
typedef struct AF_ScalerRec_
|
||||
{
|
||||
FT_Face face; /* source font face */
|
||||
FT_Fixed x_scale; /* from font units to 1/64th device pixels */
|
||||
FT_Fixed y_scale; /* from font units to 1/64th device pixels */
|
||||
FT_Pos x_delta; /* in 1/64th device pixels */
|
||||
FT_Pos y_delta; /* in 1/64th device pixels */
|
||||
FT_Render_Mode render_mode; /* monochrome, anti-aliased, LCD, etc. */
|
||||
FT_UInt32 flags; /* additional control flags, see above */
|
||||
|
||||
} AF_ScalerRec, *AF_Scaler;
|
||||
|
||||
|
||||
#define AF_SCALER_EQUAL_SCALES( a, b ) \
|
||||
( (a)->x_scale == (b)->x_scale && \
|
||||
(a)->y_scale == (b)->y_scale && \
|
||||
(a)->x_delta == (b)->x_delta && \
|
||||
(a)->y_delta == (b)->y_delta )
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** S C R I P T S *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/*
|
||||
* The list of known scripts. Each different script corresponds to the
|
||||
* following information:
|
||||
*
|
||||
* - A set of Unicode ranges to test whether the face supports the
|
||||
* script.
|
||||
*
|
||||
* - A specific global analyzer that will compute global metrics
|
||||
* specific to the script.
|
||||
*
|
||||
* - A specific glyph analyzer that will compute segments and
|
||||
* edges for each glyph covered by the script.
|
||||
*
|
||||
* - A specific grid-fitting algorithm that will distort the
|
||||
* scaled glyph outline according to the results of the glyph
|
||||
* analyzer.
|
||||
*
|
||||
* Note that a given analyzer and/or grid-fitting algorithm can be
|
||||
* used by more than one script.
|
||||
*/
|
||||
|
||||
typedef enum AF_Script_
|
||||
{
|
||||
AF_SCRIPT_NONE = 0,
|
||||
AF_SCRIPT_LATIN = 1,
|
||||
AF_SCRIPT_CJK = 2,
|
||||
AF_SCRIPT_INDIC = 3,
|
||||
#ifdef FT_OPTION_AUTOFIT2
|
||||
AF_SCRIPT_LATIN2,
|
||||
#endif
|
||||
|
||||
/* add new scripts here. Don't forget to update the list in */
|
||||
/* `afglobal.c'. */
|
||||
|
||||
AF_SCRIPT_MAX /* do not remove */
|
||||
|
||||
} AF_Script;
|
||||
|
||||
|
||||
typedef struct AF_ScriptClassRec_ const* AF_ScriptClass;
|
||||
|
||||
typedef struct AF_ScriptMetricsRec_
|
||||
{
|
||||
AF_ScriptClass clazz;
|
||||
AF_ScalerRec scaler;
|
||||
FT_Bool digits_have_same_width;
|
||||
|
||||
} AF_ScriptMetricsRec, *AF_ScriptMetrics;
|
||||
|
||||
|
||||
/* This function parses an FT_Face to compute global metrics for
|
||||
* a specific script.
|
||||
*/
|
||||
typedef FT_Error
|
||||
(*AF_Script_InitMetricsFunc)( AF_ScriptMetrics metrics,
|
||||
FT_Face face );
|
||||
|
||||
typedef void
|
||||
(*AF_Script_ScaleMetricsFunc)( AF_ScriptMetrics metrics,
|
||||
AF_Scaler scaler );
|
||||
|
||||
typedef void
|
||||
(*AF_Script_DoneMetricsFunc)( AF_ScriptMetrics metrics );
|
||||
|
||||
|
||||
typedef FT_Error
|
||||
(*AF_Script_InitHintsFunc)( AF_GlyphHints hints,
|
||||
AF_ScriptMetrics metrics );
|
||||
|
||||
typedef void
|
||||
(*AF_Script_ApplyHintsFunc)( AF_GlyphHints hints,
|
||||
FT_Outline* outline,
|
||||
AF_ScriptMetrics metrics );
|
||||
|
||||
|
||||
typedef struct AF_Script_UniRangeRec_
|
||||
{
|
||||
FT_UInt32 first;
|
||||
FT_UInt32 last;
|
||||
|
||||
} AF_Script_UniRangeRec;
|
||||
|
||||
#define AF_UNIRANGE_REC( a, b ) { (FT_UInt32)(a), (FT_UInt32)(b) }
|
||||
|
||||
typedef const AF_Script_UniRangeRec *AF_Script_UniRange;
|
||||
|
||||
|
||||
typedef struct AF_ScriptClassRec_
|
||||
{
|
||||
AF_Script script;
|
||||
AF_Script_UniRange script_uni_ranges; /* last must be { 0, 0 } */
|
||||
|
||||
FT_Offset script_metrics_size;
|
||||
AF_Script_InitMetricsFunc script_metrics_init;
|
||||
AF_Script_ScaleMetricsFunc script_metrics_scale;
|
||||
AF_Script_DoneMetricsFunc script_metrics_done;
|
||||
|
||||
AF_Script_InitHintsFunc script_hints_init;
|
||||
AF_Script_ApplyHintsFunc script_hints_apply;
|
||||
|
||||
} AF_ScriptClassRec;
|
||||
|
||||
|
||||
/* Declare and define vtables for classes */
|
||||
#ifndef FT_CONFIG_OPTION_PIC
|
||||
|
||||
#define AF_DECLARE_SCRIPT_CLASS( script_class ) \
|
||||
FT_CALLBACK_TABLE const AF_ScriptClassRec \
|
||||
script_class;
|
||||
|
||||
#define AF_DEFINE_SCRIPT_CLASS( script_class, script_, ranges, m_size, \
|
||||
m_init, m_scale, m_done, h_init, h_apply ) \
|
||||
FT_CALLBACK_TABLE_DEF const AF_ScriptClassRec \
|
||||
script_class = \
|
||||
{ \
|
||||
script_, \
|
||||
ranges, \
|
||||
\
|
||||
m_size, \
|
||||
\
|
||||
m_init, \
|
||||
m_scale, \
|
||||
m_done, \
|
||||
\
|
||||
h_init, \
|
||||
h_apply \
|
||||
};
|
||||
|
||||
#else /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
#define AF_DECLARE_SCRIPT_CLASS( script_class ) \
|
||||
FT_LOCAL( void ) \
|
||||
FT_Init_Class_##script_class( AF_ScriptClassRec* ac );
|
||||
|
||||
#define AF_DEFINE_SCRIPT_CLASS( script_class, script_, ranges, m_size, \
|
||||
m_init, m_scale, m_done, h_init, h_apply ) \
|
||||
FT_LOCAL_DEF( void ) \
|
||||
FT_Init_Class_##script_class( AF_ScriptClassRec* ac ) \
|
||||
{ \
|
||||
ac->script = script_; \
|
||||
ac->script_uni_ranges = ranges; \
|
||||
\
|
||||
ac->script_metrics_size = m_size; \
|
||||
\
|
||||
ac->script_metrics_init = m_init; \
|
||||
ac->script_metrics_scale = m_scale; \
|
||||
ac->script_metrics_done = m_done; \
|
||||
\
|
||||
ac->script_hints_init = h_init; \
|
||||
ac->script_hints_apply = h_apply; \
|
||||
}
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __AFTYPES_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,374 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afwarp.c */
|
||||
/* */
|
||||
/* Auto-fitter warping algorithm (body). */
|
||||
/* */
|
||||
/* Copyright 2006, 2007, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
/*
|
||||
* The idea of the warping code is to slightly scale and shift a glyph
|
||||
* within a single dimension so that as much of its segments are aligned
|
||||
* (more or less) on the grid. To find out the optimal scaling and
|
||||
* shifting value, various parameter combinations are tried and scored.
|
||||
*/
|
||||
|
||||
#include "afwarp.h"
|
||||
|
||||
#ifdef AF_CONFIG_OPTION_USE_WARPER
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_afwarp
|
||||
|
||||
|
||||
/* The weights cover the range 0/64 - 63/64 of a pixel. Obviously, */
|
||||
/* values around a half pixel (which means exactly between two grid */
|
||||
/* lines) gets the worst weight. */
|
||||
#if 1
|
||||
static const AF_WarpScore
|
||||
af_warper_weights[64] =
|
||||
{
|
||||
35, 32, 30, 25, 20, 15, 12, 10, 5, 1, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, -1, -2, -5, -8,-10,-10,-20,-20,-30,-30,
|
||||
|
||||
-30,-30,-20,-20,-10,-10, -8, -5, -2, -1, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 1, 5, 10, 12, 15, 20, 25, 30, 32,
|
||||
};
|
||||
#else
|
||||
static const AF_WarpScore
|
||||
af_warper_weights[64] =
|
||||
{
|
||||
30, 20, 10, 5, 4, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, -1, -2, -2, -5, -5,-10,-10,-15,-20,
|
||||
|
||||
-20,-15,-15,-10,-10, -5, -5, -2, -2, -1, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 4, 5, 10, 20,
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
/* Score segments for a given `scale' and `delta' in the range */
|
||||
/* `xx1' to `xx2', and store the best result in `warper'. If */
|
||||
/* the new best score is equal to the old one, prefer the */
|
||||
/* value with a smaller distortion (around `base_distort'). */
|
||||
|
||||
static void
|
||||
af_warper_compute_line_best( AF_Warper warper,
|
||||
FT_Fixed scale,
|
||||
FT_Pos delta,
|
||||
FT_Pos xx1,
|
||||
FT_Pos xx2,
|
||||
AF_WarpScore base_distort,
|
||||
AF_Segment segments,
|
||||
FT_UInt num_segments )
|
||||
{
|
||||
FT_Int idx_min, idx_max, idx0;
|
||||
FT_UInt nn;
|
||||
AF_WarpScore scores[65];
|
||||
|
||||
|
||||
for ( nn = 0; nn < 65; nn++ )
|
||||
scores[nn] = 0;
|
||||
|
||||
idx0 = xx1 - warper->t1;
|
||||
|
||||
/* compute minimum and maximum indices */
|
||||
{
|
||||
FT_Pos xx1min = warper->x1min;
|
||||
FT_Pos xx1max = warper->x1max;
|
||||
FT_Pos w = xx2 - xx1;
|
||||
|
||||
|
||||
if ( xx1min + w < warper->x2min )
|
||||
xx1min = warper->x2min - w;
|
||||
|
||||
xx1max = warper->x1max;
|
||||
if ( xx1max + w > warper->x2max )
|
||||
xx1max = warper->x2max - w;
|
||||
|
||||
idx_min = xx1min - warper->t1;
|
||||
idx_max = xx1max - warper->t1;
|
||||
|
||||
if ( idx_min < 0 || idx_min > idx_max || idx_max > 64 )
|
||||
{
|
||||
FT_TRACE5(( "invalid indices:\n"
|
||||
" min=%d max=%d, xx1=%ld xx2=%ld,\n"
|
||||
" x1min=%ld x1max=%ld, x2min=%ld x2max=%ld\n",
|
||||
idx_min, idx_max, xx1, xx2,
|
||||
warper->x1min, warper->x1max,
|
||||
warper->x2min, warper->x2max ));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
for ( nn = 0; nn < num_segments; nn++ )
|
||||
{
|
||||
FT_Pos len = segments[nn].max_coord - segments[nn].min_coord;
|
||||
FT_Pos y0 = FT_MulFix( segments[nn].pos, scale ) + delta;
|
||||
FT_Pos y = y0 + ( idx_min - idx0 );
|
||||
FT_Int idx;
|
||||
|
||||
|
||||
/* score the length of the segments for the given range */
|
||||
for ( idx = idx_min; idx <= idx_max; idx++, y++ )
|
||||
scores[idx] += af_warper_weights[y & 63] * len;
|
||||
}
|
||||
|
||||
/* find best score */
|
||||
{
|
||||
FT_Int idx;
|
||||
|
||||
|
||||
for ( idx = idx_min; idx <= idx_max; idx++ )
|
||||
{
|
||||
AF_WarpScore score = scores[idx];
|
||||
AF_WarpScore distort = base_distort + ( idx - idx0 );
|
||||
|
||||
|
||||
if ( score > warper->best_score ||
|
||||
( score == warper->best_score &&
|
||||
distort < warper->best_distort ) )
|
||||
{
|
||||
warper->best_score = score;
|
||||
warper->best_distort = distort;
|
||||
warper->best_scale = scale;
|
||||
warper->best_delta = delta + ( idx - idx0 );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Compute optimal scaling and delta values for a given glyph and */
|
||||
/* dimension. */
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
af_warper_compute( AF_Warper warper,
|
||||
AF_GlyphHints hints,
|
||||
AF_Dimension dim,
|
||||
FT_Fixed *a_scale,
|
||||
FT_Pos *a_delta )
|
||||
{
|
||||
AF_AxisHints axis;
|
||||
AF_Point points;
|
||||
|
||||
FT_Fixed org_scale;
|
||||
FT_Pos org_delta;
|
||||
|
||||
FT_UInt nn, num_points, num_segments;
|
||||
FT_Int X1, X2;
|
||||
FT_Int w;
|
||||
|
||||
AF_WarpScore base_distort;
|
||||
AF_Segment segments;
|
||||
|
||||
|
||||
/* get original scaling transformation */
|
||||
if ( dim == AF_DIMENSION_VERT )
|
||||
{
|
||||
org_scale = hints->y_scale;
|
||||
org_delta = hints->y_delta;
|
||||
}
|
||||
else
|
||||
{
|
||||
org_scale = hints->x_scale;
|
||||
org_delta = hints->x_delta;
|
||||
}
|
||||
|
||||
warper->best_scale = org_scale;
|
||||
warper->best_delta = org_delta;
|
||||
warper->best_score = INT_MIN;
|
||||
warper->best_distort = 0;
|
||||
|
||||
axis = &hints->axis[dim];
|
||||
segments = axis->segments;
|
||||
num_segments = axis->num_segments;
|
||||
points = hints->points;
|
||||
num_points = hints->num_points;
|
||||
|
||||
*a_scale = org_scale;
|
||||
*a_delta = org_delta;
|
||||
|
||||
/* get X1 and X2, minimum and maximum in original coordinates */
|
||||
if ( num_segments < 1 )
|
||||
return;
|
||||
|
||||
#if 1
|
||||
X1 = X2 = points[0].fx;
|
||||
for ( nn = 1; nn < num_points; nn++ )
|
||||
{
|
||||
FT_Int X = points[nn].fx;
|
||||
|
||||
|
||||
if ( X < X1 )
|
||||
X1 = X;
|
||||
if ( X > X2 )
|
||||
X2 = X;
|
||||
}
|
||||
#else
|
||||
X1 = X2 = segments[0].pos;
|
||||
for ( nn = 1; nn < num_segments; nn++ )
|
||||
{
|
||||
FT_Int X = segments[nn].pos;
|
||||
|
||||
|
||||
if ( X < X1 )
|
||||
X1 = X;
|
||||
if ( X > X2 )
|
||||
X2 = X;
|
||||
}
|
||||
#endif
|
||||
|
||||
if ( X1 >= X2 )
|
||||
return;
|
||||
|
||||
warper->x1 = FT_MulFix( X1, org_scale ) + org_delta;
|
||||
warper->x2 = FT_MulFix( X2, org_scale ) + org_delta;
|
||||
|
||||
warper->t1 = AF_WARPER_FLOOR( warper->x1 );
|
||||
warper->t2 = AF_WARPER_CEIL( warper->x2 );
|
||||
|
||||
/* examine a half pixel wide range around the maximum coordinates */
|
||||
warper->x1min = warper->x1 & ~31;
|
||||
warper->x1max = warper->x1min + 32;
|
||||
warper->x2min = warper->x2 & ~31;
|
||||
warper->x2max = warper->x2min + 32;
|
||||
|
||||
if ( warper->x1max > warper->x2 )
|
||||
warper->x1max = warper->x2;
|
||||
|
||||
if ( warper->x2min < warper->x1 )
|
||||
warper->x2min = warper->x1;
|
||||
|
||||
warper->w0 = warper->x2 - warper->x1;
|
||||
|
||||
if ( warper->w0 <= 64 )
|
||||
{
|
||||
warper->x1max = warper->x1;
|
||||
warper->x2min = warper->x2;
|
||||
}
|
||||
|
||||
/* examine (at most) a pixel wide range around the natural width */
|
||||
warper->wmin = warper->x2min - warper->x1max;
|
||||
warper->wmax = warper->x2max - warper->x1min;
|
||||
|
||||
#if 1
|
||||
/* some heuristics to reduce the number of widths to be examined */
|
||||
{
|
||||
int margin = 16;
|
||||
|
||||
|
||||
if ( warper->w0 <= 128 )
|
||||
{
|
||||
margin = 8;
|
||||
if ( warper->w0 <= 96 )
|
||||
margin = 4;
|
||||
}
|
||||
|
||||
if ( warper->wmin < warper->w0 - margin )
|
||||
warper->wmin = warper->w0 - margin;
|
||||
|
||||
if ( warper->wmax > warper->w0 + margin )
|
||||
warper->wmax = warper->w0 + margin;
|
||||
}
|
||||
|
||||
if ( warper->wmin < warper->w0 * 3 / 4 )
|
||||
warper->wmin = warper->w0 * 3 / 4;
|
||||
|
||||
if ( warper->wmax > warper->w0 * 5 / 4 )
|
||||
warper->wmax = warper->w0 * 5 / 4;
|
||||
#else
|
||||
/* no scaling, just translation */
|
||||
warper->wmin = warper->wmax = warper->w0;
|
||||
#endif
|
||||
|
||||
for ( w = warper->wmin; w <= warper->wmax; w++ )
|
||||
{
|
||||
FT_Fixed new_scale;
|
||||
FT_Pos new_delta;
|
||||
FT_Pos xx1, xx2;
|
||||
|
||||
|
||||
/* compute min and max positions for given width, */
|
||||
/* assuring that they stay within the coordinate ranges */
|
||||
xx1 = warper->x1;
|
||||
xx2 = warper->x2;
|
||||
if ( w >= warper->w0 )
|
||||
{
|
||||
xx1 -= w - warper->w0;
|
||||
if ( xx1 < warper->x1min )
|
||||
{
|
||||
xx2 += warper->x1min - xx1;
|
||||
xx1 = warper->x1min;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
xx1 -= w - warper->w0;
|
||||
if ( xx1 > warper->x1max )
|
||||
{
|
||||
xx2 -= xx1 - warper->x1max;
|
||||
xx1 = warper->x1max;
|
||||
}
|
||||
}
|
||||
|
||||
if ( xx1 < warper->x1 )
|
||||
base_distort = warper->x1 - xx1;
|
||||
else
|
||||
base_distort = xx1 - warper->x1;
|
||||
|
||||
if ( xx2 < warper->x2 )
|
||||
base_distort += warper->x2 - xx2;
|
||||
else
|
||||
base_distort += xx2 - warper->x2;
|
||||
|
||||
/* give base distortion a greater weight while scoring */
|
||||
base_distort *= 10;
|
||||
|
||||
new_scale = org_scale + FT_DivFix( w - warper->w0, X2 - X1 );
|
||||
new_delta = xx1 - FT_MulFix( X1, new_scale );
|
||||
|
||||
af_warper_compute_line_best( warper, new_scale, new_delta, xx1, xx2,
|
||||
base_distort,
|
||||
segments, num_segments );
|
||||
}
|
||||
|
||||
{
|
||||
FT_Fixed best_scale = warper->best_scale;
|
||||
FT_Pos best_delta = warper->best_delta;
|
||||
|
||||
|
||||
hints->xmin_delta = FT_MulFix( X1, best_scale - org_scale )
|
||||
+ best_delta;
|
||||
hints->xmax_delta = FT_MulFix( X2, best_scale - org_scale )
|
||||
+ best_delta;
|
||||
|
||||
*a_scale = best_scale;
|
||||
*a_delta = best_delta;
|
||||
}
|
||||
}
|
||||
|
||||
#else /* !AF_CONFIG_OPTION_USE_WARPER */
|
||||
|
||||
/* ANSI C doesn't like empty source files */
|
||||
typedef int _af_warp_dummy;
|
||||
|
||||
#endif /* !AF_CONFIG_OPTION_USE_WARPER */
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,64 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* afwarp.h */
|
||||
/* */
|
||||
/* Auto-fitter warping algorithm (specification). */
|
||||
/* */
|
||||
/* Copyright 2006, 2007 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __AFWARP_H__
|
||||
#define __AFWARP_H__
|
||||
|
||||
#include "afhints.h"
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
#define AF_WARPER_SCALE
|
||||
|
||||
#define AF_WARPER_FLOOR( x ) ( (x) & ~63 )
|
||||
#define AF_WARPER_CEIL( x ) AF_WARPER_FLOOR( (x) + 63 )
|
||||
|
||||
|
||||
typedef FT_Int32 AF_WarpScore;
|
||||
|
||||
typedef struct AF_WarperRec_
|
||||
{
|
||||
FT_Pos x1, x2;
|
||||
FT_Pos t1, t2;
|
||||
FT_Pos x1min, x1max;
|
||||
FT_Pos x2min, x2max;
|
||||
FT_Pos w0, wmin, wmax;
|
||||
|
||||
FT_Fixed best_scale;
|
||||
FT_Pos best_delta;
|
||||
AF_WarpScore best_score;
|
||||
AF_WarpScore best_distort;
|
||||
|
||||
} AF_WarperRec, *AF_Warper;
|
||||
|
||||
|
||||
FT_LOCAL( void )
|
||||
af_warper_compute( AF_Warper warper,
|
||||
AF_GlyphHints hints,
|
||||
AF_Dimension dim,
|
||||
FT_Fixed *a_scale,
|
||||
FT_Fixed *a_delta );
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
|
||||
#endif /* __AFWARP_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,41 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* autofit.c */
|
||||
/* */
|
||||
/* Auto-fitter module (body). */
|
||||
/* */
|
||||
/* Copyright 2003-2007, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#define FT_MAKE_OPTION_SINGLE_OBJECT
|
||||
#include <ft2build.h>
|
||||
#include "afpic.c"
|
||||
#include "afangles.c"
|
||||
#include "afglobal.c"
|
||||
#include "afhints.c"
|
||||
|
||||
#include "afdummy.c"
|
||||
#include "aflatin.c"
|
||||
#ifdef FT_OPTION_AUTOFIT2
|
||||
#include "aflatin2.c"
|
||||
#endif
|
||||
#include "afcjk.c"
|
||||
#include "afindic.c"
|
||||
|
||||
#include "afloader.c"
|
||||
#include "afmodule.c"
|
||||
|
||||
#ifdef AF_CONFIG_OPTION_USE_WARPER
|
||||
#include "afwarp.c"
|
||||
#endif
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,23 @@
|
||||
#
|
||||
# FreeType 2 auto-fitter module definition
|
||||
#
|
||||
|
||||
|
||||
# Copyright 2003, 2004, 2005, 2006 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.
|
||||
|
||||
|
||||
FTMODULE_H_COMMANDS += AUTOFIT_MODULE
|
||||
|
||||
define AUTOFIT_MODULE
|
||||
$(OPEN_DRIVER) FT_Module_Class, autofit_module_class $(CLOSE_DRIVER)
|
||||
$(ECHO_DRIVER)autofit $(ECHO_DRIVER_DESC)automatic hinting module$(ECHO_DRIVER_DONE)
|
||||
endef
|
||||
|
||||
# EOF
|
||||
@@ -0,0 +1,79 @@
|
||||
#
|
||||
# FreeType 2 auto-fitter module configuration rules
|
||||
#
|
||||
|
||||
|
||||
# Copyright 2003, 2004, 2005, 2006, 2007, 2011 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.
|
||||
|
||||
|
||||
# AUTOF driver directory
|
||||
#
|
||||
AUTOF_DIR := $(SRC_DIR)/autofit
|
||||
|
||||
|
||||
# compilation flags for the driver
|
||||
#
|
||||
AUTOF_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(AUTOF_DIR))
|
||||
|
||||
|
||||
# AUTOF driver sources (i.e., C files)
|
||||
#
|
||||
AUTOF_DRV_SRC := $(AUTOF_DIR)/afangles.c \
|
||||
$(AUTOF_DIR)/afcjk.c \
|
||||
$(AUTOF_DIR)/afdummy.c \
|
||||
$(AUTOF_DIR)/afglobal.c \
|
||||
$(AUTOF_DIR)/afhints.c \
|
||||
$(AUTOF_DIR)/afindic.c \
|
||||
$(AUTOF_DIR)/aflatin.c \
|
||||
$(AUTOF_DIR)/afloader.c \
|
||||
$(AUTOF_DIR)/afmodule.c \
|
||||
$(AUTOF_DIR)/afpic.c \
|
||||
$(AUTOF_DIR)/afwarp.c
|
||||
|
||||
# AUTOF driver headers
|
||||
#
|
||||
AUTOF_DRV_H := $(AUTOF_DRV_SRC:%c=%h) \
|
||||
$(AUTOF_DIR)/aferrors.h \
|
||||
$(AUTOF_DIR)/aftypes.h
|
||||
|
||||
|
||||
# AUTOF driver object(s)
|
||||
#
|
||||
# AUTOF_DRV_OBJ_M is used during `multi' builds.
|
||||
# AUTOF_DRV_OBJ_S is used during `single' builds.
|
||||
#
|
||||
AUTOF_DRV_OBJ_M := $(AUTOF_DRV_SRC:$(AUTOF_DIR)/%.c=$(OBJ_DIR)/%.$O)
|
||||
AUTOF_DRV_OBJ_S := $(OBJ_DIR)/autofit.$O
|
||||
|
||||
# AUTOF driver source file for single build
|
||||
#
|
||||
AUTOF_DRV_SRC_S := $(AUTOF_DIR)/autofit.c
|
||||
|
||||
|
||||
# AUTOF driver - single object
|
||||
#
|
||||
$(AUTOF_DRV_OBJ_S): $(AUTOF_DRV_SRC_S) $(AUTOF_DRV_SRC) \
|
||||
$(FREETYPE_H) $(AUTOF_DRV_H)
|
||||
$(AUTOF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(AUTOF_DRV_SRC_S))
|
||||
|
||||
|
||||
# AUTOF driver - multiple objects
|
||||
#
|
||||
$(OBJ_DIR)/%.$O: $(AUTOF_DIR)/%.c $(FREETYPE_H) $(AUTOF_DRV_H)
|
||||
$(AUTOF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
|
||||
|
||||
|
||||
# update main driver object lists
|
||||
#
|
||||
DRV_OBJS_S += $(AUTOF_DRV_OBJ_S)
|
||||
DRV_OBJS_M += $(AUTOF_DRV_OBJ_M)
|
||||
|
||||
|
||||
# EOF
|
||||
@@ -0,0 +1,60 @@
|
||||
# FreeType 2 src/base Jamfile
|
||||
#
|
||||
# Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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.
|
||||
|
||||
SubDir FT2_TOP $(FT2_SRC_DIR) base ;
|
||||
|
||||
|
||||
{
|
||||
local _sources ;
|
||||
|
||||
if $(FT2_MULTI)
|
||||
{
|
||||
_sources = ftadvanc ftcalc ftdbgmem ftgloadr
|
||||
ftobjs ftoutln ftrfork ftsnames
|
||||
ftstream fttrigon ftutil
|
||||
basepic ftpic
|
||||
;
|
||||
}
|
||||
else
|
||||
{
|
||||
_sources = ftbase ;
|
||||
}
|
||||
|
||||
Library $(FT2_LIB) : $(_sources).c ;
|
||||
}
|
||||
|
||||
# Add the optional/replaceable files.
|
||||
#
|
||||
{
|
||||
local _sources = bbox bdf bitmap debug gasp
|
||||
glyph gxval init lcdfil mm
|
||||
otval pfr stroke synth system
|
||||
type1 winfnt xf86 patent
|
||||
;
|
||||
|
||||
Library $(FT2_LIB) : ft$(_sources).c ;
|
||||
}
|
||||
|
||||
# Add Macintosh-specific file to the library when necessary.
|
||||
#
|
||||
if $(MAC)
|
||||
{
|
||||
Library $(FT2_LIB) : ftmac.c ;
|
||||
}
|
||||
else if $(OS) = MACOSX
|
||||
{
|
||||
if $(FT2_MULTI)
|
||||
{
|
||||
Library $(FT2_LIB) : ftmac.c ;
|
||||
}
|
||||
}
|
||||
|
||||
# end of src/base Jamfile
|
||||
@@ -0,0 +1,83 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* basepic.c */
|
||||
/* */
|
||||
/* The FreeType position independent code services for base. */
|
||||
/* */
|
||||
/* Copyright 2009 by */
|
||||
/* Oran Agra and Mickey Gabel. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include "basepic.h"
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_PIC
|
||||
|
||||
/* forward declaration of PIC init functions from ftglyph.c */
|
||||
void FT_Init_Class_ft_outline_glyph_class(FT_Glyph_Class*);
|
||||
void FT_Init_Class_ft_bitmap_glyph_class(FT_Glyph_Class*);
|
||||
|
||||
/* forward declaration of PIC init functions from ftinit.c */
|
||||
FT_Error ft_create_default_module_classes(FT_Library);
|
||||
void ft_destroy_default_module_classes(FT_Library);
|
||||
|
||||
void
|
||||
ft_base_pic_free( FT_Library library )
|
||||
{
|
||||
FT_PIC_Container* pic_container = &library->pic_container;
|
||||
FT_Memory memory = library->memory;
|
||||
if ( pic_container->base )
|
||||
{
|
||||
/* Destroy default module classes (in case FT_Add_Default_Modules was used) */
|
||||
ft_destroy_default_module_classes( library );
|
||||
|
||||
FT_FREE( pic_container->base );
|
||||
pic_container->base = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_Error
|
||||
ft_base_pic_init( FT_Library library )
|
||||
{
|
||||
FT_PIC_Container* pic_container = &library->pic_container;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
BasePIC* container;
|
||||
FT_Memory memory = library->memory;
|
||||
|
||||
/* allocate pointer, clear and set global container pointer */
|
||||
if ( FT_ALLOC ( container, sizeof ( *container ) ) )
|
||||
return error;
|
||||
FT_MEM_SET( container, 0, sizeof(*container) );
|
||||
pic_container->base = container;
|
||||
|
||||
/* initialize default modules list and pointers */
|
||||
error = ft_create_default_module_classes( library );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
/* initialize pointer table - this is how the module usually expects this data */
|
||||
FT_Init_Class_ft_outline_glyph_class(&container->ft_outline_glyph_class);
|
||||
FT_Init_Class_ft_bitmap_glyph_class(&container->ft_bitmap_glyph_class);
|
||||
|
||||
Exit:
|
||||
if(error)
|
||||
ft_base_pic_free(library);
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,62 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* basepic.h */
|
||||
/* */
|
||||
/* The FreeType position independent code services for base. */
|
||||
/* */
|
||||
/* Copyright 2009 by */
|
||||
/* Oran Agra and Mickey Gabel. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __BASEPIC_H__
|
||||
#define __BASEPIC_H__
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
#include FT_INTERNAL_PIC_H
|
||||
|
||||
#ifndef FT_CONFIG_OPTION_PIC
|
||||
#define FT_OUTLINE_GLYPH_CLASS_GET &ft_outline_glyph_class
|
||||
#define FT_BITMAP_GLYPH_CLASS_GET &ft_bitmap_glyph_class
|
||||
#define FT_DEFAULT_MODULES_GET ft_default_modules
|
||||
|
||||
#else /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
#include FT_GLYPH_H
|
||||
|
||||
typedef struct BasePIC_
|
||||
{
|
||||
FT_Module_Class** default_module_classes;
|
||||
FT_Glyph_Class ft_outline_glyph_class;
|
||||
FT_Glyph_Class ft_bitmap_glyph_class;
|
||||
} BasePIC;
|
||||
|
||||
#define GET_PIC(lib) ((BasePIC*)((lib)->pic_container.base))
|
||||
#define FT_OUTLINE_GLYPH_CLASS_GET (&GET_PIC(library)->ft_outline_glyph_class)
|
||||
#define FT_BITMAP_GLYPH_CLASS_GET (&GET_PIC(library)->ft_bitmap_glyph_class)
|
||||
#define FT_DEFAULT_MODULES_GET (GET_PIC(library)->default_module_classes)
|
||||
|
||||
void
|
||||
ft_base_pic_free( FT_Library library );
|
||||
|
||||
FT_Error
|
||||
ft_base_pic_init( FT_Library library );
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_PIC */
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __BASEPIC_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,163 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftadvanc.c */
|
||||
/* */
|
||||
/* Quick computation of advance widths (body). */
|
||||
/* */
|
||||
/* Copyright 2008, 2009 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_ADVANCES_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
|
||||
static FT_Error
|
||||
_ft_face_scale_advances( FT_Face face,
|
||||
FT_Fixed* advances,
|
||||
FT_UInt count,
|
||||
FT_Int32 flags )
|
||||
{
|
||||
FT_Fixed scale;
|
||||
FT_UInt nn;
|
||||
|
||||
|
||||
if ( flags & FT_LOAD_NO_SCALE )
|
||||
return FT_Err_Ok;
|
||||
|
||||
if ( face->size == NULL )
|
||||
return FT_Err_Invalid_Size_Handle;
|
||||
|
||||
if ( flags & FT_LOAD_VERTICAL_LAYOUT )
|
||||
scale = face->size->metrics.y_scale;
|
||||
else
|
||||
scale = face->size->metrics.x_scale;
|
||||
|
||||
/* this must be the same scaling as to get linear{Hori,Vert}Advance */
|
||||
/* (see `FT_Load_Glyph' implementation in src/base/ftobjs.c) */
|
||||
|
||||
for ( nn = 0; nn < count; nn++ )
|
||||
advances[nn] = FT_MulDiv( advances[nn], scale, 64 );
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* at the moment, we can perform fast advance retrieval only in */
|
||||
/* the following cases: */
|
||||
/* */
|
||||
/* - unscaled load */
|
||||
/* - unhinted load */
|
||||
/* - light-hinted load */
|
||||
|
||||
#define LOAD_ADVANCE_FAST_CHECK( flags ) \
|
||||
( flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING ) || \
|
||||
FT_LOAD_TARGET_MODE( flags ) == FT_RENDER_MODE_LIGHT )
|
||||
|
||||
|
||||
/* documentation is in ftadvanc.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_Advance( FT_Face face,
|
||||
FT_UInt gindex,
|
||||
FT_Int32 flags,
|
||||
FT_Fixed *padvance )
|
||||
{
|
||||
FT_Face_GetAdvancesFunc func;
|
||||
|
||||
|
||||
if ( !face )
|
||||
return FT_Err_Invalid_Face_Handle;
|
||||
|
||||
if ( gindex >= (FT_UInt)face->num_glyphs )
|
||||
return FT_Err_Invalid_Glyph_Index;
|
||||
|
||||
func = face->driver->clazz->get_advances;
|
||||
if ( func && LOAD_ADVANCE_FAST_CHECK( flags ) )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
error = func( face, gindex, 1, flags, padvance );
|
||||
if ( !error )
|
||||
return _ft_face_scale_advances( face, padvance, 1, flags );
|
||||
|
||||
if ( error != FT_ERROR_BASE( FT_Err_Unimplemented_Feature ) )
|
||||
return error;
|
||||
}
|
||||
|
||||
return FT_Get_Advances( face, gindex, 1, flags, padvance );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftadvanc.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_Advances( FT_Face face,
|
||||
FT_UInt start,
|
||||
FT_UInt count,
|
||||
FT_Int32 flags,
|
||||
FT_Fixed *padvances )
|
||||
{
|
||||
FT_Face_GetAdvancesFunc func;
|
||||
FT_UInt num, end, nn;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
|
||||
|
||||
if ( !face )
|
||||
return FT_Err_Invalid_Face_Handle;
|
||||
|
||||
num = (FT_UInt)face->num_glyphs;
|
||||
end = start + count;
|
||||
if ( start >= num || end < start || end > num )
|
||||
return FT_Err_Invalid_Glyph_Index;
|
||||
|
||||
if ( count == 0 )
|
||||
return FT_Err_Ok;
|
||||
|
||||
func = face->driver->clazz->get_advances;
|
||||
if ( func && LOAD_ADVANCE_FAST_CHECK( flags ) )
|
||||
{
|
||||
error = func( face, start, count, flags, padvances );
|
||||
if ( !error )
|
||||
goto Exit;
|
||||
|
||||
if ( error != FT_ERROR_BASE( FT_Err_Unimplemented_Feature ) )
|
||||
return error;
|
||||
}
|
||||
|
||||
error = FT_Err_Ok;
|
||||
|
||||
if ( flags & FT_ADVANCE_FLAG_FAST_ONLY )
|
||||
return FT_Err_Unimplemented_Feature;
|
||||
|
||||
flags |= (FT_UInt32)FT_LOAD_ADVANCE_ONLY;
|
||||
for ( nn = 0; nn < count; nn++ )
|
||||
{
|
||||
error = FT_Load_Glyph( face, start + nn, flags );
|
||||
if ( error )
|
||||
break;
|
||||
|
||||
padvances[nn] = ( flags & FT_LOAD_VERTICAL_LAYOUT )
|
||||
? face->glyph->advance.y
|
||||
: face->glyph->advance.x;
|
||||
}
|
||||
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
Exit:
|
||||
return _ft_face_scale_advances( face, padvances, count, flags );
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,121 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftapi.c */
|
||||
/* */
|
||||
/* The FreeType compatibility functions (body). */
|
||||
/* */
|
||||
/* Copyright 2002 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_LIST_H
|
||||
#include FT_OUTLINE_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_TRUETYPE_TABLES_H
|
||||
#include FT_OUTLINE_H
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** ****/
|
||||
/**** C O M P A T I B I L I T Y ****/
|
||||
/**** ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/* backwards compatibility API */
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_New_Memory_Stream( FT_Library library,
|
||||
FT_Byte* base,
|
||||
FT_ULong size,
|
||||
FT_Stream stream )
|
||||
{
|
||||
FT_UNUSED( library );
|
||||
|
||||
FT_Stream_OpenMemory( stream, base, size );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Seek_Stream( FT_Stream stream,
|
||||
FT_ULong pos )
|
||||
{
|
||||
return FT_Stream_Seek( stream, pos );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Skip_Stream( FT_Stream stream,
|
||||
FT_Long distance )
|
||||
{
|
||||
return FT_Stream_Skip( stream, distance );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Read_Stream( FT_Stream stream,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
return FT_Stream_Read( stream, buffer, count );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Read_Stream_At( FT_Stream stream,
|
||||
FT_ULong pos,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
return FT_Stream_ReadAt( stream, pos, buffer, count );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Extract_Frame( FT_Stream stream,
|
||||
FT_ULong count,
|
||||
FT_Byte** pbytes )
|
||||
{
|
||||
return FT_Stream_ExtractFrame( stream, count, pbytes );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Release_Frame( FT_Stream stream,
|
||||
FT_Byte** pbytes )
|
||||
{
|
||||
FT_Stream_ReleaseFrame( stream, pbytes );
|
||||
}
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Access_Frame( FT_Stream stream,
|
||||
FT_ULong count )
|
||||
{
|
||||
return FT_Stream_EnterFrame( stream, count );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Forget_Frame( FT_Stream stream )
|
||||
{
|
||||
FT_Stream_ExitFrame( stream );
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,41 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftbase.c */
|
||||
/* */
|
||||
/* Single object library component (body only). */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
|
||||
#define FT_MAKE_OPTION_SINGLE_OBJECT
|
||||
|
||||
#include "ftpic.c"
|
||||
#include "basepic.c"
|
||||
#include "ftadvanc.c"
|
||||
#include "ftcalc.c"
|
||||
#include "ftdbgmem.c"
|
||||
#include "ftgloadr.c"
|
||||
#include "ftobjs.c"
|
||||
#include "ftoutln.c"
|
||||
#include "ftrfork.c"
|
||||
#include "ftsnames.c"
|
||||
#include "ftstream.c"
|
||||
#include "fttrigon.c"
|
||||
#include "ftutil.c"
|
||||
|
||||
#if defined( FT_MACINTOSH ) && !defined ( DARWIN_NO_CARBON )
|
||||
#include "ftmac.c"
|
||||
#endif
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,68 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftbase.h */
|
||||
/* */
|
||||
/* The FreeType private functions used in base module (specification). */
|
||||
/* */
|
||||
/* Copyright 2008, 2010 by */
|
||||
/* David Turner, Robert Wilhelm, Werner Lemberg, and suzuki toshiya. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __FTBASE_H__
|
||||
#define __FTBASE_H__
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/* Assume the stream is sfnt-wrapped PS Type1 or sfnt-wrapped CID-keyed */
|
||||
/* font, and try to load a face specified by the face_index. */
|
||||
FT_LOCAL( FT_Error )
|
||||
open_face_PS_from_sfnt_stream( FT_Library library,
|
||||
FT_Stream stream,
|
||||
FT_Long face_index,
|
||||
FT_Int num_params,
|
||||
FT_Parameter *params,
|
||||
FT_Face *aface );
|
||||
|
||||
|
||||
/* Create a new FT_Face given a buffer and a driver name. */
|
||||
/* From ftmac.c. */
|
||||
FT_LOCAL( FT_Error )
|
||||
open_face_from_buffer( FT_Library library,
|
||||
FT_Byte* base,
|
||||
FT_ULong size,
|
||||
FT_Long face_index,
|
||||
const char* driver_name,
|
||||
FT_Face *aface );
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK
|
||||
/* Mac OS X/Darwin kernel often changes recommended method to access */
|
||||
/* the resource fork and older methods makes the kernel issue the */
|
||||
/* warning of deprecated method. To calm it down, the methods based */
|
||||
/* on Darwin VFS should be grouped and skip the rest methods after */
|
||||
/* the case the resource is opened but found to lack a font in it. */
|
||||
FT_LOCAL( FT_Bool )
|
||||
raccess_rule_by_darwin_vfs( FT_UInt rule_index );
|
||||
#endif /* FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __FTBASE_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,662 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftbbox.c */
|
||||
/* */
|
||||
/* FreeType bbox computation (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2002, 2004, 2006, 2010 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 component has a _single_ role: to compute exact outline bounding */
|
||||
/* boxes. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_BBOX_H
|
||||
#include FT_IMAGE_H
|
||||
#include FT_OUTLINE_H
|
||||
#include FT_INTERNAL_CALC_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
|
||||
typedef struct TBBox_Rec_
|
||||
{
|
||||
FT_Vector last;
|
||||
FT_BBox bbox;
|
||||
|
||||
} TBBox_Rec;
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* BBox_Move_To */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* This function is used as a `move_to' and `line_to' emitter during */
|
||||
/* FT_Outline_Decompose(). It simply records the destination point */
|
||||
/* in `user->last'; no further computations are necessary since we */
|
||||
/* use the cbox as the starting bbox which must be refined. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* to :: A pointer to the destination vector. */
|
||||
/* */
|
||||
/* <InOut> */
|
||||
/* user :: A pointer to the current walk context. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Always 0. Needed for the interface only. */
|
||||
/* */
|
||||
static int
|
||||
BBox_Move_To( FT_Vector* to,
|
||||
TBBox_Rec* user )
|
||||
{
|
||||
user->last = *to;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#define CHECK_X( p, bbox ) \
|
||||
( p->x < bbox.xMin || p->x > bbox.xMax )
|
||||
|
||||
#define CHECK_Y( p, bbox ) \
|
||||
( p->y < bbox.yMin || p->y > bbox.yMax )
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* BBox_Conic_Check */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* Finds the extrema of a 1-dimensional conic Bezier curve and update */
|
||||
/* a bounding range. This version uses direct computation, as it */
|
||||
/* doesn't need square roots. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* y1 :: The start coordinate. */
|
||||
/* */
|
||||
/* y2 :: The coordinate of the control point. */
|
||||
/* */
|
||||
/* y3 :: The end coordinate. */
|
||||
/* */
|
||||
/* <InOut> */
|
||||
/* min :: The address of the current minimum. */
|
||||
/* */
|
||||
/* max :: The address of the current maximum. */
|
||||
/* */
|
||||
static void
|
||||
BBox_Conic_Check( FT_Pos y1,
|
||||
FT_Pos y2,
|
||||
FT_Pos y3,
|
||||
FT_Pos* min,
|
||||
FT_Pos* max )
|
||||
{
|
||||
if ( y1 <= y3 && y2 == y1 ) /* flat arc */
|
||||
goto Suite;
|
||||
|
||||
if ( y1 < y3 )
|
||||
{
|
||||
if ( y2 >= y1 && y2 <= y3 ) /* ascending arc */
|
||||
goto Suite;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( y2 >= y3 && y2 <= y1 ) /* descending arc */
|
||||
{
|
||||
y2 = y1;
|
||||
y1 = y3;
|
||||
y3 = y2;
|
||||
goto Suite;
|
||||
}
|
||||
}
|
||||
|
||||
y1 = y3 = y1 - FT_MulDiv( y2 - y1, y2 - y1, y1 - 2*y2 + y3 );
|
||||
|
||||
Suite:
|
||||
if ( y1 < *min ) *min = y1;
|
||||
if ( y3 > *max ) *max = y3;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* BBox_Conic_To */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* This function is used as a `conic_to' emitter during */
|
||||
/* FT_Outline_Decompose(). It checks a conic Bezier curve with the */
|
||||
/* current bounding box, and computes its extrema if necessary to */
|
||||
/* update it. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* control :: A pointer to a control point. */
|
||||
/* */
|
||||
/* to :: A pointer to the destination vector. */
|
||||
/* */
|
||||
/* <InOut> */
|
||||
/* user :: The address of the current walk context. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Always 0. Needed for the interface only. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* In the case of a non-monotonous arc, we compute directly the */
|
||||
/* extremum coordinates, as it is sufficiently fast. */
|
||||
/* */
|
||||
static int
|
||||
BBox_Conic_To( FT_Vector* control,
|
||||
FT_Vector* to,
|
||||
TBBox_Rec* user )
|
||||
{
|
||||
/* we don't need to check `to' since it is always an `on' point, thus */
|
||||
/* within the bbox */
|
||||
|
||||
if ( CHECK_X( control, user->bbox ) )
|
||||
BBox_Conic_Check( user->last.x,
|
||||
control->x,
|
||||
to->x,
|
||||
&user->bbox.xMin,
|
||||
&user->bbox.xMax );
|
||||
|
||||
if ( CHECK_Y( control, user->bbox ) )
|
||||
BBox_Conic_Check( user->last.y,
|
||||
control->y,
|
||||
to->y,
|
||||
&user->bbox.yMin,
|
||||
&user->bbox.yMax );
|
||||
|
||||
user->last = *to;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* BBox_Cubic_Check */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* Finds the extrema of a 1-dimensional cubic Bezier curve and */
|
||||
/* updates a bounding range. This version uses splitting because we */
|
||||
/* don't want to use square roots and extra accuracy. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* p1 :: The start coordinate. */
|
||||
/* */
|
||||
/* p2 :: The coordinate of the first control point. */
|
||||
/* */
|
||||
/* p3 :: The coordinate of the second control point. */
|
||||
/* */
|
||||
/* p4 :: The end coordinate. */
|
||||
/* */
|
||||
/* <InOut> */
|
||||
/* min :: The address of the current minimum. */
|
||||
/* */
|
||||
/* max :: The address of the current maximum. */
|
||||
/* */
|
||||
|
||||
#if 0
|
||||
|
||||
static void
|
||||
BBox_Cubic_Check( FT_Pos p1,
|
||||
FT_Pos p2,
|
||||
FT_Pos p3,
|
||||
FT_Pos p4,
|
||||
FT_Pos* min,
|
||||
FT_Pos* max )
|
||||
{
|
||||
FT_Pos stack[32*3 + 1], *arc;
|
||||
|
||||
|
||||
arc = stack;
|
||||
|
||||
arc[0] = p1;
|
||||
arc[1] = p2;
|
||||
arc[2] = p3;
|
||||
arc[3] = p4;
|
||||
|
||||
do
|
||||
{
|
||||
FT_Pos y1 = arc[0];
|
||||
FT_Pos y2 = arc[1];
|
||||
FT_Pos y3 = arc[2];
|
||||
FT_Pos y4 = arc[3];
|
||||
|
||||
|
||||
if ( y1 == y4 )
|
||||
{
|
||||
if ( y1 == y2 && y1 == y3 ) /* flat */
|
||||
goto Test;
|
||||
}
|
||||
else if ( y1 < y4 )
|
||||
{
|
||||
if ( y2 >= y1 && y2 <= y4 && y3 >= y1 && y3 <= y4 ) /* ascending */
|
||||
goto Test;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( y2 >= y4 && y2 <= y1 && y3 >= y4 && y3 <= y1 ) /* descending */
|
||||
{
|
||||
y2 = y1;
|
||||
y1 = y4;
|
||||
y4 = y2;
|
||||
goto Test;
|
||||
}
|
||||
}
|
||||
|
||||
/* unknown direction -- split the arc in two */
|
||||
arc[6] = y4;
|
||||
arc[1] = y1 = ( y1 + y2 ) / 2;
|
||||
arc[5] = y4 = ( y4 + y3 ) / 2;
|
||||
y2 = ( y2 + y3 ) / 2;
|
||||
arc[2] = y1 = ( y1 + y2 ) / 2;
|
||||
arc[4] = y4 = ( y4 + y2 ) / 2;
|
||||
arc[3] = ( y1 + y4 ) / 2;
|
||||
|
||||
arc += 3;
|
||||
goto Suite;
|
||||
|
||||
Test:
|
||||
if ( y1 < *min ) *min = y1;
|
||||
if ( y4 > *max ) *max = y4;
|
||||
arc -= 3;
|
||||
|
||||
Suite:
|
||||
;
|
||||
} while ( arc >= stack );
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void
|
||||
test_cubic_extrema( FT_Pos y1,
|
||||
FT_Pos y2,
|
||||
FT_Pos y3,
|
||||
FT_Pos y4,
|
||||
FT_Fixed u,
|
||||
FT_Pos* min,
|
||||
FT_Pos* max )
|
||||
{
|
||||
/* FT_Pos a = y4 - 3*y3 + 3*y2 - y1; */
|
||||
FT_Pos b = y3 - 2*y2 + y1;
|
||||
FT_Pos c = y2 - y1;
|
||||
FT_Pos d = y1;
|
||||
FT_Pos y;
|
||||
FT_Fixed uu;
|
||||
|
||||
FT_UNUSED ( y4 );
|
||||
|
||||
|
||||
/* The polynomial is */
|
||||
/* */
|
||||
/* P(x) = a*x^3 + 3b*x^2 + 3c*x + d , */
|
||||
/* */
|
||||
/* dP/dx = 3a*x^2 + 6b*x + 3c . */
|
||||
/* */
|
||||
/* However, we also have */
|
||||
/* */
|
||||
/* dP/dx(u) = 0 , */
|
||||
/* */
|
||||
/* which implies by subtraction that */
|
||||
/* */
|
||||
/* P(u) = b*u^2 + 2c*u + d . */
|
||||
|
||||
if ( u > 0 && u < 0x10000L )
|
||||
{
|
||||
uu = FT_MulFix( u, u );
|
||||
y = d + FT_MulFix( c, 2*u ) + FT_MulFix( b, uu );
|
||||
|
||||
if ( y < *min ) *min = y;
|
||||
if ( y > *max ) *max = y;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
BBox_Cubic_Check( FT_Pos y1,
|
||||
FT_Pos y2,
|
||||
FT_Pos y3,
|
||||
FT_Pos y4,
|
||||
FT_Pos* min,
|
||||
FT_Pos* max )
|
||||
{
|
||||
/* always compare first and last points */
|
||||
if ( y1 < *min ) *min = y1;
|
||||
else if ( y1 > *max ) *max = y1;
|
||||
|
||||
if ( y4 < *min ) *min = y4;
|
||||
else if ( y4 > *max ) *max = y4;
|
||||
|
||||
/* now, try to see if there are split points here */
|
||||
if ( y1 <= y4 )
|
||||
{
|
||||
/* flat or ascending arc test */
|
||||
if ( y1 <= y2 && y2 <= y4 && y1 <= y3 && y3 <= y4 )
|
||||
return;
|
||||
}
|
||||
else /* y1 > y4 */
|
||||
{
|
||||
/* descending arc test */
|
||||
if ( y1 >= y2 && y2 >= y4 && y1 >= y3 && y3 >= y4 )
|
||||
return;
|
||||
}
|
||||
|
||||
/* There are some split points. Find them. */
|
||||
{
|
||||
FT_Pos a = y4 - 3*y3 + 3*y2 - y1;
|
||||
FT_Pos b = y3 - 2*y2 + y1;
|
||||
FT_Pos c = y2 - y1;
|
||||
FT_Pos d;
|
||||
FT_Fixed t;
|
||||
|
||||
|
||||
/* We need to solve `ax^2+2bx+c' here, without floating points! */
|
||||
/* The trick is to normalize to a different representation in order */
|
||||
/* to use our 16.16 fixed point routines. */
|
||||
/* */
|
||||
/* We compute FT_MulFix(b,b) and FT_MulFix(a,c) after normalization. */
|
||||
/* These values must fit into a single 16.16 value. */
|
||||
/* */
|
||||
/* We normalize a, b, and c to `8.16' fixed float values to ensure */
|
||||
/* that its product is held in a `16.16' value. */
|
||||
|
||||
{
|
||||
FT_ULong t1, t2;
|
||||
int shift = 0;
|
||||
|
||||
|
||||
/* The following computation is based on the fact that for */
|
||||
/* any value `y', if `n' is the position of the most */
|
||||
/* significant bit of `abs(y)' (starting from 0 for the */
|
||||
/* least significant bit), then `y' is in the range */
|
||||
/* */
|
||||
/* -2^n..2^n-1 */
|
||||
/* */
|
||||
/* We want to shift `a', `b', and `c' concurrently in order */
|
||||
/* to ensure that they all fit in 8.16 values, which maps */
|
||||
/* to the integer range `-2^23..2^23-1'. */
|
||||
/* */
|
||||
/* Necessarily, we need to shift `a', `b', and `c' so that */
|
||||
/* the most significant bit of its absolute values is at */
|
||||
/* _most_ at position 23. */
|
||||
/* */
|
||||
/* We begin by computing `t1' as the bitwise `OR' of the */
|
||||
/* absolute values of `a', `b', `c'. */
|
||||
|
||||
t1 = (FT_ULong)( ( a >= 0 ) ? a : -a );
|
||||
t2 = (FT_ULong)( ( b >= 0 ) ? b : -b );
|
||||
t1 |= t2;
|
||||
t2 = (FT_ULong)( ( c >= 0 ) ? c : -c );
|
||||
t1 |= t2;
|
||||
|
||||
/* Now we can be sure that the most significant bit of `t1' */
|
||||
/* is the most significant bit of either `a', `b', or `c', */
|
||||
/* depending on the greatest integer range of the particular */
|
||||
/* variable. */
|
||||
/* */
|
||||
/* Next, we compute the `shift', by shifting `t1' as many */
|
||||
/* times as necessary to move its MSB to position 23. This */
|
||||
/* corresponds to a value of `t1' that is in the range */
|
||||
/* 0x40_0000..0x7F_FFFF. */
|
||||
/* */
|
||||
/* Finally, we shift `a', `b', and `c' by the same amount. */
|
||||
/* This ensures that all values are now in the range */
|
||||
/* -2^23..2^23, i.e., they are now expressed as 8.16 */
|
||||
/* fixed-float numbers. This also means that we are using */
|
||||
/* 24 bits of precision to compute the zeros, independently */
|
||||
/* of the range of the original polynomial coefficients. */
|
||||
/* */
|
||||
/* This algorithm should ensure reasonably accurate values */
|
||||
/* for the zeros. Note that they are only expressed with */
|
||||
/* 16 bits when computing the extrema (the zeros need to */
|
||||
/* be in 0..1 exclusive to be considered part of the arc). */
|
||||
|
||||
if ( t1 == 0 ) /* all coefficients are 0! */
|
||||
return;
|
||||
|
||||
if ( t1 > 0x7FFFFFUL )
|
||||
{
|
||||
do
|
||||
{
|
||||
shift++;
|
||||
t1 >>= 1;
|
||||
|
||||
} while ( t1 > 0x7FFFFFUL );
|
||||
|
||||
/* this loses some bits of precision, but we use 24 of them */
|
||||
/* for the computation anyway */
|
||||
a >>= shift;
|
||||
b >>= shift;
|
||||
c >>= shift;
|
||||
}
|
||||
else if ( t1 < 0x400000UL )
|
||||
{
|
||||
do
|
||||
{
|
||||
shift++;
|
||||
t1 <<= 1;
|
||||
|
||||
} while ( t1 < 0x400000UL );
|
||||
|
||||
a <<= shift;
|
||||
b <<= shift;
|
||||
c <<= shift;
|
||||
}
|
||||
}
|
||||
|
||||
/* handle a == 0 */
|
||||
if ( a == 0 )
|
||||
{
|
||||
if ( b != 0 )
|
||||
{
|
||||
t = - FT_DivFix( c, b ) / 2;
|
||||
test_cubic_extrema( y1, y2, y3, y4, t, min, max );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* solve the equation now */
|
||||
d = FT_MulFix( b, b ) - FT_MulFix( a, c );
|
||||
if ( d < 0 )
|
||||
return;
|
||||
|
||||
if ( d == 0 )
|
||||
{
|
||||
/* there is a single split point at -b/a */
|
||||
t = - FT_DivFix( b, a );
|
||||
test_cubic_extrema( y1, y2, y3, y4, t, min, max );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* there are two solutions; we need to filter them */
|
||||
d = FT_SqrtFixed( (FT_Int32)d );
|
||||
t = - FT_DivFix( b - d, a );
|
||||
test_cubic_extrema( y1, y2, y3, y4, t, min, max );
|
||||
|
||||
t = - FT_DivFix( b + d, a );
|
||||
test_cubic_extrema( y1, y2, y3, y4, t, min, max );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* BBox_Cubic_To */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* This function is used as a `cubic_to' emitter during */
|
||||
/* FT_Outline_Decompose(). It checks a cubic Bezier curve with the */
|
||||
/* current bounding box, and computes its extrema if necessary to */
|
||||
/* update it. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* control1 :: A pointer to the first control point. */
|
||||
/* */
|
||||
/* control2 :: A pointer to the second control point. */
|
||||
/* */
|
||||
/* to :: A pointer to the destination vector. */
|
||||
/* */
|
||||
/* <InOut> */
|
||||
/* user :: The address of the current walk context. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* Always 0. Needed for the interface only. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* In the case of a non-monotonous arc, we don't compute directly */
|
||||
/* extremum coordinates, we subdivide instead. */
|
||||
/* */
|
||||
static int
|
||||
BBox_Cubic_To( FT_Vector* control1,
|
||||
FT_Vector* control2,
|
||||
FT_Vector* to,
|
||||
TBBox_Rec* user )
|
||||
{
|
||||
/* we don't need to check `to' since it is always an `on' point, thus */
|
||||
/* within the bbox */
|
||||
|
||||
if ( CHECK_X( control1, user->bbox ) ||
|
||||
CHECK_X( control2, user->bbox ) )
|
||||
BBox_Cubic_Check( user->last.x,
|
||||
control1->x,
|
||||
control2->x,
|
||||
to->x,
|
||||
&user->bbox.xMin,
|
||||
&user->bbox.xMax );
|
||||
|
||||
if ( CHECK_Y( control1, user->bbox ) ||
|
||||
CHECK_Y( control2, user->bbox ) )
|
||||
BBox_Cubic_Check( user->last.y,
|
||||
control1->y,
|
||||
control2->y,
|
||||
to->y,
|
||||
&user->bbox.yMin,
|
||||
&user->bbox.yMax );
|
||||
|
||||
user->last = *to;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
FT_DEFINE_OUTLINE_FUNCS(bbox_interface,
|
||||
(FT_Outline_MoveTo_Func) BBox_Move_To,
|
||||
(FT_Outline_LineTo_Func) BBox_Move_To,
|
||||
(FT_Outline_ConicTo_Func)BBox_Conic_To,
|
||||
(FT_Outline_CubicTo_Func)BBox_Cubic_To,
|
||||
0, 0
|
||||
)
|
||||
|
||||
/* documentation is in ftbbox.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Outline_Get_BBox( FT_Outline* outline,
|
||||
FT_BBox *abbox )
|
||||
{
|
||||
FT_BBox cbox;
|
||||
FT_BBox bbox;
|
||||
FT_Vector* vec;
|
||||
FT_UShort n;
|
||||
|
||||
|
||||
if ( !abbox )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
if ( !outline )
|
||||
return FT_Err_Invalid_Outline;
|
||||
|
||||
/* if outline is empty, return (0,0,0,0) */
|
||||
if ( outline->n_points == 0 || outline->n_contours <= 0 )
|
||||
{
|
||||
abbox->xMin = abbox->xMax = 0;
|
||||
abbox->yMin = abbox->yMax = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* We compute the control box as well as the bounding box of */
|
||||
/* all `on' points in the outline. Then, if the two boxes */
|
||||
/* coincide, we exit immediately. */
|
||||
|
||||
vec = outline->points;
|
||||
bbox.xMin = bbox.xMax = cbox.xMin = cbox.xMax = vec->x;
|
||||
bbox.yMin = bbox.yMax = cbox.yMin = cbox.yMax = vec->y;
|
||||
vec++;
|
||||
|
||||
for ( n = 1; n < outline->n_points; n++ )
|
||||
{
|
||||
FT_Pos x = vec->x;
|
||||
FT_Pos y = vec->y;
|
||||
|
||||
|
||||
/* update control box */
|
||||
if ( x < cbox.xMin ) cbox.xMin = x;
|
||||
if ( x > cbox.xMax ) cbox.xMax = x;
|
||||
|
||||
if ( y < cbox.yMin ) cbox.yMin = y;
|
||||
if ( y > cbox.yMax ) cbox.yMax = y;
|
||||
|
||||
if ( FT_CURVE_TAG( outline->tags[n] ) == FT_CURVE_TAG_ON )
|
||||
{
|
||||
/* update bbox for `on' points only */
|
||||
if ( x < bbox.xMin ) bbox.xMin = x;
|
||||
if ( x > bbox.xMax ) bbox.xMax = x;
|
||||
|
||||
if ( y < bbox.yMin ) bbox.yMin = y;
|
||||
if ( y > bbox.yMax ) bbox.yMax = y;
|
||||
}
|
||||
|
||||
vec++;
|
||||
}
|
||||
|
||||
/* test two boxes for equality */
|
||||
if ( cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax ||
|
||||
cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax )
|
||||
{
|
||||
/* the two boxes are different, now walk over the outline to */
|
||||
/* get the Bezier arc extrema. */
|
||||
|
||||
FT_Error error;
|
||||
TBBox_Rec user;
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_PIC
|
||||
FT_Outline_Funcs bbox_interface;
|
||||
Init_Class_bbox_interface(&bbox_interface);
|
||||
#endif
|
||||
|
||||
user.bbox = bbox;
|
||||
|
||||
error = FT_Outline_Decompose( outline, &bbox_interface, &user );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
*abbox = user.bbox;
|
||||
}
|
||||
else
|
||||
*abbox = bbox;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,88 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftbdf.c */
|
||||
/* */
|
||||
/* FreeType API for accessing BDF-specific strings (body). */
|
||||
/* */
|
||||
/* Copyright 2002, 2003, 2004 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_SERVICE_BDF_H
|
||||
|
||||
|
||||
/* documentation is in ftbdf.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_BDF_Charset_ID( FT_Face face,
|
||||
const char* *acharset_encoding,
|
||||
const char* *acharset_registry )
|
||||
{
|
||||
FT_Error error;
|
||||
const char* encoding = NULL;
|
||||
const char* registry = NULL;
|
||||
|
||||
|
||||
error = FT_Err_Invalid_Argument;
|
||||
|
||||
if ( face )
|
||||
{
|
||||
FT_Service_BDF service;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, BDF );
|
||||
|
||||
if ( service && service->get_charset_id )
|
||||
error = service->get_charset_id( face, &encoding, ®istry );
|
||||
}
|
||||
|
||||
if ( acharset_encoding )
|
||||
*acharset_encoding = encoding;
|
||||
|
||||
if ( acharset_registry )
|
||||
*acharset_registry = registry;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftbdf.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_BDF_Property( FT_Face face,
|
||||
const char* prop_name,
|
||||
BDF_PropertyRec *aproperty )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
error = FT_Err_Invalid_Argument;
|
||||
|
||||
aproperty->type = BDF_PROPERTY_TYPE_NONE;
|
||||
|
||||
if ( face )
|
||||
{
|
||||
FT_Service_BDF service;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, BDF );
|
||||
|
||||
if ( service && service->get_property )
|
||||
error = service->get_property( face, prop_name, aproperty );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,667 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftbitmap.c */
|
||||
/* */
|
||||
/* FreeType utility functions for bitmaps (body). */
|
||||
/* */
|
||||
/* Copyright 2004-2009, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_BITMAP_H
|
||||
#include FT_IMAGE_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
|
||||
static
|
||||
const FT_Bitmap null_bitmap = { 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
|
||||
/* documentation is in ftbitmap.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Bitmap_New( FT_Bitmap *abitmap )
|
||||
{
|
||||
*abitmap = null_bitmap;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftbitmap.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Bitmap_Copy( FT_Library library,
|
||||
const FT_Bitmap *source,
|
||||
FT_Bitmap *target)
|
||||
{
|
||||
FT_Memory memory = library->memory;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Int pitch = source->pitch;
|
||||
FT_ULong size;
|
||||
|
||||
|
||||
if ( source == target )
|
||||
return FT_Err_Ok;
|
||||
|
||||
if ( source->buffer == NULL )
|
||||
{
|
||||
*target = *source;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
if ( pitch < 0 )
|
||||
pitch = -pitch;
|
||||
size = (FT_ULong)( pitch * source->rows );
|
||||
|
||||
if ( target->buffer )
|
||||
{
|
||||
FT_Int target_pitch = target->pitch;
|
||||
FT_ULong target_size;
|
||||
|
||||
|
||||
if ( target_pitch < 0 )
|
||||
target_pitch = -target_pitch;
|
||||
target_size = (FT_ULong)( target_pitch * target->rows );
|
||||
|
||||
if ( target_size != size )
|
||||
(void)FT_QREALLOC( target->buffer, target_size, size );
|
||||
}
|
||||
else
|
||||
(void)FT_QALLOC( target->buffer, size );
|
||||
|
||||
if ( !error )
|
||||
{
|
||||
unsigned char *p;
|
||||
|
||||
|
||||
p = target->buffer;
|
||||
*target = *source;
|
||||
target->buffer = p;
|
||||
|
||||
FT_MEM_COPY( target->buffer, source->buffer, size );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_bitmap_assure_buffer( FT_Memory memory,
|
||||
FT_Bitmap* bitmap,
|
||||
FT_UInt xpixels,
|
||||
FT_UInt ypixels )
|
||||
{
|
||||
FT_Error error;
|
||||
int pitch;
|
||||
int new_pitch;
|
||||
FT_UInt bpp;
|
||||
FT_Int i, width, height;
|
||||
unsigned char* buffer = NULL;
|
||||
|
||||
|
||||
width = bitmap->width;
|
||||
height = bitmap->rows;
|
||||
pitch = bitmap->pitch;
|
||||
if ( pitch < 0 )
|
||||
pitch = -pitch;
|
||||
|
||||
switch ( bitmap->pixel_mode )
|
||||
{
|
||||
case FT_PIXEL_MODE_MONO:
|
||||
bpp = 1;
|
||||
new_pitch = ( width + xpixels + 7 ) >> 3;
|
||||
break;
|
||||
case FT_PIXEL_MODE_GRAY2:
|
||||
bpp = 2;
|
||||
new_pitch = ( width + xpixels + 3 ) >> 2;
|
||||
break;
|
||||
case FT_PIXEL_MODE_GRAY4:
|
||||
bpp = 4;
|
||||
new_pitch = ( width + xpixels + 1 ) >> 1;
|
||||
break;
|
||||
case FT_PIXEL_MODE_GRAY:
|
||||
case FT_PIXEL_MODE_LCD:
|
||||
case FT_PIXEL_MODE_LCD_V:
|
||||
bpp = 8;
|
||||
new_pitch = ( width + xpixels );
|
||||
break;
|
||||
default:
|
||||
return FT_Err_Invalid_Glyph_Format;
|
||||
}
|
||||
|
||||
/* if no need to allocate memory */
|
||||
if ( ypixels == 0 && new_pitch <= pitch )
|
||||
{
|
||||
/* zero the padding */
|
||||
FT_Int bit_width = pitch * 8;
|
||||
FT_Int bit_last = ( width + xpixels ) * bpp;
|
||||
|
||||
|
||||
if ( bit_last < bit_width )
|
||||
{
|
||||
FT_Byte* line = bitmap->buffer + ( bit_last >> 3 );
|
||||
FT_Byte* end = bitmap->buffer + pitch;
|
||||
FT_Int shift = bit_last & 7;
|
||||
FT_UInt mask = 0xFF00U >> shift;
|
||||
FT_Int count = height;
|
||||
|
||||
|
||||
for ( ; count > 0; count--, line += pitch, end += pitch )
|
||||
{
|
||||
FT_Byte* write = line;
|
||||
|
||||
|
||||
if ( shift > 0 )
|
||||
{
|
||||
write[0] = (FT_Byte)( write[0] & mask );
|
||||
write++;
|
||||
}
|
||||
if ( write < end )
|
||||
FT_MEM_ZERO( write, end-write );
|
||||
}
|
||||
}
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
if ( FT_QALLOC_MULT( buffer, new_pitch, bitmap->rows + ypixels ) )
|
||||
return error;
|
||||
|
||||
if ( bitmap->pitch > 0 )
|
||||
{
|
||||
FT_Int len = ( width * bpp + 7 ) >> 3;
|
||||
|
||||
|
||||
for ( i = 0; i < bitmap->rows; i++ )
|
||||
FT_MEM_COPY( buffer + new_pitch * ( ypixels + i ),
|
||||
bitmap->buffer + pitch * i, len );
|
||||
}
|
||||
else
|
||||
{
|
||||
FT_Int len = ( width * bpp + 7 ) >> 3;
|
||||
|
||||
|
||||
for ( i = 0; i < bitmap->rows; i++ )
|
||||
FT_MEM_COPY( buffer + new_pitch * i,
|
||||
bitmap->buffer + pitch * i, len );
|
||||
}
|
||||
|
||||
FT_FREE( bitmap->buffer );
|
||||
bitmap->buffer = buffer;
|
||||
|
||||
if ( bitmap->pitch < 0 )
|
||||
new_pitch = -new_pitch;
|
||||
|
||||
/* set pitch only, width and height are left untouched */
|
||||
bitmap->pitch = new_pitch;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftbitmap.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Bitmap_Embolden( FT_Library library,
|
||||
FT_Bitmap* bitmap,
|
||||
FT_Pos xStrength,
|
||||
FT_Pos yStrength )
|
||||
{
|
||||
FT_Error error;
|
||||
unsigned char* p;
|
||||
FT_Int i, x, y, pitch;
|
||||
FT_Int xstr, ystr;
|
||||
|
||||
|
||||
if ( !library )
|
||||
return FT_Err_Invalid_Library_Handle;
|
||||
|
||||
if ( !bitmap || !bitmap->buffer )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
if ( ( ( FT_PIX_ROUND( xStrength ) >> 6 ) > FT_INT_MAX ) ||
|
||||
( ( FT_PIX_ROUND( yStrength ) >> 6 ) > FT_INT_MAX ) )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
xstr = (FT_Int)FT_PIX_ROUND( xStrength ) >> 6;
|
||||
ystr = (FT_Int)FT_PIX_ROUND( yStrength ) >> 6;
|
||||
|
||||
if ( xstr == 0 && ystr == 0 )
|
||||
return FT_Err_Ok;
|
||||
else if ( xstr < 0 || ystr < 0 )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
switch ( bitmap->pixel_mode )
|
||||
{
|
||||
case FT_PIXEL_MODE_GRAY2:
|
||||
case FT_PIXEL_MODE_GRAY4:
|
||||
{
|
||||
FT_Bitmap tmp;
|
||||
FT_Int align;
|
||||
|
||||
|
||||
if ( bitmap->pixel_mode == FT_PIXEL_MODE_GRAY2 )
|
||||
align = ( bitmap->width + xstr + 3 ) / 4;
|
||||
else
|
||||
align = ( bitmap->width + xstr + 1 ) / 2;
|
||||
|
||||
FT_Bitmap_New( &tmp );
|
||||
|
||||
error = FT_Bitmap_Convert( library, bitmap, &tmp, align );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
FT_Bitmap_Done( library, bitmap );
|
||||
*bitmap = tmp;
|
||||
}
|
||||
break;
|
||||
|
||||
case FT_PIXEL_MODE_MONO:
|
||||
if ( xstr > 8 )
|
||||
xstr = 8;
|
||||
break;
|
||||
|
||||
case FT_PIXEL_MODE_LCD:
|
||||
xstr *= 3;
|
||||
break;
|
||||
|
||||
case FT_PIXEL_MODE_LCD_V:
|
||||
ystr *= 3;
|
||||
break;
|
||||
}
|
||||
|
||||
error = ft_bitmap_assure_buffer( library->memory, bitmap, xstr, ystr );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
pitch = bitmap->pitch;
|
||||
if ( pitch > 0 )
|
||||
p = bitmap->buffer + pitch * ystr;
|
||||
else
|
||||
{
|
||||
pitch = -pitch;
|
||||
p = bitmap->buffer + pitch * ( bitmap->rows - 1 );
|
||||
}
|
||||
|
||||
/* for each row */
|
||||
for ( y = 0; y < bitmap->rows ; y++ )
|
||||
{
|
||||
/*
|
||||
* Horizontally:
|
||||
*
|
||||
* From the last pixel on, make each pixel or'ed with the
|
||||
* `xstr' pixels before it.
|
||||
*/
|
||||
for ( x = pitch - 1; x >= 0; x-- )
|
||||
{
|
||||
unsigned char tmp;
|
||||
|
||||
|
||||
tmp = p[x];
|
||||
for ( i = 1; i <= xstr; i++ )
|
||||
{
|
||||
if ( bitmap->pixel_mode == FT_PIXEL_MODE_MONO )
|
||||
{
|
||||
p[x] |= tmp >> i;
|
||||
|
||||
/* the maximum value of 8 for `xstr' comes from here */
|
||||
if ( x > 0 )
|
||||
p[x] |= p[x - 1] << ( 8 - i );
|
||||
|
||||
#if 0
|
||||
if ( p[x] == 0xff )
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( x - i >= 0 )
|
||||
{
|
||||
if ( p[x] + p[x - i] > bitmap->num_grays - 1 )
|
||||
{
|
||||
p[x] = (unsigned char)(bitmap->num_grays - 1);
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
p[x] = (unsigned char)(p[x] + p[x-i]);
|
||||
if ( p[x] == bitmap->num_grays - 1 )
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Vertically:
|
||||
*
|
||||
* Make the above `ystr' rows or'ed with it.
|
||||
*/
|
||||
for ( x = 1; x <= ystr; x++ )
|
||||
{
|
||||
unsigned char* q;
|
||||
|
||||
|
||||
q = p - bitmap->pitch * x;
|
||||
for ( i = 0; i < pitch; i++ )
|
||||
q[i] |= p[i];
|
||||
}
|
||||
|
||||
p += bitmap->pitch;
|
||||
}
|
||||
|
||||
bitmap->width += xstr;
|
||||
bitmap->rows += ystr;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftbitmap.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Bitmap_Convert( FT_Library library,
|
||||
const FT_Bitmap *source,
|
||||
FT_Bitmap *target,
|
||||
FT_Int alignment )
|
||||
{
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
if ( !library )
|
||||
return FT_Err_Invalid_Library_Handle;
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
switch ( source->pixel_mode )
|
||||
{
|
||||
case FT_PIXEL_MODE_MONO:
|
||||
case FT_PIXEL_MODE_GRAY:
|
||||
case FT_PIXEL_MODE_GRAY2:
|
||||
case FT_PIXEL_MODE_GRAY4:
|
||||
case FT_PIXEL_MODE_LCD:
|
||||
case FT_PIXEL_MODE_LCD_V:
|
||||
{
|
||||
FT_Int pad;
|
||||
FT_Long old_size;
|
||||
|
||||
|
||||
old_size = target->rows * target->pitch;
|
||||
if ( old_size < 0 )
|
||||
old_size = -old_size;
|
||||
|
||||
target->pixel_mode = FT_PIXEL_MODE_GRAY;
|
||||
target->rows = source->rows;
|
||||
target->width = source->width;
|
||||
|
||||
pad = 0;
|
||||
if ( alignment > 0 )
|
||||
{
|
||||
pad = source->width % alignment;
|
||||
if ( pad != 0 )
|
||||
pad = alignment - pad;
|
||||
}
|
||||
|
||||
target->pitch = source->width + pad;
|
||||
|
||||
if ( target->pitch > 0 &&
|
||||
target->rows > FT_ULONG_MAX / target->pitch )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
if ( target->rows * target->pitch > old_size &&
|
||||
FT_QREALLOC( target->buffer,
|
||||
old_size, target->rows * target->pitch ) )
|
||||
return error;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
error = FT_Err_Invalid_Argument;
|
||||
}
|
||||
|
||||
switch ( source->pixel_mode )
|
||||
{
|
||||
case FT_PIXEL_MODE_MONO:
|
||||
{
|
||||
FT_Byte* s = source->buffer;
|
||||
FT_Byte* t = target->buffer;
|
||||
FT_Int i;
|
||||
|
||||
|
||||
target->num_grays = 2;
|
||||
|
||||
for ( i = source->rows; i > 0; i-- )
|
||||
{
|
||||
FT_Byte* ss = s;
|
||||
FT_Byte* tt = t;
|
||||
FT_Int j;
|
||||
|
||||
|
||||
/* get the full bytes */
|
||||
for ( j = source->width >> 3; j > 0; j-- )
|
||||
{
|
||||
FT_Int val = ss[0]; /* avoid a byte->int cast on each line */
|
||||
|
||||
|
||||
tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7 );
|
||||
tt[1] = (FT_Byte)( ( val & 0x40 ) >> 6 );
|
||||
tt[2] = (FT_Byte)( ( val & 0x20 ) >> 5 );
|
||||
tt[3] = (FT_Byte)( ( val & 0x10 ) >> 4 );
|
||||
tt[4] = (FT_Byte)( ( val & 0x08 ) >> 3 );
|
||||
tt[5] = (FT_Byte)( ( val & 0x04 ) >> 2 );
|
||||
tt[6] = (FT_Byte)( ( val & 0x02 ) >> 1 );
|
||||
tt[7] = (FT_Byte)( val & 0x01 );
|
||||
|
||||
tt += 8;
|
||||
ss += 1;
|
||||
}
|
||||
|
||||
/* get remaining pixels (if any) */
|
||||
j = source->width & 7;
|
||||
if ( j > 0 )
|
||||
{
|
||||
FT_Int val = *ss;
|
||||
|
||||
|
||||
for ( ; j > 0; j-- )
|
||||
{
|
||||
tt[0] = (FT_Byte)( ( val & 0x80 ) >> 7);
|
||||
val <<= 1;
|
||||
tt += 1;
|
||||
}
|
||||
}
|
||||
|
||||
s += source->pitch;
|
||||
t += target->pitch;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case FT_PIXEL_MODE_GRAY:
|
||||
case FT_PIXEL_MODE_LCD:
|
||||
case FT_PIXEL_MODE_LCD_V:
|
||||
{
|
||||
FT_Int width = source->width;
|
||||
FT_Byte* s = source->buffer;
|
||||
FT_Byte* t = target->buffer;
|
||||
FT_Int s_pitch = source->pitch;
|
||||
FT_Int t_pitch = target->pitch;
|
||||
FT_Int i;
|
||||
|
||||
|
||||
target->num_grays = 256;
|
||||
|
||||
for ( i = source->rows; i > 0; i-- )
|
||||
{
|
||||
FT_ARRAY_COPY( t, s, width );
|
||||
|
||||
s += s_pitch;
|
||||
t += t_pitch;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case FT_PIXEL_MODE_GRAY2:
|
||||
{
|
||||
FT_Byte* s = source->buffer;
|
||||
FT_Byte* t = target->buffer;
|
||||
FT_Int i;
|
||||
|
||||
|
||||
target->num_grays = 4;
|
||||
|
||||
for ( i = source->rows; i > 0; i-- )
|
||||
{
|
||||
FT_Byte* ss = s;
|
||||
FT_Byte* tt = t;
|
||||
FT_Int j;
|
||||
|
||||
|
||||
/* get the full bytes */
|
||||
for ( j = source->width >> 2; j > 0; j-- )
|
||||
{
|
||||
FT_Int val = ss[0];
|
||||
|
||||
|
||||
tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 );
|
||||
tt[1] = (FT_Byte)( ( val & 0x30 ) >> 4 );
|
||||
tt[2] = (FT_Byte)( ( val & 0x0C ) >> 2 );
|
||||
tt[3] = (FT_Byte)( ( val & 0x03 ) );
|
||||
|
||||
ss += 1;
|
||||
tt += 4;
|
||||
}
|
||||
|
||||
j = source->width & 3;
|
||||
if ( j > 0 )
|
||||
{
|
||||
FT_Int val = ss[0];
|
||||
|
||||
|
||||
for ( ; j > 0; j-- )
|
||||
{
|
||||
tt[0] = (FT_Byte)( ( val & 0xC0 ) >> 6 );
|
||||
val <<= 2;
|
||||
tt += 1;
|
||||
}
|
||||
}
|
||||
|
||||
s += source->pitch;
|
||||
t += target->pitch;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case FT_PIXEL_MODE_GRAY4:
|
||||
{
|
||||
FT_Byte* s = source->buffer;
|
||||
FT_Byte* t = target->buffer;
|
||||
FT_Int i;
|
||||
|
||||
|
||||
target->num_grays = 16;
|
||||
|
||||
for ( i = source->rows; i > 0; i-- )
|
||||
{
|
||||
FT_Byte* ss = s;
|
||||
FT_Byte* tt = t;
|
||||
FT_Int j;
|
||||
|
||||
|
||||
/* get the full bytes */
|
||||
for ( j = source->width >> 1; j > 0; j-- )
|
||||
{
|
||||
FT_Int val = ss[0];
|
||||
|
||||
|
||||
tt[0] = (FT_Byte)( ( val & 0xF0 ) >> 4 );
|
||||
tt[1] = (FT_Byte)( ( val & 0x0F ) );
|
||||
|
||||
ss += 1;
|
||||
tt += 2;
|
||||
}
|
||||
|
||||
if ( source->width & 1 )
|
||||
tt[0] = (FT_Byte)( ( ss[0] & 0xF0 ) >> 4 );
|
||||
|
||||
s += source->pitch;
|
||||
t += target->pitch;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
default:
|
||||
;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftbitmap.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_GlyphSlot_Own_Bitmap( FT_GlyphSlot slot )
|
||||
{
|
||||
if ( slot && slot->format == FT_GLYPH_FORMAT_BITMAP &&
|
||||
!( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
|
||||
{
|
||||
FT_Bitmap bitmap;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
FT_Bitmap_New( &bitmap );
|
||||
error = FT_Bitmap_Copy( slot->library, &slot->bitmap, &bitmap );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
slot->bitmap = bitmap;
|
||||
slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
|
||||
}
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftbitmap.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Bitmap_Done( FT_Library library,
|
||||
FT_Bitmap *bitmap )
|
||||
{
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
if ( !library )
|
||||
return FT_Err_Invalid_Library_Handle;
|
||||
|
||||
if ( !bitmap )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
FT_FREE( bitmap->buffer );
|
||||
*bitmap = null_bitmap;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,957 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcalc.c */
|
||||
/* */
|
||||
/* Arithmetic computations (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Support for 1-complement arithmetic has been totally dropped in this */
|
||||
/* release. You can still write your own code if you need it. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Implementing basic computation routines. */
|
||||
/* */
|
||||
/* FT_MulDiv(), FT_MulFix(), FT_DivFix(), FT_RoundFix(), FT_CeilFix(), */
|
||||
/* and FT_FloorFix() are declared in freetype.h. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_GLYPH_H
|
||||
#include FT_INTERNAL_CALC_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
#ifdef FT_MULFIX_INLINED
|
||||
#undef FT_MulFix
|
||||
#endif
|
||||
|
||||
/* we need to define a 64-bits data type here */
|
||||
|
||||
#ifdef FT_LONG64
|
||||
|
||||
typedef FT_INT64 FT_Int64;
|
||||
|
||||
#else
|
||||
|
||||
typedef struct FT_Int64_
|
||||
{
|
||||
FT_UInt32 lo;
|
||||
FT_UInt32 hi;
|
||||
|
||||
} FT_Int64;
|
||||
|
||||
#endif /* FT_LONG64 */
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_calc
|
||||
|
||||
|
||||
/* The following three functions are available regardless of whether */
|
||||
/* FT_LONG64 is defined. */
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Fixed )
|
||||
FT_RoundFix( FT_Fixed a )
|
||||
{
|
||||
return ( a >= 0 ) ? ( a + 0x8000L ) & ~0xFFFFL
|
||||
: -((-a + 0x8000L ) & ~0xFFFFL );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Fixed )
|
||||
FT_CeilFix( FT_Fixed a )
|
||||
{
|
||||
return ( a >= 0 ) ? ( a + 0xFFFFL ) & ~0xFFFFL
|
||||
: -((-a + 0xFFFFL ) & ~0xFFFFL );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Fixed )
|
||||
FT_FloorFix( FT_Fixed a )
|
||||
{
|
||||
return ( a >= 0 ) ? a & ~0xFFFFL
|
||||
: -((-a) & ~0xFFFFL );
|
||||
}
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
/* documentation is in ftcalc.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Int32 )
|
||||
FT_Sqrt32( FT_Int32 x )
|
||||
{
|
||||
FT_UInt32 val, root, newroot, mask;
|
||||
|
||||
|
||||
root = 0;
|
||||
mask = (FT_UInt32)0x40000000UL;
|
||||
val = (FT_UInt32)x;
|
||||
|
||||
do
|
||||
{
|
||||
newroot = root + mask;
|
||||
if ( newroot <= val )
|
||||
{
|
||||
val -= newroot;
|
||||
root = newroot + mask;
|
||||
}
|
||||
|
||||
root >>= 1;
|
||||
mask >>= 2;
|
||||
|
||||
} while ( mask != 0 );
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
|
||||
#ifdef FT_LONG64
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Long )
|
||||
FT_MulDiv( FT_Long a,
|
||||
FT_Long b,
|
||||
FT_Long c )
|
||||
{
|
||||
FT_Int s;
|
||||
FT_Long d;
|
||||
|
||||
|
||||
s = 1;
|
||||
if ( a < 0 ) { a = -a; s = -1; }
|
||||
if ( b < 0 ) { b = -b; s = -s; }
|
||||
if ( c < 0 ) { c = -c; s = -s; }
|
||||
|
||||
d = (FT_Long)( c > 0 ? ( (FT_Int64)a * b + ( c >> 1 ) ) / c
|
||||
: 0x7FFFFFFFL );
|
||||
|
||||
return ( s > 0 ) ? d : -d;
|
||||
}
|
||||
|
||||
|
||||
#ifdef TT_USE_BYTECODE_INTERPRETER
|
||||
|
||||
/* documentation is in ftcalc.h */
|
||||
|
||||
FT_BASE_DEF( FT_Long )
|
||||
FT_MulDiv_No_Round( FT_Long a,
|
||||
FT_Long b,
|
||||
FT_Long c )
|
||||
{
|
||||
FT_Int s;
|
||||
FT_Long d;
|
||||
|
||||
|
||||
s = 1;
|
||||
if ( a < 0 ) { a = -a; s = -1; }
|
||||
if ( b < 0 ) { b = -b; s = -s; }
|
||||
if ( c < 0 ) { c = -c; s = -s; }
|
||||
|
||||
d = (FT_Long)( c > 0 ? (FT_Int64)a * b / c
|
||||
: 0x7FFFFFFFL );
|
||||
|
||||
return ( s > 0 ) ? d : -d;
|
||||
}
|
||||
|
||||
#endif /* TT_USE_BYTECODE_INTERPRETER */
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Long )
|
||||
FT_MulFix( FT_Long a,
|
||||
FT_Long b )
|
||||
{
|
||||
#ifdef FT_MULFIX_ASSEMBLER
|
||||
|
||||
return FT_MULFIX_ASSEMBLER( a, b );
|
||||
|
||||
#else
|
||||
|
||||
FT_Int s = 1;
|
||||
FT_Long c;
|
||||
|
||||
|
||||
if ( a < 0 )
|
||||
{
|
||||
a = -a;
|
||||
s = -1;
|
||||
}
|
||||
|
||||
if ( b < 0 )
|
||||
{
|
||||
b = -b;
|
||||
s = -s;
|
||||
}
|
||||
|
||||
c = (FT_Long)( ( (FT_Int64)a * b + 0x8000L ) >> 16 );
|
||||
|
||||
return ( s > 0 ) ? c : -c;
|
||||
|
||||
#endif /* FT_MULFIX_ASSEMBLER */
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Long )
|
||||
FT_DivFix( FT_Long a,
|
||||
FT_Long b )
|
||||
{
|
||||
FT_Int32 s;
|
||||
FT_UInt32 q;
|
||||
|
||||
s = 1;
|
||||
if ( a < 0 ) { a = -a; s = -1; }
|
||||
if ( b < 0 ) { b = -b; s = -s; }
|
||||
|
||||
if ( b == 0 )
|
||||
/* check for division by 0 */
|
||||
q = 0x7FFFFFFFL;
|
||||
else
|
||||
/* compute result directly */
|
||||
q = (FT_UInt32)( ( ( (FT_Int64)a << 16 ) + ( b >> 1 ) ) / b );
|
||||
|
||||
return ( s < 0 ? -(FT_Long)q : (FT_Long)q );
|
||||
}
|
||||
|
||||
|
||||
#else /* !FT_LONG64 */
|
||||
|
||||
|
||||
static void
|
||||
ft_multo64( FT_UInt32 x,
|
||||
FT_UInt32 y,
|
||||
FT_Int64 *z )
|
||||
{
|
||||
FT_UInt32 lo1, hi1, lo2, hi2, lo, hi, i1, i2;
|
||||
|
||||
|
||||
lo1 = x & 0x0000FFFFU; hi1 = x >> 16;
|
||||
lo2 = y & 0x0000FFFFU; hi2 = y >> 16;
|
||||
|
||||
lo = lo1 * lo2;
|
||||
i1 = lo1 * hi2;
|
||||
i2 = lo2 * hi1;
|
||||
hi = hi1 * hi2;
|
||||
|
||||
/* Check carry overflow of i1 + i2 */
|
||||
i1 += i2;
|
||||
hi += (FT_UInt32)( i1 < i2 ) << 16;
|
||||
|
||||
hi += i1 >> 16;
|
||||
i1 = i1 << 16;
|
||||
|
||||
/* Check carry overflow of i1 + lo */
|
||||
lo += i1;
|
||||
hi += ( lo < i1 );
|
||||
|
||||
z->lo = lo;
|
||||
z->hi = hi;
|
||||
}
|
||||
|
||||
|
||||
static FT_UInt32
|
||||
ft_div64by32( FT_UInt32 hi,
|
||||
FT_UInt32 lo,
|
||||
FT_UInt32 y )
|
||||
{
|
||||
FT_UInt32 r, q;
|
||||
FT_Int i;
|
||||
|
||||
|
||||
q = 0;
|
||||
r = hi;
|
||||
|
||||
if ( r >= y )
|
||||
return (FT_UInt32)0x7FFFFFFFL;
|
||||
|
||||
i = 32;
|
||||
do
|
||||
{
|
||||
r <<= 1;
|
||||
q <<= 1;
|
||||
r |= lo >> 31;
|
||||
|
||||
if ( r >= (FT_UInt32)y )
|
||||
{
|
||||
r -= y;
|
||||
q |= 1;
|
||||
}
|
||||
lo <<= 1;
|
||||
} while ( --i );
|
||||
|
||||
return q;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
FT_Add64( FT_Int64* x,
|
||||
FT_Int64* y,
|
||||
FT_Int64 *z )
|
||||
{
|
||||
register FT_UInt32 lo, hi;
|
||||
|
||||
|
||||
lo = x->lo + y->lo;
|
||||
hi = x->hi + y->hi + ( lo < x->lo );
|
||||
|
||||
z->lo = lo;
|
||||
z->hi = hi;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
/* The FT_MulDiv function has been optimized thanks to ideas from */
|
||||
/* Graham Asher. The trick is to optimize computation when everything */
|
||||
/* fits within 32-bits (a rather common case). */
|
||||
/* */
|
||||
/* we compute 'a*b+c/2', then divide it by 'c'. (positive values) */
|
||||
/* */
|
||||
/* 46340 is FLOOR(SQRT(2^31-1)). */
|
||||
/* */
|
||||
/* if ( a <= 46340 && b <= 46340 ) then ( a*b <= 0x7FFEA810 ) */
|
||||
/* */
|
||||
/* 0x7FFFFFFF - 0x7FFEA810 = 0x157F0 */
|
||||
/* */
|
||||
/* if ( c < 0x157F0*2 ) then ( a*b+c/2 <= 0x7FFFFFFF ) */
|
||||
/* */
|
||||
/* and 2*0x157F0 = 176096 */
|
||||
/* */
|
||||
|
||||
FT_EXPORT_DEF( FT_Long )
|
||||
FT_MulDiv( FT_Long a,
|
||||
FT_Long b,
|
||||
FT_Long c )
|
||||
{
|
||||
long s;
|
||||
|
||||
|
||||
/* XXX: this function does not allow 64-bit arguments */
|
||||
if ( a == 0 || b == c )
|
||||
return a;
|
||||
|
||||
s = a; a = FT_ABS( a );
|
||||
s ^= b; b = FT_ABS( b );
|
||||
s ^= c; c = FT_ABS( c );
|
||||
|
||||
if ( a <= 46340L && b <= 46340L && c <= 176095L && c > 0 )
|
||||
a = ( a * b + ( c >> 1 ) ) / c;
|
||||
|
||||
else if ( c > 0 )
|
||||
{
|
||||
FT_Int64 temp, temp2;
|
||||
|
||||
|
||||
ft_multo64( (FT_Int32)a, (FT_Int32)b, &temp );
|
||||
|
||||
temp2.hi = 0;
|
||||
temp2.lo = (FT_UInt32)(c >> 1);
|
||||
FT_Add64( &temp, &temp2, &temp );
|
||||
a = ft_div64by32( temp.hi, temp.lo, (FT_Int32)c );
|
||||
}
|
||||
else
|
||||
a = 0x7FFFFFFFL;
|
||||
|
||||
return ( s < 0 ? -a : a );
|
||||
}
|
||||
|
||||
|
||||
#ifdef TT_USE_BYTECODE_INTERPRETER
|
||||
|
||||
FT_BASE_DEF( FT_Long )
|
||||
FT_MulDiv_No_Round( FT_Long a,
|
||||
FT_Long b,
|
||||
FT_Long c )
|
||||
{
|
||||
long s;
|
||||
|
||||
|
||||
if ( a == 0 || b == c )
|
||||
return a;
|
||||
|
||||
s = a; a = FT_ABS( a );
|
||||
s ^= b; b = FT_ABS( b );
|
||||
s ^= c; c = FT_ABS( c );
|
||||
|
||||
if ( a <= 46340L && b <= 46340L && c > 0 )
|
||||
a = a * b / c;
|
||||
|
||||
else if ( c > 0 )
|
||||
{
|
||||
FT_Int64 temp;
|
||||
|
||||
|
||||
ft_multo64( (FT_Int32)a, (FT_Int32)b, &temp );
|
||||
a = ft_div64by32( temp.hi, temp.lo, (FT_Int32)c );
|
||||
}
|
||||
else
|
||||
a = 0x7FFFFFFFL;
|
||||
|
||||
return ( s < 0 ? -a : a );
|
||||
}
|
||||
|
||||
#endif /* TT_USE_BYTECODE_INTERPRETER */
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Long )
|
||||
FT_MulFix( FT_Long a,
|
||||
FT_Long b )
|
||||
{
|
||||
#ifdef FT_MULFIX_ASSEMBLER
|
||||
|
||||
return FT_MULFIX_ASSEMBLER( a, b );
|
||||
|
||||
#elif 0
|
||||
|
||||
/*
|
||||
* This code is nonportable. See comment below.
|
||||
*
|
||||
* However, on a platform where right-shift of a signed quantity fills
|
||||
* the leftmost bits by copying the sign bit, it might be faster.
|
||||
*/
|
||||
|
||||
FT_Long sa, sb;
|
||||
FT_ULong ua, ub;
|
||||
|
||||
|
||||
if ( a == 0 || b == 0x10000L )
|
||||
return a;
|
||||
|
||||
/*
|
||||
* This is a clever way of converting a signed number `a' into its
|
||||
* absolute value (stored back into `a') and its sign. The sign is
|
||||
* stored in `sa'; 0 means `a' was positive or zero, and -1 means `a'
|
||||
* was negative. (Similarly for `b' and `sb').
|
||||
*
|
||||
* Unfortunately, it doesn't work (at least not portably).
|
||||
*
|
||||
* It makes the assumption that right-shift on a negative signed value
|
||||
* fills the leftmost bits by copying the sign bit. This is wrong.
|
||||
* According to K&R 2nd ed, section `A7.8 Shift Operators' on page 206,
|
||||
* the result of right-shift of a negative signed value is
|
||||
* implementation-defined. At least one implementation fills the
|
||||
* leftmost bits with 0s (i.e., it is exactly the same as an unsigned
|
||||
* right shift). This means that when `a' is negative, `sa' ends up
|
||||
* with the value 1 rather than -1. After that, everything else goes
|
||||
* wrong.
|
||||
*/
|
||||
sa = ( a >> ( sizeof ( a ) * 8 - 1 ) );
|
||||
a = ( a ^ sa ) - sa;
|
||||
sb = ( b >> ( sizeof ( b ) * 8 - 1 ) );
|
||||
b = ( b ^ sb ) - sb;
|
||||
|
||||
ua = (FT_ULong)a;
|
||||
ub = (FT_ULong)b;
|
||||
|
||||
if ( ua <= 2048 && ub <= 1048576L )
|
||||
ua = ( ua * ub + 0x8000U ) >> 16;
|
||||
else
|
||||
{
|
||||
FT_ULong al = ua & 0xFFFFU;
|
||||
|
||||
|
||||
ua = ( ua >> 16 ) * ub + al * ( ub >> 16 ) +
|
||||
( ( al * ( ub & 0xFFFFU ) + 0x8000U ) >> 16 );
|
||||
}
|
||||
|
||||
sa ^= sb,
|
||||
ua = (FT_ULong)(( ua ^ sa ) - sa);
|
||||
|
||||
return (FT_Long)ua;
|
||||
|
||||
#else /* 0 */
|
||||
|
||||
FT_Long s;
|
||||
FT_ULong ua, ub;
|
||||
|
||||
|
||||
if ( a == 0 || b == 0x10000L )
|
||||
return a;
|
||||
|
||||
s = a; a = FT_ABS( a );
|
||||
s ^= b; b = FT_ABS( b );
|
||||
|
||||
ua = (FT_ULong)a;
|
||||
ub = (FT_ULong)b;
|
||||
|
||||
if ( ua <= 2048 && ub <= 1048576L )
|
||||
ua = ( ua * ub + 0x8000UL ) >> 16;
|
||||
else
|
||||
{
|
||||
FT_ULong al = ua & 0xFFFFUL;
|
||||
|
||||
|
||||
ua = ( ua >> 16 ) * ub + al * ( ub >> 16 ) +
|
||||
( ( al * ( ub & 0xFFFFUL ) + 0x8000UL ) >> 16 );
|
||||
}
|
||||
|
||||
return ( s < 0 ? -(FT_Long)ua : (FT_Long)ua );
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Long )
|
||||
FT_DivFix( FT_Long a,
|
||||
FT_Long b )
|
||||
{
|
||||
FT_Int32 s;
|
||||
FT_UInt32 q;
|
||||
|
||||
|
||||
/* XXX: this function does not allow 64-bit arguments */
|
||||
s = (FT_Int32)a; a = FT_ABS( a );
|
||||
s ^= (FT_Int32)b; b = FT_ABS( b );
|
||||
|
||||
if ( b == 0 )
|
||||
{
|
||||
/* check for division by 0 */
|
||||
q = (FT_UInt32)0x7FFFFFFFL;
|
||||
}
|
||||
else if ( ( a >> 16 ) == 0 )
|
||||
{
|
||||
/* compute result directly */
|
||||
q = (FT_UInt32)( (a << 16) + (b >> 1) ) / (FT_UInt32)b;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* we need more bits; we have to do it by hand */
|
||||
FT_Int64 temp, temp2;
|
||||
|
||||
temp.hi = (FT_Int32) (a >> 16);
|
||||
temp.lo = (FT_UInt32)(a << 16);
|
||||
temp2.hi = 0;
|
||||
temp2.lo = (FT_UInt32)( b >> 1 );
|
||||
FT_Add64( &temp, &temp2, &temp );
|
||||
q = ft_div64by32( temp.hi, temp.lo, (FT_Int32)b );
|
||||
}
|
||||
|
||||
return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
/* documentation is in ftcalc.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_MulTo64( FT_Int32 x,
|
||||
FT_Int32 y,
|
||||
FT_Int64 *z )
|
||||
{
|
||||
FT_Int32 s;
|
||||
|
||||
|
||||
s = x; x = FT_ABS( x );
|
||||
s ^= y; y = FT_ABS( y );
|
||||
|
||||
ft_multo64( x, y, z );
|
||||
|
||||
if ( s < 0 )
|
||||
{
|
||||
z->lo = (FT_UInt32)-(FT_Int32)z->lo;
|
||||
z->hi = ~z->hi + !( z->lo );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* apparently, the second version of this code is not compiled correctly */
|
||||
/* on Mac machines with the MPW C compiler.. tsk, tsk, tsk... */
|
||||
|
||||
#if 1
|
||||
|
||||
FT_EXPORT_DEF( FT_Int32 )
|
||||
FT_Div64by32( FT_Int64* x,
|
||||
FT_Int32 y )
|
||||
{
|
||||
FT_Int32 s;
|
||||
FT_UInt32 q, r, i, lo;
|
||||
|
||||
|
||||
s = x->hi;
|
||||
if ( s < 0 )
|
||||
{
|
||||
x->lo = (FT_UInt32)-(FT_Int32)x->lo;
|
||||
x->hi = ~x->hi + !x->lo;
|
||||
}
|
||||
s ^= y; y = FT_ABS( y );
|
||||
|
||||
/* Shortcut */
|
||||
if ( x->hi == 0 )
|
||||
{
|
||||
if ( y > 0 )
|
||||
q = x->lo / y;
|
||||
else
|
||||
q = 0x7FFFFFFFL;
|
||||
|
||||
return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
|
||||
}
|
||||
|
||||
r = x->hi;
|
||||
lo = x->lo;
|
||||
|
||||
if ( r >= (FT_UInt32)y ) /* we know y is to be treated as unsigned here */
|
||||
return ( s < 0 ? 0x80000001UL : 0x7FFFFFFFUL );
|
||||
/* Return Max/Min Int32 if division overflow. */
|
||||
/* This includes division by zero! */
|
||||
q = 0;
|
||||
for ( i = 0; i < 32; i++ )
|
||||
{
|
||||
r <<= 1;
|
||||
q <<= 1;
|
||||
r |= lo >> 31;
|
||||
|
||||
if ( r >= (FT_UInt32)y )
|
||||
{
|
||||
r -= y;
|
||||
q |= 1;
|
||||
}
|
||||
lo <<= 1;
|
||||
}
|
||||
|
||||
return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
|
||||
}
|
||||
|
||||
#else /* 0 */
|
||||
|
||||
FT_EXPORT_DEF( FT_Int32 )
|
||||
FT_Div64by32( FT_Int64* x,
|
||||
FT_Int32 y )
|
||||
{
|
||||
FT_Int32 s;
|
||||
FT_UInt32 q;
|
||||
|
||||
|
||||
s = x->hi;
|
||||
if ( s < 0 )
|
||||
{
|
||||
x->lo = (FT_UInt32)-(FT_Int32)x->lo;
|
||||
x->hi = ~x->hi + !x->lo;
|
||||
}
|
||||
s ^= y; y = FT_ABS( y );
|
||||
|
||||
/* Shortcut */
|
||||
if ( x->hi == 0 )
|
||||
{
|
||||
if ( y > 0 )
|
||||
q = ( x->lo + ( y >> 1 ) ) / y;
|
||||
else
|
||||
q = 0x7FFFFFFFL;
|
||||
|
||||
return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
|
||||
}
|
||||
|
||||
q = ft_div64by32( x->hi, x->lo, y );
|
||||
|
||||
return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
#endif /* FT_LONG64 */
|
||||
|
||||
|
||||
/* documentation is in ftglyph.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Matrix_Multiply( const FT_Matrix* a,
|
||||
FT_Matrix *b )
|
||||
{
|
||||
FT_Fixed xx, xy, yx, yy;
|
||||
|
||||
|
||||
if ( !a || !b )
|
||||
return;
|
||||
|
||||
xx = FT_MulFix( a->xx, b->xx ) + FT_MulFix( a->xy, b->yx );
|
||||
xy = FT_MulFix( a->xx, b->xy ) + FT_MulFix( a->xy, b->yy );
|
||||
yx = FT_MulFix( a->yx, b->xx ) + FT_MulFix( a->yy, b->yx );
|
||||
yy = FT_MulFix( a->yx, b->xy ) + FT_MulFix( a->yy, b->yy );
|
||||
|
||||
b->xx = xx; b->xy = xy;
|
||||
b->yx = yx; b->yy = yy;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftglyph.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Matrix_Invert( FT_Matrix* matrix )
|
||||
{
|
||||
FT_Pos delta, xx, yy;
|
||||
|
||||
|
||||
if ( !matrix )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
/* compute discriminant */
|
||||
delta = FT_MulFix( matrix->xx, matrix->yy ) -
|
||||
FT_MulFix( matrix->xy, matrix->yx );
|
||||
|
||||
if ( !delta )
|
||||
return FT_Err_Invalid_Argument; /* matrix can't be inverted */
|
||||
|
||||
matrix->xy = - FT_DivFix( matrix->xy, delta );
|
||||
matrix->yx = - FT_DivFix( matrix->yx, delta );
|
||||
|
||||
xx = matrix->xx;
|
||||
yy = matrix->yy;
|
||||
|
||||
matrix->xx = FT_DivFix( yy, delta );
|
||||
matrix->yy = FT_DivFix( xx, delta );
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcalc.h */
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Matrix_Multiply_Scaled( const FT_Matrix* a,
|
||||
FT_Matrix *b,
|
||||
FT_Long scaling )
|
||||
{
|
||||
FT_Fixed xx, xy, yx, yy;
|
||||
|
||||
FT_Long val = 0x10000L * scaling;
|
||||
|
||||
|
||||
if ( !a || !b )
|
||||
return;
|
||||
|
||||
xx = FT_MulDiv( a->xx, b->xx, val ) + FT_MulDiv( a->xy, b->yx, val );
|
||||
xy = FT_MulDiv( a->xx, b->xy, val ) + FT_MulDiv( a->xy, b->yy, val );
|
||||
yx = FT_MulDiv( a->yx, b->xx, val ) + FT_MulDiv( a->yy, b->yx, val );
|
||||
yy = FT_MulDiv( a->yx, b->xy, val ) + FT_MulDiv( a->yy, b->yy, val );
|
||||
|
||||
b->xx = xx; b->xy = xy;
|
||||
b->yx = yx; b->yy = yy;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcalc.h */
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Vector_Transform_Scaled( FT_Vector* vector,
|
||||
const FT_Matrix* matrix,
|
||||
FT_Long scaling )
|
||||
{
|
||||
FT_Pos xz, yz;
|
||||
|
||||
FT_Long val = 0x10000L * scaling;
|
||||
|
||||
|
||||
if ( !vector || !matrix )
|
||||
return;
|
||||
|
||||
xz = FT_MulDiv( vector->x, matrix->xx, val ) +
|
||||
FT_MulDiv( vector->y, matrix->xy, val );
|
||||
|
||||
yz = FT_MulDiv( vector->x, matrix->yx, val ) +
|
||||
FT_MulDiv( vector->y, matrix->yy, val );
|
||||
|
||||
vector->x = xz;
|
||||
vector->y = yz;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcalc.h */
|
||||
|
||||
FT_BASE_DEF( FT_Int32 )
|
||||
FT_SqrtFixed( FT_Int32 x )
|
||||
{
|
||||
FT_UInt32 root, rem_hi, rem_lo, test_div;
|
||||
FT_Int count;
|
||||
|
||||
|
||||
root = 0;
|
||||
|
||||
if ( x > 0 )
|
||||
{
|
||||
rem_hi = 0;
|
||||
rem_lo = x;
|
||||
count = 24;
|
||||
do
|
||||
{
|
||||
rem_hi = ( rem_hi << 2 ) | ( rem_lo >> 30 );
|
||||
rem_lo <<= 2;
|
||||
root <<= 1;
|
||||
test_div = ( root << 1 ) + 1;
|
||||
|
||||
if ( rem_hi >= test_div )
|
||||
{
|
||||
rem_hi -= test_div;
|
||||
root += 1;
|
||||
}
|
||||
} while ( --count );
|
||||
}
|
||||
|
||||
return (FT_Int32)root;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcalc.h */
|
||||
|
||||
FT_BASE_DEF( FT_Int )
|
||||
ft_corner_orientation( FT_Pos in_x,
|
||||
FT_Pos in_y,
|
||||
FT_Pos out_x,
|
||||
FT_Pos out_y )
|
||||
{
|
||||
FT_Long result; /* avoid overflow on 16-bit system */
|
||||
|
||||
|
||||
/* deal with the trivial cases quickly */
|
||||
if ( in_y == 0 )
|
||||
{
|
||||
if ( in_x >= 0 )
|
||||
result = out_y;
|
||||
else
|
||||
result = -out_y;
|
||||
}
|
||||
else if ( in_x == 0 )
|
||||
{
|
||||
if ( in_y >= 0 )
|
||||
result = -out_x;
|
||||
else
|
||||
result = out_x;
|
||||
}
|
||||
else if ( out_y == 0 )
|
||||
{
|
||||
if ( out_x >= 0 )
|
||||
result = in_y;
|
||||
else
|
||||
result = -in_y;
|
||||
}
|
||||
else if ( out_x == 0 )
|
||||
{
|
||||
if ( out_y >= 0 )
|
||||
result = -in_x;
|
||||
else
|
||||
result = in_x;
|
||||
}
|
||||
else /* general case */
|
||||
{
|
||||
#ifdef FT_LONG64
|
||||
|
||||
FT_Int64 delta = (FT_Int64)in_x * out_y - (FT_Int64)in_y * out_x;
|
||||
|
||||
|
||||
if ( delta == 0 )
|
||||
result = 0;
|
||||
else
|
||||
result = 1 - 2 * ( delta < 0 );
|
||||
|
||||
#else
|
||||
|
||||
FT_Int64 z1, z2;
|
||||
|
||||
|
||||
/* XXX: this function does not allow 64-bit arguments */
|
||||
ft_multo64( (FT_Int32)in_x, (FT_Int32)out_y, &z1 );
|
||||
ft_multo64( (FT_Int32)in_y, (FT_Int32)out_x, &z2 );
|
||||
|
||||
if ( z1.hi > z2.hi )
|
||||
result = +1;
|
||||
else if ( z1.hi < z2.hi )
|
||||
result = -1;
|
||||
else if ( z1.lo > z2.lo )
|
||||
result = +1;
|
||||
else if ( z1.lo < z2.lo )
|
||||
result = -1;
|
||||
else
|
||||
result = 0;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/* XXX: only the sign of return value, +1/0/-1 must be used */
|
||||
return (FT_Int)result;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcalc.h */
|
||||
|
||||
FT_BASE_DEF( FT_Int )
|
||||
ft_corner_is_flat( FT_Pos in_x,
|
||||
FT_Pos in_y,
|
||||
FT_Pos out_x,
|
||||
FT_Pos out_y )
|
||||
{
|
||||
FT_Pos ax = in_x;
|
||||
FT_Pos ay = in_y;
|
||||
|
||||
FT_Pos d_in, d_out, d_corner;
|
||||
|
||||
|
||||
if ( ax < 0 )
|
||||
ax = -ax;
|
||||
if ( ay < 0 )
|
||||
ay = -ay;
|
||||
d_in = ax + ay;
|
||||
|
||||
ax = out_x;
|
||||
if ( ax < 0 )
|
||||
ax = -ax;
|
||||
ay = out_y;
|
||||
if ( ay < 0 )
|
||||
ay = -ay;
|
||||
d_out = ax + ay;
|
||||
|
||||
ax = out_x + in_x;
|
||||
if ( ax < 0 )
|
||||
ax = -ax;
|
||||
ay = out_y + in_y;
|
||||
if ( ay < 0 )
|
||||
ay = -ay;
|
||||
d_corner = ax + ay;
|
||||
|
||||
return ( d_in + d_out - d_corner ) < ( d_corner >> 4 );
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,117 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcid.c */
|
||||
/* */
|
||||
/* FreeType API for accessing CID font information. */
|
||||
/* */
|
||||
/* Copyright 2007, 2009 by Derek Clegg, Michael Toftdal. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CID_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_SERVICE_CID_H
|
||||
|
||||
|
||||
/* documentation is in ftcid.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_CID_Registry_Ordering_Supplement( FT_Face face,
|
||||
const char* *registry,
|
||||
const char* *ordering,
|
||||
FT_Int *supplement)
|
||||
{
|
||||
FT_Error error;
|
||||
const char* r = NULL;
|
||||
const char* o = NULL;
|
||||
FT_Int s = 0;
|
||||
|
||||
|
||||
error = FT_Err_Invalid_Argument;
|
||||
|
||||
if ( face )
|
||||
{
|
||||
FT_Service_CID service;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, CID );
|
||||
|
||||
if ( service && service->get_ros )
|
||||
error = service->get_ros( face, &r, &o, &s );
|
||||
}
|
||||
|
||||
if ( registry )
|
||||
*registry = r;
|
||||
|
||||
if ( ordering )
|
||||
*ordering = o;
|
||||
|
||||
if ( supplement )
|
||||
*supplement = s;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_CID_Is_Internally_CID_Keyed( FT_Face face,
|
||||
FT_Bool *is_cid )
|
||||
{
|
||||
FT_Error error = FT_Err_Invalid_Argument;
|
||||
FT_Bool ic = 0;
|
||||
|
||||
|
||||
if ( face )
|
||||
{
|
||||
FT_Service_CID service;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, CID );
|
||||
|
||||
if ( service && service->get_is_cid )
|
||||
error = service->get_is_cid( face, &ic);
|
||||
}
|
||||
|
||||
if ( is_cid )
|
||||
*is_cid = ic;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_CID_From_Glyph_Index( FT_Face face,
|
||||
FT_UInt glyph_index,
|
||||
FT_UInt *cid )
|
||||
{
|
||||
FT_Error error = FT_Err_Invalid_Argument;
|
||||
FT_UInt c = 0;
|
||||
|
||||
|
||||
if ( face )
|
||||
{
|
||||
FT_Service_CID service;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, CID );
|
||||
|
||||
if ( service && service->get_cid_from_glyph_index )
|
||||
error = service->get_cid_from_glyph_index( face, glyph_index, &c);
|
||||
}
|
||||
|
||||
if ( cid )
|
||||
*cid = c;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,997 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftdbgmem.c */
|
||||
/* */
|
||||
/* Memory debugger (body). */
|
||||
/* */
|
||||
/* Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2009 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CONFIG_CONFIG_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_MEMORY_H
|
||||
#include FT_SYSTEM_H
|
||||
#include FT_ERRORS_H
|
||||
#include FT_TYPES_H
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_MEMORY
|
||||
|
||||
#define KEEPALIVE /* `Keep alive' means that freed blocks aren't released
|
||||
* to the heap. This is useful to detect double-frees
|
||||
* or weird heap corruption, but it uses large amounts of
|
||||
* memory, however.
|
||||
*/
|
||||
|
||||
#include FT_CONFIG_STANDARD_LIBRARY_H
|
||||
|
||||
FT_BASE_DEF( const char* ) _ft_debug_file = 0;
|
||||
FT_BASE_DEF( long ) _ft_debug_lineno = 0;
|
||||
|
||||
extern void
|
||||
FT_DumpMemory( FT_Memory memory );
|
||||
|
||||
|
||||
typedef struct FT_MemSourceRec_* FT_MemSource;
|
||||
typedef struct FT_MemNodeRec_* FT_MemNode;
|
||||
typedef struct FT_MemTableRec_* FT_MemTable;
|
||||
|
||||
|
||||
#define FT_MEM_VAL( addr ) ((FT_PtrDist)(FT_Pointer)( addr ))
|
||||
|
||||
/*
|
||||
* This structure holds statistics for a single allocation/release
|
||||
* site. This is useful to know where memory operations happen the
|
||||
* most.
|
||||
*/
|
||||
typedef struct FT_MemSourceRec_
|
||||
{
|
||||
const char* file_name;
|
||||
long line_no;
|
||||
|
||||
FT_Long cur_blocks; /* current number of allocated blocks */
|
||||
FT_Long max_blocks; /* max. number of allocated blocks */
|
||||
FT_Long all_blocks; /* total number of blocks allocated */
|
||||
|
||||
FT_Long cur_size; /* current cumulative allocated size */
|
||||
FT_Long max_size; /* maximum cumulative allocated size */
|
||||
FT_Long all_size; /* total cumulative allocated size */
|
||||
|
||||
FT_Long cur_max; /* current maximum allocated size */
|
||||
|
||||
FT_UInt32 hash;
|
||||
FT_MemSource link;
|
||||
|
||||
} FT_MemSourceRec;
|
||||
|
||||
|
||||
/*
|
||||
* We don't need a resizable array for the memory sources, because
|
||||
* their number is pretty limited within FreeType.
|
||||
*/
|
||||
#define FT_MEM_SOURCE_BUCKETS 128
|
||||
|
||||
/*
|
||||
* This structure holds information related to a single allocated
|
||||
* memory block. If KEEPALIVE is defined, blocks that are freed by
|
||||
* FreeType are never released to the system. Instead, their `size'
|
||||
* field is set to -size. This is mainly useful to detect double frees,
|
||||
* at the price of large memory footprint during execution.
|
||||
*/
|
||||
typedef struct FT_MemNodeRec_
|
||||
{
|
||||
FT_Byte* address;
|
||||
FT_Long size; /* < 0 if the block was freed */
|
||||
|
||||
FT_MemSource source;
|
||||
|
||||
#ifdef KEEPALIVE
|
||||
const char* free_file_name;
|
||||
FT_Long free_line_no;
|
||||
#endif
|
||||
|
||||
FT_MemNode link;
|
||||
|
||||
} FT_MemNodeRec;
|
||||
|
||||
|
||||
/*
|
||||
* The global structure, containing compound statistics and all hash
|
||||
* tables.
|
||||
*/
|
||||
typedef struct FT_MemTableRec_
|
||||
{
|
||||
FT_ULong size;
|
||||
FT_ULong nodes;
|
||||
FT_MemNode* buckets;
|
||||
|
||||
FT_ULong alloc_total;
|
||||
FT_ULong alloc_current;
|
||||
FT_ULong alloc_max;
|
||||
FT_ULong alloc_count;
|
||||
|
||||
FT_Bool bound_total;
|
||||
FT_ULong alloc_total_max;
|
||||
|
||||
FT_Bool bound_count;
|
||||
FT_ULong alloc_count_max;
|
||||
|
||||
FT_MemSource sources[FT_MEM_SOURCE_BUCKETS];
|
||||
|
||||
FT_Bool keep_alive;
|
||||
|
||||
FT_Memory memory;
|
||||
FT_Pointer memory_user;
|
||||
FT_Alloc_Func alloc;
|
||||
FT_Free_Func free;
|
||||
FT_Realloc_Func realloc;
|
||||
|
||||
} FT_MemTableRec;
|
||||
|
||||
|
||||
#define FT_MEM_SIZE_MIN 7
|
||||
#define FT_MEM_SIZE_MAX 13845163
|
||||
|
||||
#define FT_FILENAME( x ) ((x) ? (x) : "unknown file")
|
||||
|
||||
|
||||
/*
|
||||
* Prime numbers are ugly to handle. It would be better to implement
|
||||
* L-Hashing, which is 10% faster and doesn't require divisions.
|
||||
*/
|
||||
static const FT_UInt ft_mem_primes[] =
|
||||
{
|
||||
7,
|
||||
11,
|
||||
19,
|
||||
37,
|
||||
73,
|
||||
109,
|
||||
163,
|
||||
251,
|
||||
367,
|
||||
557,
|
||||
823,
|
||||
1237,
|
||||
1861,
|
||||
2777,
|
||||
4177,
|
||||
6247,
|
||||
9371,
|
||||
14057,
|
||||
21089,
|
||||
31627,
|
||||
47431,
|
||||
71143,
|
||||
106721,
|
||||
160073,
|
||||
240101,
|
||||
360163,
|
||||
540217,
|
||||
810343,
|
||||
1215497,
|
||||
1823231,
|
||||
2734867,
|
||||
4102283,
|
||||
6153409,
|
||||
9230113,
|
||||
13845163,
|
||||
};
|
||||
|
||||
|
||||
static FT_ULong
|
||||
ft_mem_closest_prime( FT_ULong num )
|
||||
{
|
||||
FT_UInt i;
|
||||
|
||||
|
||||
for ( i = 0;
|
||||
i < sizeof ( ft_mem_primes ) / sizeof ( ft_mem_primes[0] ); i++ )
|
||||
if ( ft_mem_primes[i] > num )
|
||||
return ft_mem_primes[i];
|
||||
|
||||
return FT_MEM_SIZE_MAX;
|
||||
}
|
||||
|
||||
|
||||
extern void
|
||||
ft_mem_debug_panic( const char* fmt,
|
||||
... )
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
|
||||
printf( "FreeType.Debug: " );
|
||||
|
||||
va_start( ap, fmt );
|
||||
vprintf( fmt, ap );
|
||||
va_end( ap );
|
||||
|
||||
printf( "\n" );
|
||||
exit( EXIT_FAILURE );
|
||||
}
|
||||
|
||||
|
||||
static FT_Pointer
|
||||
ft_mem_table_alloc( FT_MemTable table,
|
||||
FT_Long size )
|
||||
{
|
||||
FT_Memory memory = table->memory;
|
||||
FT_Pointer block;
|
||||
|
||||
|
||||
memory->user = table->memory_user;
|
||||
block = table->alloc( memory, size );
|
||||
memory->user = table;
|
||||
|
||||
return block;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_mem_table_free( FT_MemTable table,
|
||||
FT_Pointer block )
|
||||
{
|
||||
FT_Memory memory = table->memory;
|
||||
|
||||
|
||||
memory->user = table->memory_user;
|
||||
table->free( memory, block );
|
||||
memory->user = table;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_mem_table_resize( FT_MemTable table )
|
||||
{
|
||||
FT_ULong new_size;
|
||||
|
||||
|
||||
new_size = ft_mem_closest_prime( table->nodes );
|
||||
if ( new_size != table->size )
|
||||
{
|
||||
FT_MemNode* new_buckets;
|
||||
FT_ULong i;
|
||||
|
||||
|
||||
new_buckets = (FT_MemNode *)
|
||||
ft_mem_table_alloc( table,
|
||||
new_size * sizeof ( FT_MemNode ) );
|
||||
if ( new_buckets == NULL )
|
||||
return;
|
||||
|
||||
FT_ARRAY_ZERO( new_buckets, new_size );
|
||||
|
||||
for ( i = 0; i < table->size; i++ )
|
||||
{
|
||||
FT_MemNode node, next, *pnode;
|
||||
FT_PtrDist hash;
|
||||
|
||||
|
||||
node = table->buckets[i];
|
||||
while ( node )
|
||||
{
|
||||
next = node->link;
|
||||
hash = FT_MEM_VAL( node->address ) % new_size;
|
||||
pnode = new_buckets + hash;
|
||||
|
||||
node->link = pnode[0];
|
||||
pnode[0] = node;
|
||||
|
||||
node = next;
|
||||
}
|
||||
}
|
||||
|
||||
if ( table->buckets )
|
||||
ft_mem_table_free( table, table->buckets );
|
||||
|
||||
table->buckets = new_buckets;
|
||||
table->size = new_size;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static FT_MemTable
|
||||
ft_mem_table_new( FT_Memory memory )
|
||||
{
|
||||
FT_MemTable table;
|
||||
|
||||
|
||||
table = (FT_MemTable)memory->alloc( memory, sizeof ( *table ) );
|
||||
if ( table == NULL )
|
||||
goto Exit;
|
||||
|
||||
FT_ZERO( table );
|
||||
|
||||
table->size = FT_MEM_SIZE_MIN;
|
||||
table->nodes = 0;
|
||||
|
||||
table->memory = memory;
|
||||
|
||||
table->memory_user = memory->user;
|
||||
|
||||
table->alloc = memory->alloc;
|
||||
table->realloc = memory->realloc;
|
||||
table->free = memory->free;
|
||||
|
||||
table->buckets = (FT_MemNode *)
|
||||
memory->alloc( memory,
|
||||
table->size * sizeof ( FT_MemNode ) );
|
||||
if ( table->buckets )
|
||||
FT_ARRAY_ZERO( table->buckets, table->size );
|
||||
else
|
||||
{
|
||||
memory->free( memory, table );
|
||||
table = NULL;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return table;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_mem_table_destroy( FT_MemTable table )
|
||||
{
|
||||
FT_ULong i;
|
||||
|
||||
|
||||
FT_DumpMemory( table->memory );
|
||||
|
||||
if ( table )
|
||||
{
|
||||
FT_Long leak_count = 0;
|
||||
FT_ULong leaks = 0;
|
||||
|
||||
|
||||
/* remove all blocks from the table, revealing leaked ones */
|
||||
for ( i = 0; i < table->size; i++ )
|
||||
{
|
||||
FT_MemNode *pnode = table->buckets + i, next, node = *pnode;
|
||||
|
||||
|
||||
while ( node )
|
||||
{
|
||||
next = node->link;
|
||||
node->link = 0;
|
||||
|
||||
if ( node->size > 0 )
|
||||
{
|
||||
printf(
|
||||
"leaked memory block at address %p, size %8ld in (%s:%ld)\n",
|
||||
node->address, node->size,
|
||||
FT_FILENAME( node->source->file_name ),
|
||||
node->source->line_no );
|
||||
|
||||
leak_count++;
|
||||
leaks += node->size;
|
||||
|
||||
ft_mem_table_free( table, node->address );
|
||||
}
|
||||
|
||||
node->address = NULL;
|
||||
node->size = 0;
|
||||
|
||||
ft_mem_table_free( table, node );
|
||||
node = next;
|
||||
}
|
||||
table->buckets[i] = 0;
|
||||
}
|
||||
|
||||
ft_mem_table_free( table, table->buckets );
|
||||
table->buckets = NULL;
|
||||
|
||||
table->size = 0;
|
||||
table->nodes = 0;
|
||||
|
||||
/* remove all sources */
|
||||
for ( i = 0; i < FT_MEM_SOURCE_BUCKETS; i++ )
|
||||
{
|
||||
FT_MemSource source, next;
|
||||
|
||||
|
||||
for ( source = table->sources[i]; source != NULL; source = next )
|
||||
{
|
||||
next = source->link;
|
||||
ft_mem_table_free( table, source );
|
||||
}
|
||||
|
||||
table->sources[i] = NULL;
|
||||
}
|
||||
|
||||
printf(
|
||||
"FreeType: total memory allocations = %ld\n", table->alloc_total );
|
||||
printf(
|
||||
"FreeType: maximum memory footprint = %ld\n", table->alloc_max );
|
||||
|
||||
ft_mem_table_free( table, table );
|
||||
|
||||
if ( leak_count > 0 )
|
||||
ft_mem_debug_panic(
|
||||
"FreeType: %ld bytes of memory leaked in %ld blocks\n",
|
||||
leaks, leak_count );
|
||||
|
||||
printf( "FreeType: no memory leaks detected\n" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static FT_MemNode*
|
||||
ft_mem_table_get_nodep( FT_MemTable table,
|
||||
FT_Byte* address )
|
||||
{
|
||||
FT_PtrDist hash;
|
||||
FT_MemNode *pnode, node;
|
||||
|
||||
|
||||
hash = FT_MEM_VAL( address );
|
||||
pnode = table->buckets + ( hash % table->size );
|
||||
|
||||
for (;;)
|
||||
{
|
||||
node = pnode[0];
|
||||
if ( !node )
|
||||
break;
|
||||
|
||||
if ( node->address == address )
|
||||
break;
|
||||
|
||||
pnode = &node->link;
|
||||
}
|
||||
return pnode;
|
||||
}
|
||||
|
||||
|
||||
static FT_MemSource
|
||||
ft_mem_table_get_source( FT_MemTable table )
|
||||
{
|
||||
FT_UInt32 hash;
|
||||
FT_MemSource node, *pnode;
|
||||
|
||||
|
||||
/* cast to FT_PtrDist first since void* can be larger */
|
||||
/* than FT_UInt32 and GCC 4.1.1 emits a warning */
|
||||
hash = (FT_UInt32)(FT_PtrDist)(void*)_ft_debug_file +
|
||||
(FT_UInt32)( 5 * _ft_debug_lineno );
|
||||
pnode = &table->sources[hash % FT_MEM_SOURCE_BUCKETS];
|
||||
|
||||
for ( ;; )
|
||||
{
|
||||
node = *pnode;
|
||||
if ( node == NULL )
|
||||
break;
|
||||
|
||||
if ( node->file_name == _ft_debug_file &&
|
||||
node->line_no == _ft_debug_lineno )
|
||||
goto Exit;
|
||||
|
||||
pnode = &node->link;
|
||||
}
|
||||
|
||||
node = (FT_MemSource)ft_mem_table_alloc( table, sizeof ( *node ) );
|
||||
if ( node == NULL )
|
||||
ft_mem_debug_panic(
|
||||
"not enough memory to perform memory debugging\n" );
|
||||
|
||||
node->file_name = _ft_debug_file;
|
||||
node->line_no = _ft_debug_lineno;
|
||||
|
||||
node->cur_blocks = 0;
|
||||
node->max_blocks = 0;
|
||||
node->all_blocks = 0;
|
||||
|
||||
node->cur_size = 0;
|
||||
node->max_size = 0;
|
||||
node->all_size = 0;
|
||||
|
||||
node->cur_max = 0;
|
||||
|
||||
node->link = NULL;
|
||||
node->hash = hash;
|
||||
*pnode = node;
|
||||
|
||||
Exit:
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_mem_table_set( FT_MemTable table,
|
||||
FT_Byte* address,
|
||||
FT_ULong size,
|
||||
FT_Long delta )
|
||||
{
|
||||
FT_MemNode *pnode, node;
|
||||
|
||||
|
||||
if ( table )
|
||||
{
|
||||
FT_MemSource source;
|
||||
|
||||
|
||||
pnode = ft_mem_table_get_nodep( table, address );
|
||||
node = *pnode;
|
||||
if ( node )
|
||||
{
|
||||
if ( node->size < 0 )
|
||||
{
|
||||
/* This block was already freed. Our memory is now completely */
|
||||
/* corrupted! */
|
||||
/* This can only happen in keep-alive mode. */
|
||||
ft_mem_debug_panic(
|
||||
"memory heap corrupted (allocating freed block)" );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* This block was already allocated. This means that our memory */
|
||||
/* is also corrupted! */
|
||||
ft_mem_debug_panic(
|
||||
"memory heap corrupted (re-allocating allocated block at"
|
||||
" %p, of size %ld)\n"
|
||||
"org=%s:%d new=%s:%d\n",
|
||||
node->address, node->size,
|
||||
FT_FILENAME( node->source->file_name ), node->source->line_no,
|
||||
FT_FILENAME( _ft_debug_file ), _ft_debug_lineno );
|
||||
}
|
||||
}
|
||||
|
||||
/* we need to create a new node in this table */
|
||||
node = (FT_MemNode)ft_mem_table_alloc( table, sizeof ( *node ) );
|
||||
if ( node == NULL )
|
||||
ft_mem_debug_panic( "not enough memory to run memory tests" );
|
||||
|
||||
node->address = address;
|
||||
node->size = size;
|
||||
node->source = source = ft_mem_table_get_source( table );
|
||||
|
||||
if ( delta == 0 )
|
||||
{
|
||||
/* this is an allocation */
|
||||
source->all_blocks++;
|
||||
source->cur_blocks++;
|
||||
if ( source->cur_blocks > source->max_blocks )
|
||||
source->max_blocks = source->cur_blocks;
|
||||
}
|
||||
|
||||
if ( size > (FT_ULong)source->cur_max )
|
||||
source->cur_max = size;
|
||||
|
||||
if ( delta != 0 )
|
||||
{
|
||||
/* we are growing or shrinking a reallocated block */
|
||||
source->cur_size += delta;
|
||||
table->alloc_current += delta;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* we are allocating a new block */
|
||||
source->cur_size += size;
|
||||
table->alloc_current += size;
|
||||
}
|
||||
|
||||
source->all_size += size;
|
||||
|
||||
if ( source->cur_size > source->max_size )
|
||||
source->max_size = source->cur_size;
|
||||
|
||||
node->free_file_name = NULL;
|
||||
node->free_line_no = 0;
|
||||
|
||||
node->link = pnode[0];
|
||||
|
||||
pnode[0] = node;
|
||||
table->nodes++;
|
||||
|
||||
table->alloc_total += size;
|
||||
|
||||
if ( table->alloc_current > table->alloc_max )
|
||||
table->alloc_max = table->alloc_current;
|
||||
|
||||
if ( table->nodes * 3 < table->size ||
|
||||
table->size * 3 < table->nodes )
|
||||
ft_mem_table_resize( table );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_mem_table_remove( FT_MemTable table,
|
||||
FT_Byte* address,
|
||||
FT_Long delta )
|
||||
{
|
||||
if ( table )
|
||||
{
|
||||
FT_MemNode *pnode, node;
|
||||
|
||||
|
||||
pnode = ft_mem_table_get_nodep( table, address );
|
||||
node = *pnode;
|
||||
if ( node )
|
||||
{
|
||||
FT_MemSource source;
|
||||
|
||||
|
||||
if ( node->size < 0 )
|
||||
ft_mem_debug_panic(
|
||||
"freeing memory block at %p more than once at (%s:%ld)\n"
|
||||
"block allocated at (%s:%ld) and released at (%s:%ld)",
|
||||
address,
|
||||
FT_FILENAME( _ft_debug_file ), _ft_debug_lineno,
|
||||
FT_FILENAME( node->source->file_name ), node->source->line_no,
|
||||
FT_FILENAME( node->free_file_name ), node->free_line_no );
|
||||
|
||||
/* scramble the node's content for additional safety */
|
||||
FT_MEM_SET( address, 0xF3, node->size );
|
||||
|
||||
if ( delta == 0 )
|
||||
{
|
||||
source = node->source;
|
||||
|
||||
source->cur_blocks--;
|
||||
source->cur_size -= node->size;
|
||||
|
||||
table->alloc_current -= node->size;
|
||||
}
|
||||
|
||||
if ( table->keep_alive )
|
||||
{
|
||||
/* we simply invert the node's size to indicate that the node */
|
||||
/* was freed. */
|
||||
node->size = -node->size;
|
||||
node->free_file_name = _ft_debug_file;
|
||||
node->free_line_no = _ft_debug_lineno;
|
||||
}
|
||||
else
|
||||
{
|
||||
table->nodes--;
|
||||
|
||||
*pnode = node->link;
|
||||
|
||||
node->size = 0;
|
||||
node->source = NULL;
|
||||
|
||||
ft_mem_table_free( table, node );
|
||||
|
||||
if ( table->nodes * 3 < table->size ||
|
||||
table->size * 3 < table->nodes )
|
||||
ft_mem_table_resize( table );
|
||||
}
|
||||
}
|
||||
else
|
||||
ft_mem_debug_panic(
|
||||
"trying to free unknown block at %p in (%s:%ld)\n",
|
||||
address,
|
||||
FT_FILENAME( _ft_debug_file ), _ft_debug_lineno );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
extern FT_Pointer
|
||||
ft_mem_debug_alloc( FT_Memory memory,
|
||||
FT_Long size )
|
||||
{
|
||||
FT_MemTable table = (FT_MemTable)memory->user;
|
||||
FT_Byte* block;
|
||||
|
||||
|
||||
if ( size <= 0 )
|
||||
ft_mem_debug_panic( "negative block size allocation (%ld)", size );
|
||||
|
||||
/* return NULL if the maximum number of allocations was reached */
|
||||
if ( table->bound_count &&
|
||||
table->alloc_count >= table->alloc_count_max )
|
||||
return NULL;
|
||||
|
||||
/* return NULL if this allocation would overflow the maximum heap size */
|
||||
if ( table->bound_total &&
|
||||
table->alloc_total_max - table->alloc_current > (FT_ULong)size )
|
||||
return NULL;
|
||||
|
||||
block = (FT_Byte *)ft_mem_table_alloc( table, size );
|
||||
if ( block )
|
||||
{
|
||||
ft_mem_table_set( table, block, (FT_ULong)size, 0 );
|
||||
|
||||
table->alloc_count++;
|
||||
}
|
||||
|
||||
_ft_debug_file = "<unknown>";
|
||||
_ft_debug_lineno = 0;
|
||||
|
||||
return (FT_Pointer)block;
|
||||
}
|
||||
|
||||
|
||||
extern void
|
||||
ft_mem_debug_free( FT_Memory memory,
|
||||
FT_Pointer block )
|
||||
{
|
||||
FT_MemTable table = (FT_MemTable)memory->user;
|
||||
|
||||
|
||||
if ( block == NULL )
|
||||
ft_mem_debug_panic( "trying to free NULL in (%s:%ld)",
|
||||
FT_FILENAME( _ft_debug_file ),
|
||||
_ft_debug_lineno );
|
||||
|
||||
ft_mem_table_remove( table, (FT_Byte*)block, 0 );
|
||||
|
||||
if ( !table->keep_alive )
|
||||
ft_mem_table_free( table, block );
|
||||
|
||||
table->alloc_count--;
|
||||
|
||||
_ft_debug_file = "<unknown>";
|
||||
_ft_debug_lineno = 0;
|
||||
}
|
||||
|
||||
|
||||
extern FT_Pointer
|
||||
ft_mem_debug_realloc( FT_Memory memory,
|
||||
FT_Long cur_size,
|
||||
FT_Long new_size,
|
||||
FT_Pointer block )
|
||||
{
|
||||
FT_MemTable table = (FT_MemTable)memory->user;
|
||||
FT_MemNode node, *pnode;
|
||||
FT_Pointer new_block;
|
||||
FT_Long delta;
|
||||
|
||||
const char* file_name = FT_FILENAME( _ft_debug_file );
|
||||
FT_Long line_no = _ft_debug_lineno;
|
||||
|
||||
|
||||
/* unlikely, but possible */
|
||||
if ( new_size == cur_size )
|
||||
return block;
|
||||
|
||||
/* the following is valid according to ANSI C */
|
||||
#if 0
|
||||
if ( block == NULL || cur_size == 0 )
|
||||
ft_mem_debug_panic( "trying to reallocate NULL in (%s:%ld)",
|
||||
file_name, line_no );
|
||||
#endif
|
||||
|
||||
/* while the following is allowed in ANSI C also, we abort since */
|
||||
/* such case should be handled by FreeType. */
|
||||
if ( new_size <= 0 )
|
||||
ft_mem_debug_panic(
|
||||
"trying to reallocate %p to size 0 (current is %ld) in (%s:%ld)",
|
||||
block, cur_size, file_name, line_no );
|
||||
|
||||
/* check `cur_size' value */
|
||||
pnode = ft_mem_table_get_nodep( table, (FT_Byte*)block );
|
||||
node = *pnode;
|
||||
if ( !node )
|
||||
ft_mem_debug_panic(
|
||||
"trying to reallocate unknown block at %p in (%s:%ld)",
|
||||
block, file_name, line_no );
|
||||
|
||||
if ( node->size <= 0 )
|
||||
ft_mem_debug_panic(
|
||||
"trying to reallocate freed block at %p in (%s:%ld)",
|
||||
block, file_name, line_no );
|
||||
|
||||
if ( node->size != cur_size )
|
||||
ft_mem_debug_panic( "invalid ft_realloc request for %p. cur_size is "
|
||||
"%ld instead of %ld in (%s:%ld)",
|
||||
block, cur_size, node->size, file_name, line_no );
|
||||
|
||||
/* return NULL if the maximum number of allocations was reached */
|
||||
if ( table->bound_count &&
|
||||
table->alloc_count >= table->alloc_count_max )
|
||||
return NULL;
|
||||
|
||||
delta = (FT_Long)( new_size - cur_size );
|
||||
|
||||
/* return NULL if this allocation would overflow the maximum heap size */
|
||||
if ( delta > 0 &&
|
||||
table->bound_total &&
|
||||
table->alloc_current + (FT_ULong)delta > table->alloc_total_max )
|
||||
return NULL;
|
||||
|
||||
new_block = (FT_Byte *)ft_mem_table_alloc( table, new_size );
|
||||
if ( new_block == NULL )
|
||||
return NULL;
|
||||
|
||||
ft_mem_table_set( table, (FT_Byte*)new_block, new_size, delta );
|
||||
|
||||
ft_memcpy( new_block, block, cur_size < new_size ? cur_size : new_size );
|
||||
|
||||
ft_mem_table_remove( table, (FT_Byte*)block, delta );
|
||||
|
||||
_ft_debug_file = "<unknown>";
|
||||
_ft_debug_lineno = 0;
|
||||
|
||||
if ( !table->keep_alive )
|
||||
ft_mem_table_free( table, block );
|
||||
|
||||
return new_block;
|
||||
}
|
||||
|
||||
|
||||
extern FT_Int
|
||||
ft_mem_debug_init( FT_Memory memory )
|
||||
{
|
||||
FT_MemTable table;
|
||||
FT_Int result = 0;
|
||||
|
||||
|
||||
if ( getenv( "FT2_DEBUG_MEMORY" ) )
|
||||
{
|
||||
table = ft_mem_table_new( memory );
|
||||
if ( table )
|
||||
{
|
||||
const char* p;
|
||||
|
||||
|
||||
memory->user = table;
|
||||
memory->alloc = ft_mem_debug_alloc;
|
||||
memory->realloc = ft_mem_debug_realloc;
|
||||
memory->free = ft_mem_debug_free;
|
||||
|
||||
p = getenv( "FT2_ALLOC_TOTAL_MAX" );
|
||||
if ( p != NULL )
|
||||
{
|
||||
FT_Long total_max = ft_atol( p );
|
||||
|
||||
|
||||
if ( total_max > 0 )
|
||||
{
|
||||
table->bound_total = 1;
|
||||
table->alloc_total_max = (FT_ULong)total_max;
|
||||
}
|
||||
}
|
||||
|
||||
p = getenv( "FT2_ALLOC_COUNT_MAX" );
|
||||
if ( p != NULL )
|
||||
{
|
||||
FT_Long total_count = ft_atol( p );
|
||||
|
||||
|
||||
if ( total_count > 0 )
|
||||
{
|
||||
table->bound_count = 1;
|
||||
table->alloc_count_max = (FT_ULong)total_count;
|
||||
}
|
||||
}
|
||||
|
||||
p = getenv( "FT2_KEEP_ALIVE" );
|
||||
if ( p != NULL )
|
||||
{
|
||||
FT_Long keep_alive = ft_atol( p );
|
||||
|
||||
|
||||
if ( keep_alive > 0 )
|
||||
table->keep_alive = 1;
|
||||
}
|
||||
|
||||
result = 1;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
extern void
|
||||
ft_mem_debug_done( FT_Memory memory )
|
||||
{
|
||||
FT_MemTable table = (FT_MemTable)memory->user;
|
||||
|
||||
|
||||
if ( table )
|
||||
{
|
||||
memory->free = table->free;
|
||||
memory->realloc = table->realloc;
|
||||
memory->alloc = table->alloc;
|
||||
|
||||
ft_mem_table_destroy( table );
|
||||
memory->user = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
static int
|
||||
ft_mem_source_compare( const void* p1,
|
||||
const void* p2 )
|
||||
{
|
||||
FT_MemSource s1 = *(FT_MemSource*)p1;
|
||||
FT_MemSource s2 = *(FT_MemSource*)p2;
|
||||
|
||||
|
||||
if ( s2->max_size > s1->max_size )
|
||||
return 1;
|
||||
else if ( s2->max_size < s1->max_size )
|
||||
return -1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
extern void
|
||||
FT_DumpMemory( FT_Memory memory )
|
||||
{
|
||||
FT_MemTable table = (FT_MemTable)memory->user;
|
||||
|
||||
|
||||
if ( table )
|
||||
{
|
||||
FT_MemSource* bucket = table->sources;
|
||||
FT_MemSource* limit = bucket + FT_MEM_SOURCE_BUCKETS;
|
||||
FT_MemSource* sources;
|
||||
FT_UInt nn, count;
|
||||
const char* fmt;
|
||||
|
||||
|
||||
count = 0;
|
||||
for ( ; bucket < limit; bucket++ )
|
||||
{
|
||||
FT_MemSource source = *bucket;
|
||||
|
||||
|
||||
for ( ; source; source = source->link )
|
||||
count++;
|
||||
}
|
||||
|
||||
sources = (FT_MemSource*)ft_mem_table_alloc(
|
||||
table, sizeof ( *sources ) * count );
|
||||
|
||||
count = 0;
|
||||
for ( bucket = table->sources; bucket < limit; bucket++ )
|
||||
{
|
||||
FT_MemSource source = *bucket;
|
||||
|
||||
|
||||
for ( ; source; source = source->link )
|
||||
sources[count++] = source;
|
||||
}
|
||||
|
||||
ft_qsort( sources, count, sizeof ( *sources ), ft_mem_source_compare );
|
||||
|
||||
printf( "FreeType Memory Dump: "
|
||||
"current=%ld max=%ld total=%ld count=%ld\n",
|
||||
table->alloc_current, table->alloc_max,
|
||||
table->alloc_total, table->alloc_count );
|
||||
printf( " block block sizes sizes sizes source\n" );
|
||||
printf( " count high sum highsum max location\n" );
|
||||
printf( "-------------------------------------------------\n" );
|
||||
|
||||
fmt = "%6ld %6ld %8ld %8ld %8ld %s:%d\n";
|
||||
|
||||
for ( nn = 0; nn < count; nn++ )
|
||||
{
|
||||
FT_MemSource source = sources[nn];
|
||||
|
||||
|
||||
printf( fmt,
|
||||
source->cur_blocks, source->max_blocks,
|
||||
source->cur_size, source->max_size, source->cur_max,
|
||||
FT_FILENAME( source->file_name ),
|
||||
source->line_no );
|
||||
}
|
||||
printf( "------------------------------------------------\n" );
|
||||
|
||||
ft_mem_table_free( table, sources );
|
||||
}
|
||||
}
|
||||
|
||||
#else /* !FT_DEBUG_MEMORY */
|
||||
|
||||
/* ANSI C doesn't like empty source files */
|
||||
typedef int _debug_mem_dummy;
|
||||
|
||||
#endif /* !FT_DEBUG_MEMORY */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,246 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftdebug.c */
|
||||
/* */
|
||||
/* Debugging and logging component (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2002, 2004, 2008 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 component contains various macros and functions used to ease the */
|
||||
/* debugging of the FreeType engine. Its main purpose is in assertion */
|
||||
/* checking, tracing, and error detection. */
|
||||
/* */
|
||||
/* There are now three debugging modes: */
|
||||
/* */
|
||||
/* - trace mode */
|
||||
/* */
|
||||
/* Error and trace messages are sent to the log file (which can be the */
|
||||
/* standard error output). */
|
||||
/* */
|
||||
/* - error mode */
|
||||
/* */
|
||||
/* Only error messages are generated. */
|
||||
/* */
|
||||
/* - release mode: */
|
||||
/* */
|
||||
/* No error message is sent or generated. The code is free from any */
|
||||
/* debugging parts. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_LEVEL_ERROR
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Message( const char* fmt, ... )
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
|
||||
va_start( ap, fmt );
|
||||
vfprintf( stderr, fmt, ap );
|
||||
va_end( ap );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Panic( const char* fmt, ... )
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
|
||||
va_start( ap, fmt );
|
||||
vfprintf( stderr, fmt, ap );
|
||||
va_end( ap );
|
||||
|
||||
exit( EXIT_FAILURE );
|
||||
}
|
||||
|
||||
#endif /* FT_DEBUG_LEVEL_ERROR */
|
||||
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_LEVEL_TRACE
|
||||
|
||||
/* array of trace levels, initialized to 0 */
|
||||
int ft_trace_levels[trace_count];
|
||||
|
||||
|
||||
/* define array of trace toggle names */
|
||||
#define FT_TRACE_DEF( x ) #x ,
|
||||
|
||||
static const char* ft_trace_toggles[trace_count + 1] =
|
||||
{
|
||||
#include FT_INTERNAL_TRACE_H
|
||||
NULL
|
||||
};
|
||||
|
||||
#undef FT_TRACE_DEF
|
||||
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( FT_Int )
|
||||
FT_Trace_Get_Count( void )
|
||||
{
|
||||
return trace_count;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftdebug.h */
|
||||
|
||||
FT_BASE_DEF( const char * )
|
||||
FT_Trace_Get_Name( FT_Int idx )
|
||||
{
|
||||
int max = FT_Trace_Get_Count();
|
||||
|
||||
|
||||
if ( idx < max )
|
||||
return ft_trace_toggles[idx];
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Initialize the tracing sub-system. This is done by retrieving the */
|
||||
/* value of the `FT2_DEBUG' environment variable. It must be a list of */
|
||||
/* toggles, separated by spaces, `;', or `,'. Example: */
|
||||
/* */
|
||||
/* export FT2_DEBUG="any:3 memory:7 stream:5" */
|
||||
/* */
|
||||
/* This requests that all levels be set to 3, except the trace level for */
|
||||
/* the memory and stream components which are set to 7 and 5, */
|
||||
/* respectively. */
|
||||
/* */
|
||||
/* See the file <include/freetype/internal/fttrace.h> for details of the */
|
||||
/* available toggle names. */
|
||||
/* */
|
||||
/* The level must be between 0 and 7; 0 means quiet (except for serious */
|
||||
/* runtime errors), and 7 means _very_ verbose. */
|
||||
/* */
|
||||
FT_BASE_DEF( void )
|
||||
ft_debug_init( void )
|
||||
{
|
||||
const char* ft2_debug = getenv( "FT2_DEBUG" );
|
||||
|
||||
|
||||
if ( ft2_debug )
|
||||
{
|
||||
const char* p = ft2_debug;
|
||||
const char* q;
|
||||
|
||||
|
||||
for ( ; *p; p++ )
|
||||
{
|
||||
/* skip leading whitespace and separators */
|
||||
if ( *p == ' ' || *p == '\t' || *p == ',' || *p == ';' || *p == '=' )
|
||||
continue;
|
||||
|
||||
/* read toggle name, followed by ':' */
|
||||
q = p;
|
||||
while ( *p && *p != ':' )
|
||||
p++;
|
||||
|
||||
if ( *p == ':' && p > q )
|
||||
{
|
||||
FT_Int n, i, len = (FT_Int)( p - q );
|
||||
FT_Int level = -1, found = -1;
|
||||
|
||||
|
||||
for ( n = 0; n < trace_count; n++ )
|
||||
{
|
||||
const char* toggle = ft_trace_toggles[n];
|
||||
|
||||
|
||||
for ( i = 0; i < len; i++ )
|
||||
{
|
||||
if ( toggle[i] != q[i] )
|
||||
break;
|
||||
}
|
||||
|
||||
if ( i == len && toggle[i] == 0 )
|
||||
{
|
||||
found = n;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* read level */
|
||||
p++;
|
||||
if ( *p )
|
||||
{
|
||||
level = *p++ - '0';
|
||||
if ( level < 0 || level > 7 )
|
||||
level = -1;
|
||||
}
|
||||
|
||||
if ( found >= 0 && level >= 0 )
|
||||
{
|
||||
if ( found == trace_any )
|
||||
{
|
||||
/* special case for `any' */
|
||||
for ( n = 0; n < trace_count; n++ )
|
||||
ft_trace_levels[n] = level;
|
||||
}
|
||||
else
|
||||
ft_trace_levels[found] = level;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#else /* !FT_DEBUG_LEVEL_TRACE */
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
ft_debug_init( void )
|
||||
{
|
||||
/* nothing */
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Int )
|
||||
FT_Trace_Get_Count( void )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( const char * )
|
||||
FT_Trace_Get_Name( FT_Int idx )
|
||||
{
|
||||
FT_UNUSED( idx );
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
#endif /* !FT_DEBUG_LEVEL_TRACE */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,62 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftfstype.c */
|
||||
/* */
|
||||
/* FreeType utility file to access FSType data (body). */
|
||||
/* */
|
||||
/* Copyright 2008, 2009 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_TYPE1_TABLES_H
|
||||
#include FT_TRUETYPE_TABLES_H
|
||||
#include FT_INTERNAL_SERVICE_H
|
||||
#include FT_SERVICE_POSTSCRIPT_INFO_H
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_UShort )
|
||||
FT_Get_FSType_Flags( FT_Face face )
|
||||
{
|
||||
TT_OS2* os2;
|
||||
|
||||
|
||||
/* first, try to get the fs_type directly from the font */
|
||||
if ( face )
|
||||
{
|
||||
FT_Service_PsInfo service = NULL;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, POSTSCRIPT_INFO );
|
||||
|
||||
if ( service && service->ps_get_font_extra )
|
||||
{
|
||||
PS_FontExtraRec extra;
|
||||
|
||||
|
||||
if ( !service->ps_get_font_extra( face, &extra ) &&
|
||||
extra.fs_type != 0 )
|
||||
return extra.fs_type;
|
||||
}
|
||||
}
|
||||
|
||||
/* look at FSType before fsType for Type42 */
|
||||
|
||||
if ( ( os2 = (TT_OS2*)FT_Get_Sfnt_Table( face, ft_sfnt_os2 ) ) != NULL &&
|
||||
os2->version != 0xFFFFU )
|
||||
return os2->fsType;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,61 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftgasp.c */
|
||||
/* */
|
||||
/* Access of TrueType's `gasp' table (body). */
|
||||
/* */
|
||||
/* Copyright 2007 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_GASP_H
|
||||
#include FT_INTERNAL_TRUETYPE_TYPES_H
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Int )
|
||||
FT_Get_Gasp( FT_Face face,
|
||||
FT_UInt ppem )
|
||||
{
|
||||
FT_Int result = FT_GASP_NO_TABLE;
|
||||
|
||||
|
||||
if ( face && FT_IS_SFNT( face ) )
|
||||
{
|
||||
TT_Face ttface = (TT_Face)face;
|
||||
|
||||
|
||||
if ( ttface->gasp.numRanges > 0 )
|
||||
{
|
||||
TT_GaspRange range = ttface->gasp.gaspRanges;
|
||||
TT_GaspRange range_end = range + ttface->gasp.numRanges;
|
||||
|
||||
|
||||
while ( ppem > range->maxPPEM )
|
||||
{
|
||||
range++;
|
||||
if ( range >= range_end )
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
result = range->gaspFlag;
|
||||
|
||||
/* ensure that we don't have spurious bits */
|
||||
if ( ttface->gasp.version == 0 )
|
||||
result &= 3;
|
||||
}
|
||||
}
|
||||
Exit:
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,401 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftgloadr.c */
|
||||
/* */
|
||||
/* The FreeType glyph loader (body). */
|
||||
/* */
|
||||
/* Copyright 2002, 2003, 2004, 2005, 2006, 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_GLYPH_LOADER_H
|
||||
#include FT_INTERNAL_MEMORY_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_gloader
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** *****/
|
||||
/***** G L Y P H L O A D E R *****/
|
||||
/***** *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The glyph loader is a simple object which is used to load a set of */
|
||||
/* glyphs easily. It is critical for the correct loading of composites. */
|
||||
/* */
|
||||
/* Ideally, one can see it as a stack of abstract `glyph' objects. */
|
||||
/* */
|
||||
/* loader.base Is really the bottom of the stack. It describes a */
|
||||
/* single glyph image made of the juxtaposition of */
|
||||
/* several glyphs (those `in the stack'). */
|
||||
/* */
|
||||
/* loader.current Describes the top of the stack, on which a new */
|
||||
/* glyph can be loaded. */
|
||||
/* */
|
||||
/* Rewind Clears the stack. */
|
||||
/* Prepare Set up `loader.current' for addition of a new glyph */
|
||||
/* image. */
|
||||
/* Add Add the `current' glyph image to the `base' one, */
|
||||
/* and prepare for another one. */
|
||||
/* */
|
||||
/* The glyph loader is now a base object. Each driver used to */
|
||||
/* re-implement it in one way or the other, which wasted code and */
|
||||
/* energy. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/* create a new glyph loader */
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_GlyphLoader_New( FT_Memory memory,
|
||||
FT_GlyphLoader *aloader )
|
||||
{
|
||||
FT_GlyphLoader loader = NULL;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
if ( !FT_NEW( loader ) )
|
||||
{
|
||||
loader->memory = memory;
|
||||
*aloader = loader;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* rewind the glyph loader - reset counters to 0 */
|
||||
FT_BASE_DEF( void )
|
||||
FT_GlyphLoader_Rewind( FT_GlyphLoader loader )
|
||||
{
|
||||
FT_GlyphLoad base = &loader->base;
|
||||
FT_GlyphLoad current = &loader->current;
|
||||
|
||||
|
||||
base->outline.n_points = 0;
|
||||
base->outline.n_contours = 0;
|
||||
base->num_subglyphs = 0;
|
||||
|
||||
*current = *base;
|
||||
}
|
||||
|
||||
|
||||
/* reset the glyph loader, frees all allocated tables */
|
||||
/* and starts from zero */
|
||||
FT_BASE_DEF( void )
|
||||
FT_GlyphLoader_Reset( FT_GlyphLoader loader )
|
||||
{
|
||||
FT_Memory memory = loader->memory;
|
||||
|
||||
|
||||
FT_FREE( loader->base.outline.points );
|
||||
FT_FREE( loader->base.outline.tags );
|
||||
FT_FREE( loader->base.outline.contours );
|
||||
FT_FREE( loader->base.extra_points );
|
||||
FT_FREE( loader->base.subglyphs );
|
||||
|
||||
loader->base.extra_points2 = NULL;
|
||||
|
||||
loader->max_points = 0;
|
||||
loader->max_contours = 0;
|
||||
loader->max_subglyphs = 0;
|
||||
|
||||
FT_GlyphLoader_Rewind( loader );
|
||||
}
|
||||
|
||||
|
||||
/* delete a glyph loader */
|
||||
FT_BASE_DEF( void )
|
||||
FT_GlyphLoader_Done( FT_GlyphLoader loader )
|
||||
{
|
||||
if ( loader )
|
||||
{
|
||||
FT_Memory memory = loader->memory;
|
||||
|
||||
|
||||
FT_GlyphLoader_Reset( loader );
|
||||
FT_FREE( loader );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* re-adjust the `current' outline fields */
|
||||
static void
|
||||
FT_GlyphLoader_Adjust_Points( FT_GlyphLoader loader )
|
||||
{
|
||||
FT_Outline* base = &loader->base.outline;
|
||||
FT_Outline* current = &loader->current.outline;
|
||||
|
||||
|
||||
current->points = base->points + base->n_points;
|
||||
current->tags = base->tags + base->n_points;
|
||||
current->contours = base->contours + base->n_contours;
|
||||
|
||||
/* handle extra points table - if any */
|
||||
if ( loader->use_extra )
|
||||
{
|
||||
loader->current.extra_points = loader->base.extra_points +
|
||||
base->n_points;
|
||||
|
||||
loader->current.extra_points2 = loader->base.extra_points2 +
|
||||
base->n_points;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_GlyphLoader_CreateExtra( FT_GlyphLoader loader )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory = loader->memory;
|
||||
|
||||
|
||||
if ( !FT_NEW_ARRAY( loader->base.extra_points, 2 * loader->max_points ) )
|
||||
{
|
||||
loader->use_extra = 1;
|
||||
loader->base.extra_points2 = loader->base.extra_points +
|
||||
loader->max_points;
|
||||
|
||||
FT_GlyphLoader_Adjust_Points( loader );
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* re-adjust the `current' subglyphs field */
|
||||
static void
|
||||
FT_GlyphLoader_Adjust_Subglyphs( FT_GlyphLoader loader )
|
||||
{
|
||||
FT_GlyphLoad base = &loader->base;
|
||||
FT_GlyphLoad current = &loader->current;
|
||||
|
||||
|
||||
current->subglyphs = base->subglyphs + base->num_subglyphs;
|
||||
}
|
||||
|
||||
|
||||
/* Ensure that we can add `n_points' and `n_contours' to our glyph. */
|
||||
/* This function reallocates its outline tables if necessary. Note that */
|
||||
/* it DOESN'T change the number of points within the loader! */
|
||||
/* */
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_GlyphLoader_CheckPoints( FT_GlyphLoader loader,
|
||||
FT_UInt n_points,
|
||||
FT_UInt n_contours )
|
||||
{
|
||||
FT_Memory memory = loader->memory;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Outline* base = &loader->base.outline;
|
||||
FT_Outline* current = &loader->current.outline;
|
||||
FT_Bool adjust = 0;
|
||||
|
||||
FT_UInt new_max, old_max;
|
||||
|
||||
|
||||
/* check points & tags */
|
||||
new_max = base->n_points + current->n_points + n_points;
|
||||
old_max = loader->max_points;
|
||||
|
||||
if ( new_max > old_max )
|
||||
{
|
||||
new_max = FT_PAD_CEIL( new_max, 8 );
|
||||
|
||||
if ( new_max > FT_OUTLINE_POINTS_MAX )
|
||||
return FT_Err_Array_Too_Large;
|
||||
|
||||
if ( FT_RENEW_ARRAY( base->points, old_max, new_max ) ||
|
||||
FT_RENEW_ARRAY( base->tags, old_max, new_max ) )
|
||||
goto Exit;
|
||||
|
||||
if ( loader->use_extra )
|
||||
{
|
||||
if ( FT_RENEW_ARRAY( loader->base.extra_points,
|
||||
old_max * 2, new_max * 2 ) )
|
||||
goto Exit;
|
||||
|
||||
FT_ARRAY_MOVE( loader->base.extra_points + new_max,
|
||||
loader->base.extra_points + old_max,
|
||||
old_max );
|
||||
|
||||
loader->base.extra_points2 = loader->base.extra_points + new_max;
|
||||
}
|
||||
|
||||
adjust = 1;
|
||||
loader->max_points = new_max;
|
||||
}
|
||||
|
||||
/* check contours */
|
||||
old_max = loader->max_contours;
|
||||
new_max = base->n_contours + current->n_contours +
|
||||
n_contours;
|
||||
if ( new_max > old_max )
|
||||
{
|
||||
new_max = FT_PAD_CEIL( new_max, 4 );
|
||||
|
||||
if ( new_max > FT_OUTLINE_CONTOURS_MAX )
|
||||
return FT_Err_Array_Too_Large;
|
||||
|
||||
if ( FT_RENEW_ARRAY( base->contours, old_max, new_max ) )
|
||||
goto Exit;
|
||||
|
||||
adjust = 1;
|
||||
loader->max_contours = new_max;
|
||||
}
|
||||
|
||||
if ( adjust )
|
||||
FT_GlyphLoader_Adjust_Points( loader );
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* Ensure that we can add `n_subglyphs' to our glyph. this function */
|
||||
/* reallocates its subglyphs table if necessary. Note that it DOES */
|
||||
/* NOT change the number of subglyphs within the loader! */
|
||||
/* */
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_GlyphLoader_CheckSubGlyphs( FT_GlyphLoader loader,
|
||||
FT_UInt n_subs )
|
||||
{
|
||||
FT_Memory memory = loader->memory;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_UInt new_max, old_max;
|
||||
|
||||
FT_GlyphLoad base = &loader->base;
|
||||
FT_GlyphLoad current = &loader->current;
|
||||
|
||||
|
||||
new_max = base->num_subglyphs + current->num_subglyphs + n_subs;
|
||||
old_max = loader->max_subglyphs;
|
||||
if ( new_max > old_max )
|
||||
{
|
||||
new_max = FT_PAD_CEIL( new_max, 2 );
|
||||
if ( FT_RENEW_ARRAY( base->subglyphs, old_max, new_max ) )
|
||||
goto Exit;
|
||||
|
||||
loader->max_subglyphs = new_max;
|
||||
|
||||
FT_GlyphLoader_Adjust_Subglyphs( loader );
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* prepare loader for the addition of a new glyph on top of the base one */
|
||||
FT_BASE_DEF( void )
|
||||
FT_GlyphLoader_Prepare( FT_GlyphLoader loader )
|
||||
{
|
||||
FT_GlyphLoad current = &loader->current;
|
||||
|
||||
|
||||
current->outline.n_points = 0;
|
||||
current->outline.n_contours = 0;
|
||||
current->num_subglyphs = 0;
|
||||
|
||||
FT_GlyphLoader_Adjust_Points ( loader );
|
||||
FT_GlyphLoader_Adjust_Subglyphs( loader );
|
||||
}
|
||||
|
||||
|
||||
/* add current glyph to the base image - and prepare for another */
|
||||
FT_BASE_DEF( void )
|
||||
FT_GlyphLoader_Add( FT_GlyphLoader loader )
|
||||
{
|
||||
FT_GlyphLoad base;
|
||||
FT_GlyphLoad current;
|
||||
|
||||
FT_UInt n_curr_contours;
|
||||
FT_UInt n_base_points;
|
||||
FT_UInt n;
|
||||
|
||||
|
||||
if ( !loader )
|
||||
return;
|
||||
|
||||
base = &loader->base;
|
||||
current = &loader->current;
|
||||
|
||||
n_curr_contours = current->outline.n_contours;
|
||||
n_base_points = base->outline.n_points;
|
||||
|
||||
base->outline.n_points =
|
||||
(short)( base->outline.n_points + current->outline.n_points );
|
||||
base->outline.n_contours =
|
||||
(short)( base->outline.n_contours + current->outline.n_contours );
|
||||
|
||||
base->num_subglyphs += current->num_subglyphs;
|
||||
|
||||
/* adjust contours count in newest outline */
|
||||
for ( n = 0; n < n_curr_contours; n++ )
|
||||
current->outline.contours[n] =
|
||||
(short)( current->outline.contours[n] + n_base_points );
|
||||
|
||||
/* prepare for another new glyph image */
|
||||
FT_GlyphLoader_Prepare( loader );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_GlyphLoader_CopyPoints( FT_GlyphLoader target,
|
||||
FT_GlyphLoader source )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_UInt num_points = source->base.outline.n_points;
|
||||
FT_UInt num_contours = source->base.outline.n_contours;
|
||||
|
||||
|
||||
error = FT_GlyphLoader_CheckPoints( target, num_points, num_contours );
|
||||
if ( !error )
|
||||
{
|
||||
FT_Outline* out = &target->base.outline;
|
||||
FT_Outline* in = &source->base.outline;
|
||||
|
||||
|
||||
FT_ARRAY_COPY( out->points, in->points,
|
||||
num_points );
|
||||
FT_ARRAY_COPY( out->tags, in->tags,
|
||||
num_points );
|
||||
FT_ARRAY_COPY( out->contours, in->contours,
|
||||
num_contours );
|
||||
|
||||
/* do we need to copy the extra points? */
|
||||
if ( target->use_extra && source->use_extra )
|
||||
{
|
||||
FT_ARRAY_COPY( target->base.extra_points, source->base.extra_points,
|
||||
num_points );
|
||||
FT_ARRAY_COPY( target->base.extra_points2, source->base.extra_points2,
|
||||
num_points );
|
||||
}
|
||||
|
||||
out->n_points = (short)num_points;
|
||||
out->n_contours = (short)num_contours;
|
||||
|
||||
FT_GlyphLoader_Adjust_Points( target );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,627 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftglyph.c */
|
||||
/* */
|
||||
/* FreeType convenience functions to handle glyphs (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2007, 2008, 2010 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 are 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 <ft2build.h>
|
||||
#include FT_GLYPH_H
|
||||
#include FT_OUTLINE_H
|
||||
#include FT_BITMAP_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
#include "basepic.h"
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_glyph
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** FT_BitmapGlyph support ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ft_bitmap_glyph_init( FT_Glyph bitmap_glyph,
|
||||
FT_GlyphSlot slot )
|
||||
{
|
||||
FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Library library = FT_GLYPH( glyph )->library;
|
||||
|
||||
|
||||
if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
|
||||
{
|
||||
error = FT_Err_Invalid_Glyph_Format;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
glyph->left = slot->bitmap_left;
|
||||
glyph->top = slot->bitmap_top;
|
||||
|
||||
/* do lazy copying whenever possible */
|
||||
if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
|
||||
{
|
||||
glyph->bitmap = slot->bitmap;
|
||||
slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
|
||||
}
|
||||
else
|
||||
{
|
||||
FT_Bitmap_New( &glyph->bitmap );
|
||||
error = FT_Bitmap_Copy( library, &slot->bitmap, &glyph->bitmap );
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ft_bitmap_glyph_copy( FT_Glyph bitmap_source,
|
||||
FT_Glyph bitmap_target )
|
||||
{
|
||||
FT_Library library = bitmap_source->library;
|
||||
FT_BitmapGlyph source = (FT_BitmapGlyph)bitmap_source;
|
||||
FT_BitmapGlyph target = (FT_BitmapGlyph)bitmap_target;
|
||||
|
||||
|
||||
target->left = source->left;
|
||||
target->top = source->top;
|
||||
|
||||
return FT_Bitmap_Copy( library, &source->bitmap, &target->bitmap );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
ft_bitmap_glyph_done( FT_Glyph bitmap_glyph )
|
||||
{
|
||||
FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph;
|
||||
FT_Library library = FT_GLYPH( glyph )->library;
|
||||
|
||||
|
||||
FT_Bitmap_Done( library, &glyph->bitmap );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
ft_bitmap_glyph_bbox( FT_Glyph bitmap_glyph,
|
||||
FT_BBox* cbox )
|
||||
{
|
||||
FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph;
|
||||
|
||||
|
||||
cbox->xMin = glyph->left << 6;
|
||||
cbox->xMax = cbox->xMin + ( glyph->bitmap.width << 6 );
|
||||
cbox->yMax = glyph->top << 6;
|
||||
cbox->yMin = cbox->yMax - ( glyph->bitmap.rows << 6 );
|
||||
}
|
||||
|
||||
|
||||
FT_DEFINE_GLYPH(ft_bitmap_glyph_class,
|
||||
sizeof ( FT_BitmapGlyphRec ),
|
||||
FT_GLYPH_FORMAT_BITMAP,
|
||||
|
||||
ft_bitmap_glyph_init,
|
||||
ft_bitmap_glyph_done,
|
||||
ft_bitmap_glyph_copy,
|
||||
0, /* FT_Glyph_TransformFunc */
|
||||
ft_bitmap_glyph_bbox,
|
||||
0 /* FT_Glyph_PrepareFunc */
|
||||
)
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** FT_OutlineGlyph support ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ft_outline_glyph_init( FT_Glyph outline_glyph,
|
||||
FT_GlyphSlot slot )
|
||||
{
|
||||
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Library library = FT_GLYPH( glyph )->library;
|
||||
FT_Outline* source = &slot->outline;
|
||||
FT_Outline* target = &glyph->outline;
|
||||
|
||||
|
||||
/* check format in glyph slot */
|
||||
if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )
|
||||
{
|
||||
error = FT_Err_Invalid_Glyph_Format;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* allocate new outline */
|
||||
error = FT_Outline_New( library, source->n_points, source->n_contours,
|
||||
&glyph->outline );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
FT_Outline_Copy( source, target );
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
ft_outline_glyph_done( FT_Glyph outline_glyph )
|
||||
{
|
||||
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
|
||||
|
||||
|
||||
FT_Outline_Done( FT_GLYPH( glyph )->library, &glyph->outline );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ft_outline_glyph_copy( FT_Glyph outline_source,
|
||||
FT_Glyph outline_target )
|
||||
{
|
||||
FT_OutlineGlyph source = (FT_OutlineGlyph)outline_source;
|
||||
FT_OutlineGlyph target = (FT_OutlineGlyph)outline_target;
|
||||
FT_Error error;
|
||||
FT_Library library = FT_GLYPH( source )->library;
|
||||
|
||||
|
||||
error = FT_Outline_New( library, source->outline.n_points,
|
||||
source->outline.n_contours, &target->outline );
|
||||
if ( !error )
|
||||
FT_Outline_Copy( &source->outline, &target->outline );
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
ft_outline_glyph_transform( FT_Glyph outline_glyph,
|
||||
const FT_Matrix* matrix,
|
||||
const FT_Vector* delta )
|
||||
{
|
||||
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
|
||||
|
||||
|
||||
if ( matrix )
|
||||
FT_Outline_Transform( &glyph->outline, matrix );
|
||||
|
||||
if ( delta )
|
||||
FT_Outline_Translate( &glyph->outline, delta->x, delta->y );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
ft_outline_glyph_bbox( FT_Glyph outline_glyph,
|
||||
FT_BBox* bbox )
|
||||
{
|
||||
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
|
||||
|
||||
|
||||
FT_Outline_Get_CBox( &glyph->outline, bbox );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ft_outline_glyph_prepare( FT_Glyph outline_glyph,
|
||||
FT_GlyphSlot slot )
|
||||
{
|
||||
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
|
||||
|
||||
|
||||
slot->format = FT_GLYPH_FORMAT_OUTLINE;
|
||||
slot->outline = glyph->outline;
|
||||
slot->outline.flags &= ~FT_OUTLINE_OWNER;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
FT_DEFINE_GLYPH( ft_outline_glyph_class,
|
||||
sizeof ( FT_OutlineGlyphRec ),
|
||||
FT_GLYPH_FORMAT_OUTLINE,
|
||||
|
||||
ft_outline_glyph_init,
|
||||
ft_outline_glyph_done,
|
||||
ft_outline_glyph_copy,
|
||||
ft_outline_glyph_transform,
|
||||
ft_outline_glyph_bbox,
|
||||
ft_outline_glyph_prepare
|
||||
)
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** FT_Glyph class and API ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
static FT_Error
|
||||
ft_new_glyph( FT_Library library,
|
||||
const FT_Glyph_Class* clazz,
|
||||
FT_Glyph* aglyph )
|
||||
{
|
||||
FT_Memory memory = library->memory;
|
||||
FT_Error error;
|
||||
FT_Glyph glyph = NULL;
|
||||
|
||||
|
||||
*aglyph = 0;
|
||||
|
||||
if ( !FT_ALLOC( glyph, clazz->glyph_size ) )
|
||||
{
|
||||
glyph->library = library;
|
||||
glyph->clazz = clazz;
|
||||
glyph->format = clazz->glyph_format;
|
||||
|
||||
*aglyph = glyph;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftglyph.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Glyph_Copy( FT_Glyph source,
|
||||
FT_Glyph *target )
|
||||
{
|
||||
FT_Glyph copy;
|
||||
FT_Error error;
|
||||
const FT_Glyph_Class* clazz;
|
||||
|
||||
|
||||
/* check arguments */
|
||||
if ( !target )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
*target = 0;
|
||||
|
||||
if ( !source || !source->clazz )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
clazz = source->clazz;
|
||||
error = ft_new_glyph( source->library, clazz, © );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
copy->advance = source->advance;
|
||||
copy->format = source->format;
|
||||
|
||||
if ( clazz->glyph_copy )
|
||||
error = clazz->glyph_copy( source, copy );
|
||||
|
||||
if ( error )
|
||||
FT_Done_Glyph( copy );
|
||||
else
|
||||
*target = copy;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftglyph.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_Glyph( FT_GlyphSlot slot,
|
||||
FT_Glyph *aglyph )
|
||||
{
|
||||
FT_Library library;
|
||||
FT_Error error;
|
||||
FT_Glyph glyph;
|
||||
|
||||
const FT_Glyph_Class* clazz = 0;
|
||||
|
||||
|
||||
if ( !slot )
|
||||
return FT_Err_Invalid_Slot_Handle;
|
||||
|
||||
library = slot->library;
|
||||
|
||||
if ( !aglyph )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
/* if it is a bitmap, that's easy :-) */
|
||||
if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
|
||||
clazz = FT_BITMAP_GLYPH_CLASS_GET;
|
||||
|
||||
/* if it is an outline */
|
||||
else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
|
||||
clazz = FT_OUTLINE_GLYPH_CLASS_GET;
|
||||
|
||||
else
|
||||
{
|
||||
/* try to find a renderer that supports the glyph image format */
|
||||
FT_Renderer render = FT_Lookup_Renderer( library, slot->format, 0 );
|
||||
|
||||
|
||||
if ( render )
|
||||
clazz = &render->glyph_class;
|
||||
}
|
||||
|
||||
if ( !clazz )
|
||||
{
|
||||
error = FT_Err_Invalid_Glyph_Format;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* create FT_Glyph object */
|
||||
error = ft_new_glyph( library, clazz, &glyph );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
/* copy advance while converting it to 16.16 format */
|
||||
glyph->advance.x = slot->advance.x << 10;
|
||||
glyph->advance.y = slot->advance.y << 10;
|
||||
|
||||
/* now import the image from the glyph slot */
|
||||
error = clazz->glyph_init( glyph, slot );
|
||||
|
||||
/* if an error occurred, destroy the glyph */
|
||||
if ( error )
|
||||
FT_Done_Glyph( glyph );
|
||||
else
|
||||
*aglyph = glyph;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftglyph.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Glyph_Transform( FT_Glyph glyph,
|
||||
FT_Matrix* matrix,
|
||||
FT_Vector* delta )
|
||||
{
|
||||
const FT_Glyph_Class* clazz;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
|
||||
|
||||
if ( !glyph || !glyph->clazz )
|
||||
error = FT_Err_Invalid_Argument;
|
||||
else
|
||||
{
|
||||
clazz = glyph->clazz;
|
||||
if ( clazz->glyph_transform )
|
||||
{
|
||||
/* transform glyph image */
|
||||
clazz->glyph_transform( glyph, matrix, delta );
|
||||
|
||||
/* transform advance vector */
|
||||
if ( matrix )
|
||||
FT_Vector_Transform( &glyph->advance, matrix );
|
||||
}
|
||||
else
|
||||
error = FT_Err_Invalid_Glyph_Format;
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftglyph.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Glyph_Get_CBox( FT_Glyph glyph,
|
||||
FT_UInt bbox_mode,
|
||||
FT_BBox *acbox )
|
||||
{
|
||||
const FT_Glyph_Class* clazz;
|
||||
|
||||
|
||||
if ( !acbox )
|
||||
return;
|
||||
|
||||
acbox->xMin = acbox->yMin = acbox->xMax = acbox->yMax = 0;
|
||||
|
||||
if ( !glyph || !glyph->clazz )
|
||||
return;
|
||||
else
|
||||
{
|
||||
clazz = glyph->clazz;
|
||||
if ( !clazz->glyph_bbox )
|
||||
return;
|
||||
else
|
||||
{
|
||||
/* retrieve bbox in 26.6 coordinates */
|
||||
clazz->glyph_bbox( glyph, acbox );
|
||||
|
||||
/* perform grid fitting if needed */
|
||||
if ( bbox_mode == FT_GLYPH_BBOX_GRIDFIT ||
|
||||
bbox_mode == FT_GLYPH_BBOX_PIXELS )
|
||||
{
|
||||
acbox->xMin = FT_PIX_FLOOR( acbox->xMin );
|
||||
acbox->yMin = FT_PIX_FLOOR( acbox->yMin );
|
||||
acbox->xMax = FT_PIX_CEIL( acbox->xMax );
|
||||
acbox->yMax = FT_PIX_CEIL( acbox->yMax );
|
||||
}
|
||||
|
||||
/* convert to integer pixels if needed */
|
||||
if ( bbox_mode == FT_GLYPH_BBOX_TRUNCATE ||
|
||||
bbox_mode == FT_GLYPH_BBOX_PIXELS )
|
||||
{
|
||||
acbox->xMin >>= 6;
|
||||
acbox->yMin >>= 6;
|
||||
acbox->xMax >>= 6;
|
||||
acbox->yMax >>= 6;
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftglyph.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Glyph_To_Bitmap( FT_Glyph* the_glyph,
|
||||
FT_Render_Mode render_mode,
|
||||
FT_Vector* origin,
|
||||
FT_Bool destroy )
|
||||
{
|
||||
FT_GlyphSlotRec dummy;
|
||||
FT_GlyphSlot_InternalRec dummy_internal;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Glyph glyph;
|
||||
FT_BitmapGlyph bitmap = NULL;
|
||||
|
||||
const FT_Glyph_Class* clazz;
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_PIC
|
||||
FT_Library library = FT_GLYPH( glyph )->library;
|
||||
#endif
|
||||
|
||||
|
||||
/* check argument */
|
||||
if ( !the_glyph )
|
||||
goto Bad;
|
||||
|
||||
/* we render the glyph into a glyph bitmap using a `dummy' glyph slot */
|
||||
/* then calling FT_Render_Glyph_Internal() */
|
||||
|
||||
glyph = *the_glyph;
|
||||
if ( !glyph )
|
||||
goto Bad;
|
||||
|
||||
clazz = glyph->clazz;
|
||||
|
||||
/* when called with a bitmap glyph, do nothing and return successfully */
|
||||
if ( clazz == FT_BITMAP_GLYPH_CLASS_GET )
|
||||
goto Exit;
|
||||
|
||||
if ( !clazz || !clazz->glyph_prepare )
|
||||
goto Bad;
|
||||
|
||||
FT_MEM_ZERO( &dummy, sizeof ( dummy ) );
|
||||
FT_MEM_ZERO( &dummy_internal, sizeof ( dummy_internal ) );
|
||||
dummy.internal = &dummy_internal;
|
||||
dummy.library = glyph->library;
|
||||
dummy.format = clazz->glyph_format;
|
||||
|
||||
/* create result bitmap glyph */
|
||||
error = ft_new_glyph( glyph->library, FT_BITMAP_GLYPH_CLASS_GET,
|
||||
(FT_Glyph*)(void*)&bitmap );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
#if 1
|
||||
/* if `origin' is set, translate the glyph image */
|
||||
if ( origin )
|
||||
FT_Glyph_Transform( glyph, 0, origin );
|
||||
#else
|
||||
FT_UNUSED( origin );
|
||||
#endif
|
||||
|
||||
/* prepare dummy slot for rendering */
|
||||
error = clazz->glyph_prepare( glyph, &dummy );
|
||||
if ( !error )
|
||||
error = FT_Render_Glyph_Internal( glyph->library, &dummy, render_mode );
|
||||
|
||||
#if 1
|
||||
if ( !destroy && origin )
|
||||
{
|
||||
FT_Vector v;
|
||||
|
||||
|
||||
v.x = -origin->x;
|
||||
v.y = -origin->y;
|
||||
FT_Glyph_Transform( glyph, 0, &v );
|
||||
}
|
||||
#endif
|
||||
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
/* in case of success, copy the bitmap to the glyph bitmap */
|
||||
error = ft_bitmap_glyph_init( (FT_Glyph)bitmap, &dummy );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
/* copy advance */
|
||||
bitmap->root.advance = glyph->advance;
|
||||
|
||||
if ( destroy )
|
||||
FT_Done_Glyph( glyph );
|
||||
|
||||
*the_glyph = FT_GLYPH( bitmap );
|
||||
|
||||
Exit:
|
||||
if ( error && bitmap )
|
||||
FT_Done_Glyph( FT_GLYPH( bitmap ) );
|
||||
|
||||
return error;
|
||||
|
||||
Bad:
|
||||
error = FT_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftglyph.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Done_Glyph( FT_Glyph glyph )
|
||||
{
|
||||
if ( glyph )
|
||||
{
|
||||
FT_Memory memory = glyph->library->memory;
|
||||
const FT_Glyph_Class* clazz = glyph->clazz;
|
||||
|
||||
|
||||
if ( clazz->glyph_done )
|
||||
clazz->glyph_done( glyph );
|
||||
|
||||
FT_FREE( glyph );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,140 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftgxval.c */
|
||||
/* */
|
||||
/* FreeType API for validating TrueTyepGX/AAT tables (body). */
|
||||
/* */
|
||||
/* Copyright 2004, 2005, 2006, 2010 by */
|
||||
/* Masatake YAMATO, Redhat K.K, */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* gxvalid is derived from both gxlayout module and otvalid module. */
|
||||
/* Development of gxlayout is supported by the Information-technology */
|
||||
/* Promotion Agency(IPA), Japan. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_SERVICE_GX_VALIDATE_H
|
||||
|
||||
|
||||
/* documentation is in ftgxval.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_TrueTypeGX_Validate( FT_Face face,
|
||||
FT_UInt validation_flags,
|
||||
FT_Bytes tables[FT_VALIDATE_GX_LENGTH],
|
||||
FT_UInt table_length )
|
||||
{
|
||||
FT_Service_GXvalidate service;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
if ( !face )
|
||||
{
|
||||
error = FT_Err_Invalid_Face_Handle;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( tables == NULL )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
FT_FACE_FIND_GLOBAL_SERVICE( face, service, GX_VALIDATE );
|
||||
|
||||
if ( service )
|
||||
error = service->validate( face,
|
||||
validation_flags,
|
||||
tables,
|
||||
table_length );
|
||||
else
|
||||
error = FT_Err_Unimplemented_Feature;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_TrueTypeGX_Free( FT_Face face,
|
||||
FT_Bytes table )
|
||||
{
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
if ( !face )
|
||||
return;
|
||||
|
||||
memory = FT_FACE_MEMORY( face );
|
||||
|
||||
FT_FREE( table );
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_ClassicKern_Validate( FT_Face face,
|
||||
FT_UInt validation_flags,
|
||||
FT_Bytes *ckern_table )
|
||||
{
|
||||
FT_Service_CKERNvalidate service;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
if ( !face )
|
||||
{
|
||||
error = FT_Err_Invalid_Face_Handle;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( ckern_table == NULL )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
FT_FACE_FIND_GLOBAL_SERVICE( face, service, CLASSICKERN_VALIDATE );
|
||||
|
||||
if ( service )
|
||||
error = service->validate( face,
|
||||
validation_flags,
|
||||
ckern_table );
|
||||
else
|
||||
error = FT_Err_Unimplemented_Feature;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_ClassicKern_Free( FT_Face face,
|
||||
FT_Bytes table )
|
||||
{
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
if ( !face )
|
||||
return;
|
||||
|
||||
memory = FT_FACE_MEMORY( face );
|
||||
|
||||
|
||||
FT_FREE( table );
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,253 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftinit.c */
|
||||
/* */
|
||||
/* FreeType initialization layer (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2002, 2005, 2007, 2009 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The purpose of this file is to implement the following two */
|
||||
/* functions: */
|
||||
/* */
|
||||
/* FT_Add_Default_Modules(): */
|
||||
/* This function is used to add the set of default modules to a */
|
||||
/* fresh new library object. The set is taken from the header file */
|
||||
/* `freetype/config/ftmodule.h'. See the document `FreeType 2.0 */
|
||||
/* Build System' for more information. */
|
||||
/* */
|
||||
/* FT_Init_FreeType(): */
|
||||
/* This function creates a system object for the current platform, */
|
||||
/* builds a library out of it, then calls FT_Default_Drivers(). */
|
||||
/* */
|
||||
/* Note that even if FT_Init_FreeType() uses the implementation of the */
|
||||
/* system object defined at build time, client applications are still */
|
||||
/* able to provide their own `ftsystem.c'. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CONFIG_CONFIG_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_MODULE_H
|
||||
#include "basepic.h"
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_init
|
||||
|
||||
#ifndef FT_CONFIG_OPTION_PIC
|
||||
|
||||
#undef FT_USE_MODULE
|
||||
#ifdef __cplusplus
|
||||
#define FT_USE_MODULE( type, x ) extern "C" const type x;
|
||||
#else
|
||||
#define FT_USE_MODULE( type, x ) extern const type x;
|
||||
#endif
|
||||
|
||||
|
||||
#include FT_CONFIG_MODULES_H
|
||||
|
||||
|
||||
#undef FT_USE_MODULE
|
||||
#define FT_USE_MODULE( type, x ) (const FT_Module_Class*)&(x),
|
||||
|
||||
static
|
||||
const FT_Module_Class* const ft_default_modules[] =
|
||||
{
|
||||
#include FT_CONFIG_MODULES_H
|
||||
0
|
||||
};
|
||||
|
||||
#else /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
#ifdef __cplusplus
|
||||
#define FT_EXTERNC extern "C"
|
||||
#else
|
||||
#define FT_EXTERNC extern
|
||||
#endif
|
||||
|
||||
/* declare the module's class creation/destruction functions */
|
||||
#undef FT_USE_MODULE
|
||||
#define FT_USE_MODULE( type, x ) \
|
||||
FT_EXTERNC FT_Error FT_Create_Class_##x( FT_Library library, FT_Module_Class** output_class ); \
|
||||
FT_EXTERNC void FT_Destroy_Class_##x( FT_Library library, FT_Module_Class* clazz );
|
||||
|
||||
#include FT_CONFIG_MODULES_H
|
||||
|
||||
|
||||
/* count all module classes */
|
||||
#undef FT_USE_MODULE
|
||||
#define FT_USE_MODULE( type, x ) MODULE_CLASS_##x,
|
||||
|
||||
enum
|
||||
{
|
||||
#include FT_CONFIG_MODULES_H
|
||||
FT_NUM_MODULE_CLASSES
|
||||
};
|
||||
|
||||
/* destroy all module classes */
|
||||
#undef FT_USE_MODULE
|
||||
#define FT_USE_MODULE( type, x ) \
|
||||
if ( classes[i] ) { FT_Destroy_Class_##x(library, classes[i]); } \
|
||||
i++; \
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
ft_destroy_default_module_classes( FT_Library library )
|
||||
{
|
||||
FT_Module_Class** classes;
|
||||
FT_Memory memory;
|
||||
FT_UInt i;
|
||||
BasePIC* pic_container = (BasePIC*)library->pic_container.base;
|
||||
|
||||
if ( !pic_container->default_module_classes )
|
||||
return;
|
||||
|
||||
memory = library->memory;
|
||||
classes = pic_container->default_module_classes;
|
||||
i = 0;
|
||||
|
||||
#include FT_CONFIG_MODULES_H
|
||||
|
||||
FT_FREE( classes );
|
||||
pic_container->default_module_classes = 0;
|
||||
}
|
||||
|
||||
/* initialize all module classes and the pointer table */
|
||||
#undef FT_USE_MODULE
|
||||
#define FT_USE_MODULE( type, x ) \
|
||||
error = FT_Create_Class_##x(library, &clazz); \
|
||||
if (error) goto Exit; \
|
||||
classes[i++] = clazz;
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
ft_create_default_module_classes( FT_Library library )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
FT_Module_Class** classes;
|
||||
FT_Module_Class* clazz;
|
||||
FT_UInt i;
|
||||
BasePIC* pic_container = (BasePIC*)library->pic_container.base;
|
||||
|
||||
memory = library->memory;
|
||||
pic_container->default_module_classes = 0;
|
||||
|
||||
if ( FT_ALLOC(classes, sizeof(FT_Module_Class*) * (FT_NUM_MODULE_CLASSES + 1) ) )
|
||||
return error;
|
||||
/* initialize all pointers to 0, especially the last one */
|
||||
for (i = 0; i < FT_NUM_MODULE_CLASSES; i++)
|
||||
classes[i] = 0;
|
||||
classes[FT_NUM_MODULE_CLASSES] = 0;
|
||||
|
||||
i = 0;
|
||||
|
||||
#include FT_CONFIG_MODULES_H
|
||||
|
||||
Exit:
|
||||
if (error) ft_destroy_default_module_classes( library );
|
||||
else pic_container->default_module_classes = classes;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
/* documentation is in ftmodapi.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Add_Default_Modules( FT_Library library )
|
||||
{
|
||||
FT_Error error;
|
||||
const FT_Module_Class* const* cur;
|
||||
|
||||
|
||||
/* test for valid `library' delayed to FT_Add_Module() */
|
||||
|
||||
cur = FT_DEFAULT_MODULES_GET;
|
||||
while ( *cur )
|
||||
{
|
||||
error = FT_Add_Module( library, *cur );
|
||||
/* notify errors, but don't stop */
|
||||
if ( error )
|
||||
FT_TRACE0(( "FT_Add_Default_Module:"
|
||||
" Cannot install `%s', error = 0x%x\n",
|
||||
(*cur)->module_name, error ));
|
||||
cur++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Init_FreeType( FT_Library *alibrary )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
/* First of all, allocate a new system object -- this function is part */
|
||||
/* of the system-specific component, i.e. `ftsystem.c'. */
|
||||
|
||||
memory = FT_New_Memory();
|
||||
if ( !memory )
|
||||
{
|
||||
FT_ERROR(( "FT_Init_FreeType: cannot find memory manager\n" ));
|
||||
return FT_Err_Unimplemented_Feature;
|
||||
}
|
||||
|
||||
/* build a library out of it, then fill it with the set of */
|
||||
/* default drivers. */
|
||||
|
||||
error = FT_New_Library( memory, alibrary );
|
||||
if ( error )
|
||||
FT_Done_Memory( memory );
|
||||
else
|
||||
FT_Add_Default_Modules( *alibrary );
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Done_FreeType( FT_Library library )
|
||||
{
|
||||
if ( library )
|
||||
{
|
||||
FT_Memory memory = library->memory;
|
||||
|
||||
|
||||
/* Discard the library object */
|
||||
FT_Done_Library( library );
|
||||
|
||||
/* discard memory manager */
|
||||
FT_Done_Memory( memory );
|
||||
}
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,376 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftlcdfil.c */
|
||||
/* */
|
||||
/* FreeType API for color filtering of subpixel bitmap glyphs (body). */
|
||||
/* */
|
||||
/* Copyright 2006, 2008, 2009, 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_LCD_FILTER_H
|
||||
#include FT_IMAGE_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
|
||||
|
||||
/* define USE_LEGACY to implement the legacy filter */
|
||||
#define USE_LEGACY
|
||||
|
||||
/* FIR filter used by the default and light filters */
|
||||
static void
|
||||
_ft_lcd_filter_fir( FT_Bitmap* bitmap,
|
||||
FT_Render_Mode mode,
|
||||
FT_Library library )
|
||||
{
|
||||
FT_Byte* weights = library->lcd_weights;
|
||||
FT_UInt width = (FT_UInt)bitmap->width;
|
||||
FT_UInt height = (FT_UInt)bitmap->rows;
|
||||
|
||||
|
||||
/* horizontal in-place FIR filter */
|
||||
if ( mode == FT_RENDER_MODE_LCD && width >= 4 )
|
||||
{
|
||||
FT_Byte* line = bitmap->buffer;
|
||||
|
||||
|
||||
for ( ; height > 0; height--, line += bitmap->pitch )
|
||||
{
|
||||
FT_UInt fir[5];
|
||||
FT_UInt val1, xx;
|
||||
|
||||
|
||||
val1 = line[0];
|
||||
fir[0] = weights[2] * val1;
|
||||
fir[1] = weights[3] * val1;
|
||||
fir[2] = weights[4] * val1;
|
||||
fir[3] = 0;
|
||||
fir[4] = 0;
|
||||
|
||||
val1 = line[1];
|
||||
fir[0] += weights[1] * val1;
|
||||
fir[1] += weights[2] * val1;
|
||||
fir[2] += weights[3] * val1;
|
||||
fir[3] += weights[4] * val1;
|
||||
|
||||
for ( xx = 2; xx < width; xx++ )
|
||||
{
|
||||
FT_UInt val, pix;
|
||||
|
||||
|
||||
val = line[xx];
|
||||
pix = fir[0] + weights[0] * val;
|
||||
fir[0] = fir[1] + weights[1] * val;
|
||||
fir[1] = fir[2] + weights[2] * val;
|
||||
fir[2] = fir[3] + weights[3] * val;
|
||||
fir[3] = weights[4] * val;
|
||||
|
||||
pix >>= 8;
|
||||
pix |= -( pix >> 8 );
|
||||
line[xx - 2] = (FT_Byte)pix;
|
||||
}
|
||||
|
||||
{
|
||||
FT_UInt pix;
|
||||
|
||||
|
||||
pix = fir[0] >> 8;
|
||||
pix |= -( pix >> 8 );
|
||||
line[xx - 2] = (FT_Byte)pix;
|
||||
|
||||
pix = fir[1] >> 8;
|
||||
pix |= -( pix >> 8 );
|
||||
line[xx - 1] = (FT_Byte)pix;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* vertical in-place FIR filter */
|
||||
else if ( mode == FT_RENDER_MODE_LCD_V && height >= 4 )
|
||||
{
|
||||
FT_Byte* column = bitmap->buffer;
|
||||
FT_Int pitch = bitmap->pitch;
|
||||
|
||||
|
||||
for ( ; width > 0; width--, column++ )
|
||||
{
|
||||
FT_Byte* col = column;
|
||||
FT_UInt fir[5];
|
||||
FT_UInt val1, yy;
|
||||
|
||||
|
||||
val1 = col[0];
|
||||
fir[0] = weights[2] * val1;
|
||||
fir[1] = weights[3] * val1;
|
||||
fir[2] = weights[4] * val1;
|
||||
fir[3] = 0;
|
||||
fir[4] = 0;
|
||||
col += pitch;
|
||||
|
||||
val1 = col[0];
|
||||
fir[0] += weights[1] * val1;
|
||||
fir[1] += weights[2] * val1;
|
||||
fir[2] += weights[3] * val1;
|
||||
fir[3] += weights[4] * val1;
|
||||
col += pitch;
|
||||
|
||||
for ( yy = 2; yy < height; yy++ )
|
||||
{
|
||||
FT_UInt val, pix;
|
||||
|
||||
|
||||
val = col[0];
|
||||
pix = fir[0] + weights[0] * val;
|
||||
fir[0] = fir[1] + weights[1] * val;
|
||||
fir[1] = fir[2] + weights[2] * val;
|
||||
fir[2] = fir[3] + weights[3] * val;
|
||||
fir[3] = weights[4] * val;
|
||||
|
||||
pix >>= 8;
|
||||
pix |= -( pix >> 8 );
|
||||
col[-2 * pitch] = (FT_Byte)pix;
|
||||
col += pitch;
|
||||
}
|
||||
|
||||
{
|
||||
FT_UInt pix;
|
||||
|
||||
|
||||
pix = fir[0] >> 8;
|
||||
pix |= -( pix >> 8 );
|
||||
col[-2 * pitch] = (FT_Byte)pix;
|
||||
|
||||
pix = fir[1] >> 8;
|
||||
pix |= -( pix >> 8 );
|
||||
col[-pitch] = (FT_Byte)pix;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifdef USE_LEGACY
|
||||
|
||||
/* intra-pixel filter used by the legacy filter */
|
||||
static void
|
||||
_ft_lcd_filter_legacy( FT_Bitmap* bitmap,
|
||||
FT_Render_Mode mode,
|
||||
FT_Library library )
|
||||
{
|
||||
FT_UInt width = (FT_UInt)bitmap->width;
|
||||
FT_UInt height = (FT_UInt)bitmap->rows;
|
||||
FT_Int pitch = bitmap->pitch;
|
||||
|
||||
static const int filters[3][3] =
|
||||
{
|
||||
{ 65538 * 9/13, 65538 * 1/6, 65538 * 1/13 },
|
||||
{ 65538 * 3/13, 65538 * 4/6, 65538 * 3/13 },
|
||||
{ 65538 * 1/13, 65538 * 1/6, 65538 * 9/13 }
|
||||
};
|
||||
|
||||
FT_UNUSED( library );
|
||||
|
||||
|
||||
/* horizontal in-place intra-pixel filter */
|
||||
if ( mode == FT_RENDER_MODE_LCD && width >= 3 )
|
||||
{
|
||||
FT_Byte* line = bitmap->buffer;
|
||||
|
||||
|
||||
for ( ; height > 0; height--, line += pitch )
|
||||
{
|
||||
FT_UInt xx;
|
||||
|
||||
|
||||
for ( xx = 0; xx < width; xx += 3 )
|
||||
{
|
||||
FT_UInt r = 0;
|
||||
FT_UInt g = 0;
|
||||
FT_UInt b = 0;
|
||||
FT_UInt p;
|
||||
|
||||
|
||||
p = line[xx];
|
||||
r += filters[0][0] * p;
|
||||
g += filters[0][1] * p;
|
||||
b += filters[0][2] * p;
|
||||
|
||||
p = line[xx + 1];
|
||||
r += filters[1][0] * p;
|
||||
g += filters[1][1] * p;
|
||||
b += filters[1][2] * p;
|
||||
|
||||
p = line[xx + 2];
|
||||
r += filters[2][0] * p;
|
||||
g += filters[2][1] * p;
|
||||
b += filters[2][2] * p;
|
||||
|
||||
line[xx] = (FT_Byte)( r / 65536 );
|
||||
line[xx + 1] = (FT_Byte)( g / 65536 );
|
||||
line[xx + 2] = (FT_Byte)( b / 65536 );
|
||||
}
|
||||
}
|
||||
}
|
||||
else if ( mode == FT_RENDER_MODE_LCD_V && height >= 3 )
|
||||
{
|
||||
FT_Byte* column = bitmap->buffer;
|
||||
|
||||
|
||||
for ( ; width > 0; width--, column++ )
|
||||
{
|
||||
FT_Byte* col = column;
|
||||
FT_Byte* col_end = col + height * pitch;
|
||||
|
||||
|
||||
for ( ; col < col_end; col += 3 * pitch )
|
||||
{
|
||||
FT_UInt r = 0;
|
||||
FT_UInt g = 0;
|
||||
FT_UInt b = 0;
|
||||
FT_UInt p;
|
||||
|
||||
|
||||
p = col[0];
|
||||
r += filters[0][0] * p;
|
||||
g += filters[0][1] * p;
|
||||
b += filters[0][2] * p;
|
||||
|
||||
p = col[pitch];
|
||||
r += filters[1][0] * p;
|
||||
g += filters[1][1] * p;
|
||||
b += filters[1][2] * p;
|
||||
|
||||
p = col[pitch * 2];
|
||||
r += filters[2][0] * p;
|
||||
g += filters[2][1] * p;
|
||||
b += filters[2][2] * p;
|
||||
|
||||
col[0] = (FT_Byte)( r / 65536 );
|
||||
col[pitch] = (FT_Byte)( g / 65536 );
|
||||
col[2 * pitch] = (FT_Byte)( b / 65536 );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* USE_LEGACY */
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Library_SetLcdFilterWeights( FT_Library library,
|
||||
unsigned char *weights )
|
||||
{
|
||||
if ( !library || !weights )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
ft_memcpy( library->lcd_weights, weights, 5 );
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Library_SetLcdFilter( FT_Library library,
|
||||
FT_LcdFilter filter )
|
||||
{
|
||||
static const FT_Byte light_filter[5] =
|
||||
{ 0x00, 0x55, 0x56, 0x55, 0x00 };
|
||||
/* the values here sum up to a value larger than 256, */
|
||||
/* providing a cheap gamma correction */
|
||||
static const FT_Byte default_filter[5] =
|
||||
{ 0x10, 0x40, 0x70, 0x40, 0x10 };
|
||||
|
||||
|
||||
if ( !library )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
switch ( filter )
|
||||
{
|
||||
case FT_LCD_FILTER_NONE:
|
||||
library->lcd_filter_func = NULL;
|
||||
library->lcd_extra = 0;
|
||||
break;
|
||||
|
||||
case FT_LCD_FILTER_DEFAULT:
|
||||
#if defined( FT_FORCE_LEGACY_LCD_FILTER )
|
||||
|
||||
library->lcd_filter_func = _ft_lcd_filter_legacy;
|
||||
library->lcd_extra = 0;
|
||||
|
||||
#elif defined( FT_FORCE_LIGHT_LCD_FILTER )
|
||||
|
||||
ft_memcpy( library->lcd_weights, light_filter, 5 );
|
||||
library->lcd_filter_func = _ft_lcd_filter_fir;
|
||||
library->lcd_extra = 2;
|
||||
|
||||
#else
|
||||
|
||||
ft_memcpy( library->lcd_weights, default_filter, 5 );
|
||||
library->lcd_filter_func = _ft_lcd_filter_fir;
|
||||
library->lcd_extra = 2;
|
||||
|
||||
#endif
|
||||
|
||||
break;
|
||||
|
||||
case FT_LCD_FILTER_LIGHT:
|
||||
ft_memcpy( library->lcd_weights, light_filter, 5 );
|
||||
library->lcd_filter_func = _ft_lcd_filter_fir;
|
||||
library->lcd_extra = 2;
|
||||
break;
|
||||
|
||||
#ifdef USE_LEGACY
|
||||
|
||||
case FT_LCD_FILTER_LEGACY:
|
||||
library->lcd_filter_func = _ft_lcd_filter_legacy;
|
||||
library->lcd_extra = 0;
|
||||
break;
|
||||
|
||||
#endif
|
||||
|
||||
default:
|
||||
return FT_Err_Invalid_Argument;
|
||||
}
|
||||
|
||||
library->lcd_filter = filter;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
#else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Library_SetLcdFilterWeights( FT_Library library,
|
||||
unsigned char *weights )
|
||||
{
|
||||
FT_UNUSED( library );
|
||||
FT_UNUSED( weights );
|
||||
|
||||
return FT_Err_Unimplemented_Feature;
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Library_SetLcdFilter( FT_Library library,
|
||||
FT_LcdFilter filter )
|
||||
{
|
||||
FT_UNUSED( library );
|
||||
FT_UNUSED( filter );
|
||||
|
||||
return FT_Err_Unimplemented_Feature;
|
||||
}
|
||||
|
||||
#endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
|
||||
|
||||
|
||||
/* END */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,202 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftmm.c */
|
||||
/* */
|
||||
/* Multiple Master font support (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2003, 2004, 2009 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_MULTIPLE_MASTERS_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_SERVICE_MULTIPLE_MASTERS_H
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_mm
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_face_get_mm_service( FT_Face face,
|
||||
FT_Service_MultiMasters *aservice )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
*aservice = NULL;
|
||||
|
||||
if ( !face )
|
||||
return FT_Err_Invalid_Face_Handle;
|
||||
|
||||
error = FT_Err_Invalid_Argument;
|
||||
|
||||
if ( FT_HAS_MULTIPLE_MASTERS( face ) )
|
||||
{
|
||||
FT_FACE_LOOKUP_SERVICE( face,
|
||||
*aservice,
|
||||
MULTI_MASTERS );
|
||||
|
||||
if ( *aservice )
|
||||
error = FT_Err_Ok;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftmm.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_Multi_Master( FT_Face face,
|
||||
FT_Multi_Master *amaster )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Service_MultiMasters service;
|
||||
|
||||
|
||||
error = ft_face_get_mm_service( face, &service );
|
||||
if ( !error )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
if ( service->get_mm )
|
||||
error = service->get_mm( face, amaster );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftmm.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_MM_Var( FT_Face face,
|
||||
FT_MM_Var* *amaster )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Service_MultiMasters service;
|
||||
|
||||
|
||||
error = ft_face_get_mm_service( face, &service );
|
||||
if ( !error )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
if ( service->get_mm_var )
|
||||
error = service->get_mm_var( face, amaster );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftmm.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Set_MM_Design_Coordinates( FT_Face face,
|
||||
FT_UInt num_coords,
|
||||
FT_Long* coords )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Service_MultiMasters service;
|
||||
|
||||
|
||||
error = ft_face_get_mm_service( face, &service );
|
||||
if ( !error )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
if ( service->set_mm_design )
|
||||
error = service->set_mm_design( face, num_coords, coords );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftmm.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Set_Var_Design_Coordinates( FT_Face face,
|
||||
FT_UInt num_coords,
|
||||
FT_Fixed* coords )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Service_MultiMasters service;
|
||||
|
||||
|
||||
error = ft_face_get_mm_service( face, &service );
|
||||
if ( !error )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
if ( service->set_var_design )
|
||||
error = service->set_var_design( face, num_coords, coords );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftmm.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Set_MM_Blend_Coordinates( FT_Face face,
|
||||
FT_UInt num_coords,
|
||||
FT_Fixed* coords )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Service_MultiMasters service;
|
||||
|
||||
|
||||
error = ft_face_get_mm_service( face, &service );
|
||||
if ( !error )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
if ( service->set_mm_blend )
|
||||
error = service->set_mm_blend( face, num_coords, coords );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftmm.h */
|
||||
|
||||
/* This is exactly the same as the previous function. It exists for */
|
||||
/* orthogonality. */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Set_Var_Blend_Coordinates( FT_Face face,
|
||||
FT_UInt num_coords,
|
||||
FT_Fixed* coords )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Service_MultiMasters service;
|
||||
|
||||
|
||||
error = ft_face_get_mm_service( face, &service );
|
||||
if ( !error )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
if ( service->set_mm_blend )
|
||||
error = service->set_mm_blend( face, num_coords, coords );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,89 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftotval.c */
|
||||
/* */
|
||||
/* FreeType API for validating OpenType tables (body). */
|
||||
/* */
|
||||
/* Copyright 2004, 2006, 2008, 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_SERVICE_OPENTYPE_VALIDATE_H
|
||||
#include FT_OPENTYPE_VALIDATE_H
|
||||
|
||||
|
||||
/* documentation is in ftotval.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_OpenType_Validate( FT_Face face,
|
||||
FT_UInt validation_flags,
|
||||
FT_Bytes *BASE_table,
|
||||
FT_Bytes *GDEF_table,
|
||||
FT_Bytes *GPOS_table,
|
||||
FT_Bytes *GSUB_table,
|
||||
FT_Bytes *JSTF_table )
|
||||
{
|
||||
FT_Service_OTvalidate service;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
if ( !face )
|
||||
{
|
||||
error = FT_Err_Invalid_Face_Handle;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( !( BASE_table &&
|
||||
GDEF_table &&
|
||||
GPOS_table &&
|
||||
GSUB_table &&
|
||||
JSTF_table ) )
|
||||
{
|
||||
error = FT_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
FT_FACE_FIND_GLOBAL_SERVICE( face, service, OPENTYPE_VALIDATE );
|
||||
|
||||
if ( service )
|
||||
error = service->validate( face,
|
||||
validation_flags,
|
||||
BASE_table,
|
||||
GDEF_table,
|
||||
GPOS_table,
|
||||
GSUB_table,
|
||||
JSTF_table );
|
||||
else
|
||||
error = FT_Err_Unimplemented_Feature;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_OpenType_Free( FT_Face face,
|
||||
FT_Bytes table )
|
||||
{
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
if ( !face )
|
||||
return;
|
||||
|
||||
memory = FT_FACE_MEMORY( face );
|
||||
|
||||
FT_FREE( table );
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,286 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftpatent.c */
|
||||
/* */
|
||||
/* FreeType API for checking patented TrueType bytecode instructions */
|
||||
/* (body). */
|
||||
/* */
|
||||
/* Copyright 2007, 2008, 2010 by David Turner. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_TRUETYPE_TAGS_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_SERVICE_SFNT_H
|
||||
#include FT_SERVICE_TRUETYPE_GLYF_H
|
||||
|
||||
|
||||
static FT_Bool
|
||||
_tt_check_patents_in_range( FT_Stream stream,
|
||||
FT_ULong size )
|
||||
{
|
||||
FT_Bool result = FALSE;
|
||||
FT_Error error;
|
||||
FT_Bytes p, end;
|
||||
|
||||
|
||||
if ( FT_FRAME_ENTER( size ) )
|
||||
return 0;
|
||||
|
||||
p = stream->cursor;
|
||||
end = p + size;
|
||||
|
||||
while ( p < end )
|
||||
{
|
||||
switch (p[0])
|
||||
{
|
||||
case 0x06: /* SPvTL // */
|
||||
case 0x07: /* SPvTL + */
|
||||
case 0x08: /* SFvTL // */
|
||||
case 0x09: /* SFvTL + */
|
||||
case 0x0A: /* SPvFS */
|
||||
case 0x0B: /* SFvFS */
|
||||
result = TRUE;
|
||||
goto Exit;
|
||||
|
||||
case 0x40:
|
||||
if ( p + 1 >= end )
|
||||
goto Exit;
|
||||
|
||||
p += p[1] + 2;
|
||||
break;
|
||||
|
||||
case 0x41:
|
||||
if ( p + 1 >= end )
|
||||
goto Exit;
|
||||
|
||||
p += p[1] * 2 + 2;
|
||||
break;
|
||||
|
||||
case 0x71: /* DELTAP2 */
|
||||
case 0x72: /* DELTAP3 */
|
||||
case 0x73: /* DELTAC0 */
|
||||
case 0x74: /* DELTAC1 */
|
||||
case 0x75: /* DELTAC2 */
|
||||
result = TRUE;
|
||||
goto Exit;
|
||||
|
||||
case 0xB0:
|
||||
case 0xB1:
|
||||
case 0xB2:
|
||||
case 0xB3:
|
||||
case 0xB4:
|
||||
case 0xB5:
|
||||
case 0xB6:
|
||||
case 0xB7:
|
||||
p += ( p[0] - 0xB0 ) + 2;
|
||||
break;
|
||||
|
||||
case 0xB8:
|
||||
case 0xB9:
|
||||
case 0xBA:
|
||||
case 0xBB:
|
||||
case 0xBC:
|
||||
case 0xBD:
|
||||
case 0xBE:
|
||||
case 0xBF:
|
||||
p += ( p[0] - 0xB8 ) * 2 + 3;
|
||||
break;
|
||||
|
||||
default:
|
||||
p += 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Exit:
|
||||
FT_UNUSED( error );
|
||||
FT_FRAME_EXIT();
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
static FT_Bool
|
||||
_tt_check_patents_in_table( FT_Face face,
|
||||
FT_ULong tag )
|
||||
{
|
||||
FT_Stream stream = face->stream;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Service_SFNT_Table service;
|
||||
FT_Bool result = FALSE;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
|
||||
|
||||
if ( service )
|
||||
{
|
||||
FT_UInt i = 0;
|
||||
FT_ULong tag_i = 0, offset_i = 0, length_i = 0;
|
||||
|
||||
|
||||
for ( i = 0; !error && tag_i != tag ; i++ )
|
||||
error = service->table_info( face, i,
|
||||
&tag_i, &offset_i, &length_i );
|
||||
|
||||
if ( error ||
|
||||
FT_STREAM_SEEK( offset_i ) )
|
||||
goto Exit;
|
||||
|
||||
result = _tt_check_patents_in_range( stream, length_i );
|
||||
}
|
||||
|
||||
Exit:
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
static FT_Bool
|
||||
_tt_face_check_patents( FT_Face face )
|
||||
{
|
||||
FT_Stream stream = face->stream;
|
||||
FT_UInt gindex;
|
||||
FT_Error error;
|
||||
FT_Bool result;
|
||||
|
||||
FT_Service_TTGlyf service;
|
||||
|
||||
|
||||
result = _tt_check_patents_in_table( face, TTAG_fpgm );
|
||||
if ( result )
|
||||
goto Exit;
|
||||
|
||||
result = _tt_check_patents_in_table( face, TTAG_prep );
|
||||
if ( result )
|
||||
goto Exit;
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, TT_GLYF );
|
||||
if ( service == NULL )
|
||||
goto Exit;
|
||||
|
||||
for ( gindex = 0; gindex < (FT_UInt)face->num_glyphs; gindex++ )
|
||||
{
|
||||
FT_ULong offset, num_ins, size;
|
||||
FT_Int num_contours;
|
||||
|
||||
|
||||
offset = service->get_location( face, gindex, &size );
|
||||
if ( size == 0 )
|
||||
continue;
|
||||
|
||||
if ( FT_STREAM_SEEK( offset ) ||
|
||||
FT_READ_SHORT( num_contours ) )
|
||||
continue;
|
||||
|
||||
if ( num_contours >= 0 ) /* simple glyph */
|
||||
{
|
||||
if ( FT_STREAM_SKIP( 8 + num_contours * 2 ) )
|
||||
continue;
|
||||
}
|
||||
else /* compound glyph */
|
||||
{
|
||||
FT_Bool has_instr = 0;
|
||||
|
||||
|
||||
if ( FT_STREAM_SKIP( 8 ) )
|
||||
continue;
|
||||
|
||||
/* now read each component */
|
||||
for (;;)
|
||||
{
|
||||
FT_UInt flags, toskip;
|
||||
|
||||
|
||||
if( FT_READ_USHORT( flags ) )
|
||||
break;
|
||||
|
||||
toskip = 2 + 1 + 1;
|
||||
|
||||
if ( ( flags & ( 1 << 0 ) ) != 0 ) /* ARGS_ARE_WORDS */
|
||||
toskip += 2;
|
||||
|
||||
if ( ( flags & ( 1 << 3 ) ) != 0 ) /* WE_HAVE_A_SCALE */
|
||||
toskip += 2;
|
||||
else if ( ( flags & ( 1 << 6 ) ) != 0 ) /* WE_HAVE_X_Y_SCALE */
|
||||
toskip += 4;
|
||||
else if ( ( flags & ( 1 << 7 ) ) != 0 ) /* WE_HAVE_A_2x2 */
|
||||
toskip += 8;
|
||||
|
||||
if ( ( flags & ( 1 << 8 ) ) != 0 ) /* WE_HAVE_INSTRUCTIONS */
|
||||
has_instr = 1;
|
||||
|
||||
if ( FT_STREAM_SKIP( toskip ) )
|
||||
goto NextGlyph;
|
||||
|
||||
if ( ( flags & ( 1 << 5 ) ) == 0 ) /* MORE_COMPONENTS */
|
||||
break;
|
||||
}
|
||||
|
||||
if ( !has_instr )
|
||||
goto NextGlyph;
|
||||
}
|
||||
|
||||
if ( FT_READ_USHORT( num_ins ) )
|
||||
continue;
|
||||
|
||||
result = _tt_check_patents_in_range( stream, num_ins );
|
||||
if ( result )
|
||||
goto Exit;
|
||||
|
||||
NextGlyph:
|
||||
;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Bool )
|
||||
FT_Face_CheckTrueTypePatents( FT_Face face )
|
||||
{
|
||||
FT_Bool result = FALSE;
|
||||
|
||||
|
||||
if ( face && FT_IS_SFNT( face ) )
|
||||
result = _tt_face_check_patents( face );
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in freetype.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Bool )
|
||||
FT_Face_SetUnpatentedHinting( FT_Face face,
|
||||
FT_Bool value )
|
||||
{
|
||||
FT_Bool result = FALSE;
|
||||
|
||||
|
||||
#if defined( TT_CONFIG_OPTION_UNPATENTED_HINTING ) && \
|
||||
!defined( TT_CONFIG_OPTION_BYTECODE_INTERPRETER )
|
||||
if ( face && FT_IS_SFNT( face ) )
|
||||
{
|
||||
result = !face->internal->ignore_unpatented_hinter;
|
||||
face->internal->ignore_unpatented_hinter = !value;
|
||||
}
|
||||
#else
|
||||
FT_UNUSED( face );
|
||||
FT_UNUSED( value );
|
||||
#endif
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,144 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftpfr.c */
|
||||
/* */
|
||||
/* FreeType API for accessing PFR-specific data (body). */
|
||||
/* */
|
||||
/* Copyright 2002, 2003, 2004, 2008, 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_SERVICE_PFR_H
|
||||
|
||||
|
||||
/* check the format */
|
||||
static FT_Service_PfrMetrics
|
||||
ft_pfr_check( FT_Face face )
|
||||
{
|
||||
FT_Service_PfrMetrics service = NULL;
|
||||
|
||||
|
||||
if ( face )
|
||||
FT_FACE_LOOKUP_SERVICE( face, service, PFR_METRICS );
|
||||
|
||||
return service;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftpfr.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_PFR_Metrics( FT_Face face,
|
||||
FT_UInt *aoutline_resolution,
|
||||
FT_UInt *ametrics_resolution,
|
||||
FT_Fixed *ametrics_x_scale,
|
||||
FT_Fixed *ametrics_y_scale )
|
||||
{
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Service_PfrMetrics service;
|
||||
|
||||
|
||||
if ( !face )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
service = ft_pfr_check( face );
|
||||
if ( service )
|
||||
{
|
||||
error = service->get_metrics( face,
|
||||
aoutline_resolution,
|
||||
ametrics_resolution,
|
||||
ametrics_x_scale,
|
||||
ametrics_y_scale );
|
||||
}
|
||||
else
|
||||
{
|
||||
FT_Fixed x_scale, y_scale;
|
||||
|
||||
|
||||
/* this is not a PFR font */
|
||||
if ( aoutline_resolution )
|
||||
*aoutline_resolution = face->units_per_EM;
|
||||
|
||||
if ( ametrics_resolution )
|
||||
*ametrics_resolution = face->units_per_EM;
|
||||
|
||||
x_scale = y_scale = 0x10000L;
|
||||
if ( face->size )
|
||||
{
|
||||
x_scale = face->size->metrics.x_scale;
|
||||
y_scale = face->size->metrics.y_scale;
|
||||
}
|
||||
|
||||
if ( ametrics_x_scale )
|
||||
*ametrics_x_scale = x_scale;
|
||||
|
||||
if ( ametrics_y_scale )
|
||||
*ametrics_y_scale = y_scale;
|
||||
|
||||
error = FT_Err_Unknown_File_Format;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftpfr.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_PFR_Kerning( FT_Face face,
|
||||
FT_UInt left,
|
||||
FT_UInt right,
|
||||
FT_Vector *avector )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Service_PfrMetrics service;
|
||||
|
||||
|
||||
if ( !face )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
service = ft_pfr_check( face );
|
||||
if ( service )
|
||||
error = service->get_kerning( face, left, right, avector );
|
||||
else
|
||||
error = FT_Get_Kerning( face, left, right,
|
||||
FT_KERNING_UNSCALED, avector );
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftpfr.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_PFR_Advance( FT_Face face,
|
||||
FT_UInt gindex,
|
||||
FT_Pos *aadvance )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Service_PfrMetrics service;
|
||||
|
||||
|
||||
service = ft_pfr_check( face );
|
||||
if ( service )
|
||||
{
|
||||
error = service->get_advance( face, gindex, aadvance );
|
||||
}
|
||||
else
|
||||
/* XXX: TODO: PROVIDE ADVANCE-LOADING METHOD TO ALL FONT DRIVERS */
|
||||
error = FT_Err_Invalid_Argument;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,54 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftpic.c */
|
||||
/* */
|
||||
/* The FreeType position independent code services (body). */
|
||||
/* */
|
||||
/* Copyright 2009 by */
|
||||
/* Oran Agra and Mickey Gabel. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include "basepic.h"
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_PIC
|
||||
|
||||
/* documentation is in ftpic.h */
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
ft_pic_container_init( FT_Library library )
|
||||
{
|
||||
FT_PIC_Container* pic_container = &library->pic_container;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
|
||||
FT_MEM_SET( pic_container, 0, sizeof(*pic_container) );
|
||||
|
||||
error = ft_base_pic_init( library );
|
||||
if(error)
|
||||
return error;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
/* Destroy the contents of the container. */
|
||||
FT_BASE_DEF( void )
|
||||
ft_pic_container_destroy( FT_Library library )
|
||||
{
|
||||
ft_base_pic_free( library );
|
||||
}
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_PIC */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,871 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftrfork.c */
|
||||
/* */
|
||||
/* Embedded resource forks accessor (body). */
|
||||
/* */
|
||||
/* Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010 by */
|
||||
/* Masatake YAMATO and Redhat K.K. */
|
||||
/* */
|
||||
/* FT_Raccess_Get_HeaderInfo() and raccess_guess_darwin_hfsplus() are */
|
||||
/* derived from ftobjs.c. */
|
||||
/* */
|
||||
/* 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
/***************************************************************************/
|
||||
/* Development of the code in this file is support of */
|
||||
/* Information-technology Promotion Agency, Japan. */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_INTERNAL_RFORK_H
|
||||
|
||||
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_raccess
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** ****/
|
||||
/**** Resource fork directory access ****/
|
||||
/**** ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Raccess_Get_HeaderInfo( FT_Library library,
|
||||
FT_Stream stream,
|
||||
FT_Long rfork_offset,
|
||||
FT_Long *map_offset,
|
||||
FT_Long *rdata_pos )
|
||||
{
|
||||
FT_Error error;
|
||||
unsigned char head[16], head2[16];
|
||||
FT_Long map_pos, rdata_len;
|
||||
int allzeros, allmatch, i;
|
||||
FT_Long type_list;
|
||||
|
||||
FT_UNUSED( library );
|
||||
|
||||
|
||||
error = FT_Stream_Seek( stream, rfork_offset );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
error = FT_Stream_Read( stream, (FT_Byte *)head, 16 );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
*rdata_pos = rfork_offset + ( ( head[0] << 24 ) |
|
||||
( head[1] << 16 ) |
|
||||
( head[2] << 8 ) |
|
||||
head[3] );
|
||||
map_pos = rfork_offset + ( ( head[4] << 24 ) |
|
||||
( head[5] << 16 ) |
|
||||
( head[6] << 8 ) |
|
||||
head[7] );
|
||||
rdata_len = ( head[ 8] << 24 ) |
|
||||
( head[ 9] << 16 ) |
|
||||
( head[10] << 8 ) |
|
||||
head[11];
|
||||
|
||||
/* map_len = head[12] .. head[15] */
|
||||
|
||||
if ( *rdata_pos + rdata_len != map_pos || map_pos == rfork_offset )
|
||||
return FT_Err_Unknown_File_Format;
|
||||
|
||||
error = FT_Stream_Seek( stream, map_pos );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
head2[15] = (FT_Byte)( head[15] + 1 ); /* make it be different */
|
||||
|
||||
error = FT_Stream_Read( stream, (FT_Byte*)head2, 16 );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
allzeros = 1;
|
||||
allmatch = 1;
|
||||
for ( i = 0; i < 16; ++i )
|
||||
{
|
||||
if ( head2[i] != 0 )
|
||||
allzeros = 0;
|
||||
if ( head2[i] != head[i] )
|
||||
allmatch = 0;
|
||||
}
|
||||
if ( !allzeros && !allmatch )
|
||||
return FT_Err_Unknown_File_Format;
|
||||
|
||||
/* If we have reached this point then it is probably a mac resource */
|
||||
/* file. Now, does it contain any interesting resources? */
|
||||
/* Skip handle to next resource map, the file resource number, and */
|
||||
/* attributes. */
|
||||
(void)FT_STREAM_SKIP( 4 /* skip handle to next resource map */
|
||||
+ 2 /* skip file resource number */
|
||||
+ 2 ); /* skip attributes */
|
||||
|
||||
if ( FT_READ_USHORT( type_list ) )
|
||||
return error;
|
||||
if ( type_list == -1 )
|
||||
return FT_Err_Unknown_File_Format;
|
||||
|
||||
error = FT_Stream_Seek( stream, map_pos + type_list );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
*map_offset = map_pos + type_list;
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ft_raccess_sort_ref_by_id( FT_RFork_Ref* a,
|
||||
FT_RFork_Ref* b )
|
||||
{
|
||||
if ( a->res_id < b->res_id )
|
||||
return -1;
|
||||
else if ( a->res_id > b->res_id )
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Raccess_Get_DataOffsets( FT_Library library,
|
||||
FT_Stream stream,
|
||||
FT_Long map_offset,
|
||||
FT_Long rdata_pos,
|
||||
FT_Long tag,
|
||||
FT_Long **offsets,
|
||||
FT_Long *count )
|
||||
{
|
||||
FT_Error error;
|
||||
int i, j, cnt, subcnt;
|
||||
FT_Long tag_internal, rpos;
|
||||
FT_Memory memory = library->memory;
|
||||
FT_Long temp;
|
||||
FT_Long *offsets_internal = NULL;
|
||||
FT_RFork_Ref *ref = NULL;
|
||||
|
||||
|
||||
error = FT_Stream_Seek( stream, map_offset );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
if ( FT_READ_USHORT( cnt ) )
|
||||
return error;
|
||||
cnt++;
|
||||
|
||||
for ( i = 0; i < cnt; ++i )
|
||||
{
|
||||
if ( FT_READ_LONG( tag_internal ) ||
|
||||
FT_READ_USHORT( subcnt ) ||
|
||||
FT_READ_USHORT( rpos ) )
|
||||
return error;
|
||||
|
||||
FT_TRACE2(( "Resource tags: %c%c%c%c\n",
|
||||
(char)( 0xff & ( tag_internal >> 24 ) ),
|
||||
(char)( 0xff & ( tag_internal >> 16 ) ),
|
||||
(char)( 0xff & ( tag_internal >> 8 ) ),
|
||||
(char)( 0xff & ( tag_internal >> 0 ) ) ));
|
||||
|
||||
if ( tag_internal == tag )
|
||||
{
|
||||
*count = subcnt + 1;
|
||||
rpos += map_offset;
|
||||
|
||||
error = FT_Stream_Seek( stream, rpos );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
if ( FT_NEW_ARRAY( ref, *count ) )
|
||||
return error;
|
||||
|
||||
for ( j = 0; j < *count; ++j )
|
||||
{
|
||||
if ( FT_READ_USHORT( ref[j].res_id ) )
|
||||
goto Exit;
|
||||
if ( FT_STREAM_SKIP( 2 ) ) /* resource name */
|
||||
goto Exit;
|
||||
if ( FT_READ_LONG( temp ) )
|
||||
goto Exit;
|
||||
if ( FT_STREAM_SKIP( 4 ) ) /* mbz */
|
||||
goto Exit;
|
||||
|
||||
ref[j].offset = temp & 0xFFFFFFL;
|
||||
}
|
||||
|
||||
ft_qsort( ref, *count, sizeof ( FT_RFork_Ref ),
|
||||
( int(*)(const void*, const void*) )
|
||||
ft_raccess_sort_ref_by_id );
|
||||
|
||||
if ( FT_NEW_ARRAY( offsets_internal, *count ) )
|
||||
goto Exit;
|
||||
|
||||
/* XXX: duplicated reference ID,
|
||||
* gap between reference IDs are acceptable?
|
||||
* further investigation on Apple implementation is needed.
|
||||
*/
|
||||
for ( j = 0; j < *count; ++j )
|
||||
offsets_internal[j] = rdata_pos + ref[j].offset;
|
||||
|
||||
*offsets = offsets_internal;
|
||||
error = FT_Err_Ok;
|
||||
|
||||
Exit:
|
||||
FT_FREE( ref );
|
||||
return error;
|
||||
}
|
||||
}
|
||||
|
||||
return FT_Err_Cannot_Open_Resource;
|
||||
}
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** ****/
|
||||
/**** Guessing functions ****/
|
||||
/**** ****/
|
||||
/**** When you add a new guessing function, ****/
|
||||
/**** update FT_RACCESS_N_RULES in ftrfork.h. ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
typedef FT_Error
|
||||
(*raccess_guess_func)( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_apple_double( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_apple_single( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_darwin_ufs_export( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_darwin_newvfs( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_darwin_hfsplus( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_vfat( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_linux_cap( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_linux_double( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_linux_netatalk( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** Helper functions ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_apple_generic( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
FT_Int32 magic,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_linux_double_from_file_name( FT_Library library,
|
||||
char * file_name,
|
||||
FT_Long *result_offset );
|
||||
|
||||
static char *
|
||||
raccess_make_file_name( FT_Memory memory,
|
||||
const char *original_name,
|
||||
const char *insertion );
|
||||
|
||||
|
||||
typedef enum FT_RFork_Rule_ {
|
||||
FT_RFork_Rule_invalid = -2,
|
||||
FT_RFork_Rule_uknown, /* -1 */
|
||||
FT_RFork_Rule_apple_double,
|
||||
FT_RFork_Rule_apple_single,
|
||||
FT_RFork_Rule_darwin_ufs_export,
|
||||
FT_RFork_Rule_darwin_newvfs,
|
||||
FT_RFork_Rule_darwin_hfsplus,
|
||||
FT_RFork_Rule_vfat,
|
||||
FT_RFork_Rule_linux_cap,
|
||||
FT_RFork_Rule_linux_double,
|
||||
FT_RFork_Rule_linux_netatalk
|
||||
} FT_RFork_Rule;
|
||||
|
||||
/* For fast translation between rule index and rule type,
|
||||
* the macros FT_RFORK_xxx should be kept consistent with
|
||||
* the raccess_guess_funcs table
|
||||
*/
|
||||
typedef struct raccess_guess_rec_ {
|
||||
raccess_guess_func func;
|
||||
FT_RFork_Rule type;
|
||||
} raccess_guess_rec;
|
||||
|
||||
static raccess_guess_rec raccess_guess_table[FT_RACCESS_N_RULES] =
|
||||
{
|
||||
{ raccess_guess_apple_double, FT_RFork_Rule_apple_double, },
|
||||
{ raccess_guess_apple_single, FT_RFork_Rule_apple_single, },
|
||||
{ raccess_guess_darwin_ufs_export, FT_RFork_Rule_darwin_ufs_export, },
|
||||
{ raccess_guess_darwin_newvfs, FT_RFork_Rule_darwin_newvfs, },
|
||||
{ raccess_guess_darwin_hfsplus, FT_RFork_Rule_darwin_hfsplus, },
|
||||
{ raccess_guess_vfat, FT_RFork_Rule_vfat, },
|
||||
{ raccess_guess_linux_cap, FT_RFork_Rule_linux_cap, },
|
||||
{ raccess_guess_linux_double, FT_RFork_Rule_linux_double, },
|
||||
{ raccess_guess_linux_netatalk, FT_RFork_Rule_linux_netatalk, },
|
||||
};
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Raccess_Guess( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char* base_name,
|
||||
char **new_names,
|
||||
FT_Long *offsets,
|
||||
FT_Error *errors )
|
||||
{
|
||||
FT_Long i;
|
||||
|
||||
|
||||
for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
|
||||
{
|
||||
new_names[i] = NULL;
|
||||
if ( NULL != stream )
|
||||
errors[i] = FT_Stream_Seek( stream, 0 );
|
||||
else
|
||||
errors[i] = FT_Err_Ok;
|
||||
|
||||
if ( errors[i] )
|
||||
continue ;
|
||||
|
||||
errors[i] = (raccess_guess_table[i].func)( library,
|
||||
stream, base_name,
|
||||
&(new_names[i]),
|
||||
&(offsets[i]) );
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
static FT_RFork_Rule
|
||||
raccess_get_rule_type_from_rule_index( FT_UInt rule_index )
|
||||
{
|
||||
if ( rule_index >= FT_RACCESS_N_RULES )
|
||||
return FT_RFork_Rule_invalid;
|
||||
|
||||
return raccess_guess_table[rule_index].type;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Bool )
|
||||
raccess_rule_by_darwin_vfs( FT_UInt rule_index )
|
||||
{
|
||||
switch( raccess_get_rule_type_from_rule_index( rule_index ) )
|
||||
{
|
||||
case FT_RFork_Rule_darwin_newvfs:
|
||||
case FT_RFork_Rule_darwin_hfsplus:
|
||||
return TRUE;
|
||||
|
||||
default:
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_apple_double( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
FT_Int32 magic = ( 0x00 << 24 ) |
|
||||
( 0x05 << 16 ) |
|
||||
( 0x16 << 8 ) |
|
||||
0x07;
|
||||
|
||||
|
||||
*result_file_name = NULL;
|
||||
if ( NULL == stream )
|
||||
return FT_Err_Cannot_Open_Stream;
|
||||
|
||||
return raccess_guess_apple_generic( library, stream, base_file_name,
|
||||
magic, result_offset );
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_apple_single( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
FT_Int32 magic = ( 0x00 << 24 ) |
|
||||
( 0x05 << 16 ) |
|
||||
( 0x16 << 8 ) |
|
||||
0x00;
|
||||
|
||||
|
||||
*result_file_name = NULL;
|
||||
if ( NULL == stream )
|
||||
return FT_Err_Cannot_Open_Stream;
|
||||
|
||||
return raccess_guess_apple_generic( library, stream, base_file_name,
|
||||
magic, result_offset );
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_darwin_ufs_export( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
char* newpath;
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
|
||||
FT_UNUSED( stream );
|
||||
|
||||
|
||||
memory = library->memory;
|
||||
newpath = raccess_make_file_name( memory, base_file_name, "._" );
|
||||
if ( !newpath )
|
||||
return FT_Err_Out_Of_Memory;
|
||||
|
||||
error = raccess_guess_linux_double_from_file_name( library, newpath,
|
||||
result_offset );
|
||||
if ( !error )
|
||||
*result_file_name = newpath;
|
||||
else
|
||||
FT_FREE( newpath );
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_darwin_hfsplus( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
/*
|
||||
Only meaningful on systems with hfs+ drivers (or Macs).
|
||||
*/
|
||||
FT_Error error;
|
||||
char* newpath = NULL;
|
||||
FT_Memory memory;
|
||||
FT_Long base_file_len = ft_strlen( base_file_name );
|
||||
|
||||
FT_UNUSED( stream );
|
||||
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
if ( base_file_len + 6 > FT_INT_MAX )
|
||||
return FT_Err_Array_Too_Large;
|
||||
|
||||
if ( FT_ALLOC( newpath, base_file_len + 6 ) )
|
||||
return error;
|
||||
|
||||
FT_MEM_COPY( newpath, base_file_name, base_file_len );
|
||||
FT_MEM_COPY( newpath + base_file_len, "/rsrc", 6 );
|
||||
|
||||
*result_file_name = newpath;
|
||||
*result_offset = 0;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_darwin_newvfs( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
/*
|
||||
Only meaningful on systems with Mac OS X (> 10.1).
|
||||
*/
|
||||
FT_Error error;
|
||||
char* newpath = NULL;
|
||||
FT_Memory memory;
|
||||
FT_Long base_file_len = ft_strlen( base_file_name );
|
||||
|
||||
FT_UNUSED( stream );
|
||||
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
if ( base_file_len + 18 > FT_INT_MAX )
|
||||
return FT_Err_Array_Too_Large;
|
||||
|
||||
if ( FT_ALLOC( newpath, base_file_len + 18 ) )
|
||||
return error;
|
||||
|
||||
FT_MEM_COPY( newpath, base_file_name, base_file_len );
|
||||
FT_MEM_COPY( newpath + base_file_len, "/..namedfork/rsrc", 18 );
|
||||
|
||||
*result_file_name = newpath;
|
||||
*result_offset = 0;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_vfat( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
char* newpath;
|
||||
FT_Memory memory;
|
||||
|
||||
FT_UNUSED( stream );
|
||||
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
newpath = raccess_make_file_name( memory, base_file_name,
|
||||
"resource.frk/" );
|
||||
if ( !newpath )
|
||||
return FT_Err_Out_Of_Memory;
|
||||
|
||||
*result_file_name = newpath;
|
||||
*result_offset = 0;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_linux_cap( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
char* newpath;
|
||||
FT_Memory memory;
|
||||
|
||||
FT_UNUSED( stream );
|
||||
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
newpath = raccess_make_file_name( memory, base_file_name, ".resource/" );
|
||||
if ( !newpath )
|
||||
return FT_Err_Out_Of_Memory;
|
||||
|
||||
*result_file_name = newpath;
|
||||
*result_offset = 0;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_linux_double( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
char* newpath;
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
|
||||
FT_UNUSED( stream );
|
||||
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
newpath = raccess_make_file_name( memory, base_file_name, "%" );
|
||||
if ( !newpath )
|
||||
return FT_Err_Out_Of_Memory;
|
||||
|
||||
error = raccess_guess_linux_double_from_file_name( library, newpath,
|
||||
result_offset );
|
||||
if ( !error )
|
||||
*result_file_name = newpath;
|
||||
else
|
||||
FT_FREE( newpath );
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_linux_netatalk( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
char **result_file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
char* newpath;
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
|
||||
FT_UNUSED( stream );
|
||||
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
newpath = raccess_make_file_name( memory, base_file_name,
|
||||
".AppleDouble/" );
|
||||
if ( !newpath )
|
||||
return FT_Err_Out_Of_Memory;
|
||||
|
||||
error = raccess_guess_linux_double_from_file_name( library, newpath,
|
||||
result_offset );
|
||||
if ( !error )
|
||||
*result_file_name = newpath;
|
||||
else
|
||||
FT_FREE( newpath );
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_apple_generic( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_file_name,
|
||||
FT_Int32 magic,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
FT_Int32 magic_from_stream;
|
||||
FT_Error error;
|
||||
FT_Int32 version_number = 0;
|
||||
FT_UShort n_of_entries;
|
||||
|
||||
int i;
|
||||
FT_UInt32 entry_id, entry_offset, entry_length = 0;
|
||||
|
||||
const FT_UInt32 resource_fork_entry_id = 0x2;
|
||||
|
||||
FT_UNUSED( library );
|
||||
FT_UNUSED( base_file_name );
|
||||
FT_UNUSED( version_number );
|
||||
FT_UNUSED( entry_length );
|
||||
|
||||
|
||||
if ( FT_READ_LONG( magic_from_stream ) )
|
||||
return error;
|
||||
if ( magic_from_stream != magic )
|
||||
return FT_Err_Unknown_File_Format;
|
||||
|
||||
if ( FT_READ_LONG( version_number ) )
|
||||
return error;
|
||||
|
||||
/* filler */
|
||||
error = FT_Stream_Skip( stream, 16 );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
if ( FT_READ_USHORT( n_of_entries ) )
|
||||
return error;
|
||||
if ( n_of_entries == 0 )
|
||||
return FT_Err_Unknown_File_Format;
|
||||
|
||||
for ( i = 0; i < n_of_entries; i++ )
|
||||
{
|
||||
if ( FT_READ_LONG( entry_id ) )
|
||||
return error;
|
||||
if ( entry_id == resource_fork_entry_id )
|
||||
{
|
||||
if ( FT_READ_LONG( entry_offset ) ||
|
||||
FT_READ_LONG( entry_length ) )
|
||||
continue;
|
||||
*result_offset = entry_offset;
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
else
|
||||
{
|
||||
error = FT_Stream_Skip( stream, 4 + 4 ); /* offset + length */
|
||||
if ( error )
|
||||
return error;
|
||||
}
|
||||
}
|
||||
|
||||
return FT_Err_Unknown_File_Format;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
raccess_guess_linux_double_from_file_name( FT_Library library,
|
||||
char *file_name,
|
||||
FT_Long *result_offset )
|
||||
{
|
||||
FT_Open_Args args2;
|
||||
FT_Stream stream2;
|
||||
char * nouse = NULL;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
args2.flags = FT_OPEN_PATHNAME;
|
||||
args2.pathname = file_name;
|
||||
error = FT_Stream_New( library, &args2, &stream2 );
|
||||
if ( error )
|
||||
return error;
|
||||
|
||||
error = raccess_guess_apple_double( library, stream2, file_name,
|
||||
&nouse, result_offset );
|
||||
|
||||
FT_Stream_Free( stream2, 0 );
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static char*
|
||||
raccess_make_file_name( FT_Memory memory,
|
||||
const char *original_name,
|
||||
const char *insertion )
|
||||
{
|
||||
char* new_name = NULL;
|
||||
const char* tmp;
|
||||
const char* slash;
|
||||
size_t new_length;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
|
||||
FT_UNUSED( error );
|
||||
|
||||
|
||||
new_length = ft_strlen( original_name ) + ft_strlen( insertion );
|
||||
if ( FT_ALLOC( new_name, new_length + 1 ) )
|
||||
return NULL;
|
||||
|
||||
tmp = ft_strrchr( original_name, '/' );
|
||||
if ( tmp )
|
||||
{
|
||||
ft_strncpy( new_name, original_name, tmp - original_name + 1 );
|
||||
new_name[tmp - original_name + 1] = '\0';
|
||||
slash = tmp + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
slash = original_name;
|
||||
new_name[0] = '\0';
|
||||
}
|
||||
|
||||
ft_strcat( new_name, insertion );
|
||||
ft_strcat( new_name, slash );
|
||||
|
||||
return new_name;
|
||||
}
|
||||
|
||||
|
||||
#else /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* Dummy function; just sets errors */
|
||||
/*************************************************************************/
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Raccess_Guess( FT_Library library,
|
||||
FT_Stream stream,
|
||||
char *base_name,
|
||||
char **new_names,
|
||||
FT_Long *offsets,
|
||||
FT_Error *errors )
|
||||
{
|
||||
int i;
|
||||
|
||||
FT_UNUSED( library );
|
||||
FT_UNUSED( stream );
|
||||
FT_UNUSED( base_name );
|
||||
|
||||
|
||||
for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
|
||||
{
|
||||
new_names[i] = NULL;
|
||||
offsets[i] = 0;
|
||||
errors[i] = FT_Err_Unimplemented_Feature;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#endif /* !FT_CONFIG_OPTION_GUESSING_EMBEDDED_RFORK */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,94 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftsnames.c */
|
||||
/* */
|
||||
/* Simple interface to access SFNT name tables (which are used */
|
||||
/* to hold font names, copyright info, notices, etc.) (body). */
|
||||
/* */
|
||||
/* This is _not_ used to retrieve glyph names! */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2002, 2009 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_SFNT_NAMES_H
|
||||
#include FT_INTERNAL_TRUETYPE_TYPES_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
|
||||
|
||||
#ifdef TT_CONFIG_OPTION_SFNT_NAMES
|
||||
|
||||
|
||||
/* documentation is in ftsnames.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_UInt )
|
||||
FT_Get_Sfnt_Name_Count( FT_Face face )
|
||||
{
|
||||
return ( face && FT_IS_SFNT( face ) ) ? ((TT_Face)face)->num_names : 0;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftsnames.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_Sfnt_Name( FT_Face face,
|
||||
FT_UInt idx,
|
||||
FT_SfntName *aname )
|
||||
{
|
||||
FT_Error error = FT_Err_Invalid_Argument;
|
||||
|
||||
|
||||
if ( aname && face && FT_IS_SFNT( face ) )
|
||||
{
|
||||
TT_Face ttface = (TT_Face)face;
|
||||
|
||||
|
||||
if ( idx < (FT_UInt)ttface->num_names )
|
||||
{
|
||||
TT_NameEntryRec* entry = ttface->name_table.names + idx;
|
||||
|
||||
|
||||
/* load name on demand */
|
||||
if ( entry->stringLength > 0 && entry->string == NULL )
|
||||
{
|
||||
FT_Memory memory = face->memory;
|
||||
FT_Stream stream = face->stream;
|
||||
|
||||
|
||||
if ( FT_NEW_ARRAY ( entry->string, entry->stringLength ) ||
|
||||
FT_STREAM_SEEK( entry->stringOffset ) ||
|
||||
FT_STREAM_READ( entry->string, entry->stringLength ) )
|
||||
{
|
||||
FT_FREE( entry->string );
|
||||
entry->stringLength = 0;
|
||||
}
|
||||
}
|
||||
|
||||
aname->platform_id = entry->platformID;
|
||||
aname->encoding_id = entry->encodingID;
|
||||
aname->language_id = entry->languageID;
|
||||
aname->name_id = entry->nameID;
|
||||
aname->string = (FT_Byte*)entry->string;
|
||||
aname->string_len = entry->stringLength;
|
||||
|
||||
error = FT_Err_Ok;
|
||||
}
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
#endif /* TT_CONFIG_OPTION_SFNT_NAMES */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,864 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftstream.c */
|
||||
/* */
|
||||
/* I/O stream support (body). */
|
||||
/* */
|
||||
/* Copyright 2000-2002, 2004-2006, 2008-2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_stream
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Stream_OpenMemory( FT_Stream stream,
|
||||
const FT_Byte* base,
|
||||
FT_ULong size )
|
||||
{
|
||||
stream->base = (FT_Byte*) base;
|
||||
stream->size = size;
|
||||
stream->pos = 0;
|
||||
stream->cursor = 0;
|
||||
stream->read = 0;
|
||||
stream->close = 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Stream_Close( FT_Stream stream )
|
||||
{
|
||||
if ( stream && stream->close )
|
||||
stream->close( stream );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Stream_Seek( FT_Stream stream,
|
||||
FT_ULong pos )
|
||||
{
|
||||
FT_Error error = FT_Err_Ok;
|
||||
|
||||
|
||||
if ( stream->read )
|
||||
{
|
||||
if ( stream->read( stream, pos, 0, 0 ) )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_Seek:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
pos, stream->size ));
|
||||
|
||||
error = FT_Err_Invalid_Stream_Operation;
|
||||
}
|
||||
}
|
||||
/* note that seeking to the first position after the file is valid */
|
||||
else if ( pos > stream->size )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_Seek:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
pos, stream->size ));
|
||||
|
||||
error = FT_Err_Invalid_Stream_Operation;
|
||||
}
|
||||
|
||||
if ( !error )
|
||||
stream->pos = pos;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Stream_Skip( FT_Stream stream,
|
||||
FT_Long distance )
|
||||
{
|
||||
if ( distance < 0 )
|
||||
return FT_Err_Invalid_Stream_Operation;
|
||||
|
||||
return FT_Stream_Seek( stream, (FT_ULong)( stream->pos + distance ) );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Long )
|
||||
FT_Stream_Pos( FT_Stream stream )
|
||||
{
|
||||
return stream->pos;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Stream_Read( FT_Stream stream,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
return FT_Stream_ReadAt( stream, stream->pos, buffer, count );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Stream_ReadAt( FT_Stream stream,
|
||||
FT_ULong pos,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_ULong read_bytes;
|
||||
|
||||
|
||||
if ( pos >= stream->size )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_ReadAt:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
pos, stream->size ));
|
||||
|
||||
return FT_Err_Invalid_Stream_Operation;
|
||||
}
|
||||
|
||||
if ( stream->read )
|
||||
read_bytes = stream->read( stream, pos, buffer, count );
|
||||
else
|
||||
{
|
||||
read_bytes = stream->size - pos;
|
||||
if ( read_bytes > count )
|
||||
read_bytes = count;
|
||||
|
||||
FT_MEM_COPY( buffer, stream->base + pos, read_bytes );
|
||||
}
|
||||
|
||||
stream->pos = pos + read_bytes;
|
||||
|
||||
if ( read_bytes < count )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_ReadAt:"
|
||||
" invalid read; expected %lu bytes, got %lu\n",
|
||||
count, read_bytes ));
|
||||
|
||||
error = FT_Err_Invalid_Stream_Operation;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_ULong )
|
||||
FT_Stream_TryRead( FT_Stream stream,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_ULong read_bytes = 0;
|
||||
|
||||
|
||||
if ( stream->pos >= stream->size )
|
||||
goto Exit;
|
||||
|
||||
if ( stream->read )
|
||||
read_bytes = stream->read( stream, stream->pos, buffer, count );
|
||||
else
|
||||
{
|
||||
read_bytes = stream->size - stream->pos;
|
||||
if ( read_bytes > count )
|
||||
read_bytes = count;
|
||||
|
||||
FT_MEM_COPY( buffer, stream->base + stream->pos, read_bytes );
|
||||
}
|
||||
|
||||
stream->pos += read_bytes;
|
||||
|
||||
Exit:
|
||||
return read_bytes;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Stream_ExtractFrame( FT_Stream stream,
|
||||
FT_ULong count,
|
||||
FT_Byte** pbytes )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
error = FT_Stream_EnterFrame( stream, count );
|
||||
if ( !error )
|
||||
{
|
||||
*pbytes = (FT_Byte*)stream->cursor;
|
||||
|
||||
/* equivalent to FT_Stream_ExitFrame(), with no memory block release */
|
||||
stream->cursor = 0;
|
||||
stream->limit = 0;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Stream_ReleaseFrame( FT_Stream stream,
|
||||
FT_Byte** pbytes )
|
||||
{
|
||||
if ( stream && stream->read )
|
||||
{
|
||||
FT_Memory memory = stream->memory;
|
||||
|
||||
#ifdef FT_DEBUG_MEMORY
|
||||
ft_mem_free( memory, *pbytes );
|
||||
*pbytes = NULL;
|
||||
#else
|
||||
FT_FREE( *pbytes );
|
||||
#endif
|
||||
}
|
||||
*pbytes = 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Stream_EnterFrame( FT_Stream stream,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_ULong read_bytes;
|
||||
|
||||
|
||||
/* check for nested frame access */
|
||||
FT_ASSERT( stream && stream->cursor == 0 );
|
||||
|
||||
if ( stream->read )
|
||||
{
|
||||
/* allocate the frame in memory */
|
||||
FT_Memory memory = stream->memory;
|
||||
|
||||
|
||||
/* simple sanity check */
|
||||
if ( count > stream->size )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_EnterFrame:"
|
||||
" frame size (%lu) larger than stream size (%lu)\n",
|
||||
count, stream->size ));
|
||||
|
||||
error = FT_Err_Invalid_Stream_Operation;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
#ifdef FT_DEBUG_MEMORY
|
||||
/* assume _ft_debug_file and _ft_debug_lineno are already set */
|
||||
stream->base = (unsigned char*)ft_mem_qalloc( memory, count, &error );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
#else
|
||||
if ( FT_QALLOC( stream->base, count ) )
|
||||
goto Exit;
|
||||
#endif
|
||||
/* read it */
|
||||
read_bytes = stream->read( stream, stream->pos,
|
||||
stream->base, count );
|
||||
if ( read_bytes < count )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_EnterFrame:"
|
||||
" invalid read; expected %lu bytes, got %lu\n",
|
||||
count, read_bytes ));
|
||||
|
||||
FT_FREE( stream->base );
|
||||
error = FT_Err_Invalid_Stream_Operation;
|
||||
}
|
||||
stream->cursor = stream->base;
|
||||
stream->limit = stream->cursor + count;
|
||||
stream->pos += read_bytes;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* check current and new position */
|
||||
if ( stream->pos >= stream->size ||
|
||||
stream->size - stream->pos < count )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_EnterFrame:"
|
||||
" invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx\n",
|
||||
stream->pos, count, stream->size ));
|
||||
|
||||
error = FT_Err_Invalid_Stream_Operation;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* set cursor */
|
||||
stream->cursor = stream->base + stream->pos;
|
||||
stream->limit = stream->cursor + count;
|
||||
stream->pos += count;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Stream_ExitFrame( FT_Stream stream )
|
||||
{
|
||||
/* IMPORTANT: The assertion stream->cursor != 0 was removed, given */
|
||||
/* that it is possible to access a frame of length 0 in */
|
||||
/* some weird fonts (usually, when accessing an array of */
|
||||
/* 0 records, like in some strange kern tables). */
|
||||
/* */
|
||||
/* In this case, the loader code handles the 0-length table */
|
||||
/* gracefully; however, stream.cursor is really set to 0 by the */
|
||||
/* FT_Stream_EnterFrame() call, and this is not an error. */
|
||||
/* */
|
||||
FT_ASSERT( stream );
|
||||
|
||||
if ( stream->read )
|
||||
{
|
||||
FT_Memory memory = stream->memory;
|
||||
|
||||
#ifdef FT_DEBUG_MEMORY
|
||||
ft_mem_free( memory, stream->base );
|
||||
stream->base = NULL;
|
||||
#else
|
||||
FT_FREE( stream->base );
|
||||
#endif
|
||||
}
|
||||
stream->cursor = 0;
|
||||
stream->limit = 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Char )
|
||||
FT_Stream_GetChar( FT_Stream stream )
|
||||
{
|
||||
FT_Char result;
|
||||
|
||||
|
||||
FT_ASSERT( stream && stream->cursor );
|
||||
|
||||
result = 0;
|
||||
if ( stream->cursor < stream->limit )
|
||||
result = *stream->cursor++;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_UShort )
|
||||
FT_Stream_GetUShort( FT_Stream stream )
|
||||
{
|
||||
FT_Byte* p;
|
||||
FT_Short result;
|
||||
|
||||
|
||||
FT_ASSERT( stream && stream->cursor );
|
||||
|
||||
result = 0;
|
||||
p = stream->cursor;
|
||||
if ( p + 1 < stream->limit )
|
||||
result = FT_NEXT_USHORT( p );
|
||||
stream->cursor = p;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_UShort )
|
||||
FT_Stream_GetUShortLE( FT_Stream stream )
|
||||
{
|
||||
FT_Byte* p;
|
||||
FT_Short result;
|
||||
|
||||
|
||||
FT_ASSERT( stream && stream->cursor );
|
||||
|
||||
result = 0;
|
||||
p = stream->cursor;
|
||||
if ( p + 1 < stream->limit )
|
||||
result = FT_NEXT_USHORT_LE( p );
|
||||
stream->cursor = p;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_ULong )
|
||||
FT_Stream_GetUOffset( FT_Stream stream )
|
||||
{
|
||||
FT_Byte* p;
|
||||
FT_Long result;
|
||||
|
||||
|
||||
FT_ASSERT( stream && stream->cursor );
|
||||
|
||||
result = 0;
|
||||
p = stream->cursor;
|
||||
if ( p + 2 < stream->limit )
|
||||
result = FT_NEXT_UOFF3( p );
|
||||
stream->cursor = p;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_ULong )
|
||||
FT_Stream_GetULong( FT_Stream stream )
|
||||
{
|
||||
FT_Byte* p;
|
||||
FT_Long result;
|
||||
|
||||
|
||||
FT_ASSERT( stream && stream->cursor );
|
||||
|
||||
result = 0;
|
||||
p = stream->cursor;
|
||||
if ( p + 3 < stream->limit )
|
||||
result = FT_NEXT_ULONG( p );
|
||||
stream->cursor = p;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_ULong )
|
||||
FT_Stream_GetULongLE( FT_Stream stream )
|
||||
{
|
||||
FT_Byte* p;
|
||||
FT_Long result;
|
||||
|
||||
|
||||
FT_ASSERT( stream && stream->cursor );
|
||||
|
||||
result = 0;
|
||||
p = stream->cursor;
|
||||
if ( p + 3 < stream->limit )
|
||||
result = FT_NEXT_ULONG_LE( p );
|
||||
stream->cursor = p;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Char )
|
||||
FT_Stream_ReadChar( FT_Stream stream,
|
||||
FT_Error* error )
|
||||
{
|
||||
FT_Byte result = 0;
|
||||
|
||||
|
||||
FT_ASSERT( stream );
|
||||
|
||||
*error = FT_Err_Ok;
|
||||
|
||||
if ( stream->read )
|
||||
{
|
||||
if ( stream->read( stream, stream->pos, &result, 1L ) != 1L )
|
||||
goto Fail;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( stream->pos < stream->size )
|
||||
result = stream->base[stream->pos];
|
||||
else
|
||||
goto Fail;
|
||||
}
|
||||
stream->pos++;
|
||||
|
||||
return result;
|
||||
|
||||
Fail:
|
||||
*error = FT_Err_Invalid_Stream_Operation;
|
||||
FT_ERROR(( "FT_Stream_ReadChar:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
stream->pos, stream->size ));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_UShort )
|
||||
FT_Stream_ReadUShort( FT_Stream stream,
|
||||
FT_Error* error )
|
||||
{
|
||||
FT_Byte reads[2];
|
||||
FT_Byte* p = 0;
|
||||
FT_Short result = 0;
|
||||
|
||||
|
||||
FT_ASSERT( stream );
|
||||
|
||||
*error = FT_Err_Ok;
|
||||
|
||||
if ( stream->pos + 1 < stream->size )
|
||||
{
|
||||
if ( stream->read )
|
||||
{
|
||||
if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
|
||||
goto Fail;
|
||||
|
||||
p = reads;
|
||||
}
|
||||
else
|
||||
{
|
||||
p = stream->base + stream->pos;
|
||||
}
|
||||
|
||||
if ( p )
|
||||
result = FT_NEXT_USHORT( p );
|
||||
}
|
||||
else
|
||||
goto Fail;
|
||||
|
||||
stream->pos += 2;
|
||||
|
||||
return result;
|
||||
|
||||
Fail:
|
||||
*error = FT_Err_Invalid_Stream_Operation;
|
||||
FT_ERROR(( "FT_Stream_ReadUShort:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
stream->pos, stream->size ));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_UShort )
|
||||
FT_Stream_ReadUShortLE( FT_Stream stream,
|
||||
FT_Error* error )
|
||||
{
|
||||
FT_Byte reads[2];
|
||||
FT_Byte* p = 0;
|
||||
FT_Short result = 0;
|
||||
|
||||
|
||||
FT_ASSERT( stream );
|
||||
|
||||
*error = FT_Err_Ok;
|
||||
|
||||
if ( stream->pos + 1 < stream->size )
|
||||
{
|
||||
if ( stream->read )
|
||||
{
|
||||
if ( stream->read( stream, stream->pos, reads, 2L ) != 2L )
|
||||
goto Fail;
|
||||
|
||||
p = reads;
|
||||
}
|
||||
else
|
||||
{
|
||||
p = stream->base + stream->pos;
|
||||
}
|
||||
|
||||
if ( p )
|
||||
result = FT_NEXT_USHORT_LE( p );
|
||||
}
|
||||
else
|
||||
goto Fail;
|
||||
|
||||
stream->pos += 2;
|
||||
|
||||
return result;
|
||||
|
||||
Fail:
|
||||
*error = FT_Err_Invalid_Stream_Operation;
|
||||
FT_ERROR(( "FT_Stream_ReadUShortLE:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
stream->pos, stream->size ));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_ULong )
|
||||
FT_Stream_ReadUOffset( FT_Stream stream,
|
||||
FT_Error* error )
|
||||
{
|
||||
FT_Byte reads[3];
|
||||
FT_Byte* p = 0;
|
||||
FT_Long result = 0;
|
||||
|
||||
|
||||
FT_ASSERT( stream );
|
||||
|
||||
*error = FT_Err_Ok;
|
||||
|
||||
if ( stream->pos + 2 < stream->size )
|
||||
{
|
||||
if ( stream->read )
|
||||
{
|
||||
if (stream->read( stream, stream->pos, reads, 3L ) != 3L )
|
||||
goto Fail;
|
||||
|
||||
p = reads;
|
||||
}
|
||||
else
|
||||
{
|
||||
p = stream->base + stream->pos;
|
||||
}
|
||||
|
||||
if ( p )
|
||||
result = FT_NEXT_UOFF3( p );
|
||||
}
|
||||
else
|
||||
goto Fail;
|
||||
|
||||
stream->pos += 3;
|
||||
|
||||
return result;
|
||||
|
||||
Fail:
|
||||
*error = FT_Err_Invalid_Stream_Operation;
|
||||
FT_ERROR(( "FT_Stream_ReadUOffset:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
stream->pos, stream->size ));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_ULong )
|
||||
FT_Stream_ReadULong( FT_Stream stream,
|
||||
FT_Error* error )
|
||||
{
|
||||
FT_Byte reads[4];
|
||||
FT_Byte* p = 0;
|
||||
FT_Long result = 0;
|
||||
|
||||
|
||||
FT_ASSERT( stream );
|
||||
|
||||
*error = FT_Err_Ok;
|
||||
|
||||
if ( stream->pos + 3 < stream->size )
|
||||
{
|
||||
if ( stream->read )
|
||||
{
|
||||
if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
|
||||
goto Fail;
|
||||
|
||||
p = reads;
|
||||
}
|
||||
else
|
||||
{
|
||||
p = stream->base + stream->pos;
|
||||
}
|
||||
|
||||
if ( p )
|
||||
result = FT_NEXT_ULONG( p );
|
||||
}
|
||||
else
|
||||
goto Fail;
|
||||
|
||||
stream->pos += 4;
|
||||
|
||||
return result;
|
||||
|
||||
Fail:
|
||||
*error = FT_Err_Invalid_Stream_Operation;
|
||||
FT_ERROR(( "FT_Stream_ReadULong:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
stream->pos, stream->size ));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_ULong )
|
||||
FT_Stream_ReadULongLE( FT_Stream stream,
|
||||
FT_Error* error )
|
||||
{
|
||||
FT_Byte reads[4];
|
||||
FT_Byte* p = 0;
|
||||
FT_Long result = 0;
|
||||
|
||||
|
||||
FT_ASSERT( stream );
|
||||
|
||||
*error = FT_Err_Ok;
|
||||
|
||||
if ( stream->pos + 3 < stream->size )
|
||||
{
|
||||
if ( stream->read )
|
||||
{
|
||||
if ( stream->read( stream, stream->pos, reads, 4L ) != 4L )
|
||||
goto Fail;
|
||||
|
||||
p = reads;
|
||||
}
|
||||
else
|
||||
{
|
||||
p = stream->base + stream->pos;
|
||||
}
|
||||
|
||||
if ( p )
|
||||
result = FT_NEXT_ULONG_LE( p );
|
||||
}
|
||||
else
|
||||
goto Fail;
|
||||
|
||||
stream->pos += 4;
|
||||
|
||||
return result;
|
||||
|
||||
Fail:
|
||||
*error = FT_Err_Invalid_Stream_Operation;
|
||||
FT_ERROR(( "FT_Stream_ReadULongLE:"
|
||||
" invalid i/o; pos = 0x%lx, size = 0x%lx\n",
|
||||
stream->pos, stream->size ));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Stream_ReadFields( FT_Stream stream,
|
||||
const FT_Frame_Field* fields,
|
||||
void* structure )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Bool frame_accessed = 0;
|
||||
FT_Byte* cursor;
|
||||
|
||||
if ( !fields || !stream )
|
||||
return FT_Err_Invalid_Argument;
|
||||
|
||||
cursor = stream->cursor;
|
||||
|
||||
error = FT_Err_Ok;
|
||||
do
|
||||
{
|
||||
FT_ULong value;
|
||||
FT_Int sign_shift;
|
||||
FT_Byte* p;
|
||||
|
||||
|
||||
switch ( fields->value )
|
||||
{
|
||||
case ft_frame_start: /* access a new frame */
|
||||
error = FT_Stream_EnterFrame( stream, fields->offset );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
frame_accessed = 1;
|
||||
cursor = stream->cursor;
|
||||
fields++;
|
||||
continue; /* loop! */
|
||||
|
||||
case ft_frame_bytes: /* read a byte sequence */
|
||||
case ft_frame_skip: /* skip some bytes */
|
||||
{
|
||||
FT_UInt len = fields->size;
|
||||
|
||||
|
||||
if ( cursor + len > stream->limit )
|
||||
{
|
||||
error = FT_Err_Invalid_Stream_Operation;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( fields->value == ft_frame_bytes )
|
||||
{
|
||||
p = (FT_Byte*)structure + fields->offset;
|
||||
FT_MEM_COPY( p, cursor, len );
|
||||
}
|
||||
cursor += len;
|
||||
fields++;
|
||||
continue;
|
||||
}
|
||||
|
||||
case ft_frame_byte:
|
||||
case ft_frame_schar: /* read a single byte */
|
||||
value = FT_NEXT_BYTE(cursor);
|
||||
sign_shift = 24;
|
||||
break;
|
||||
|
||||
case ft_frame_short_be:
|
||||
case ft_frame_ushort_be: /* read a 2-byte big-endian short */
|
||||
value = FT_NEXT_USHORT(cursor);
|
||||
sign_shift = 16;
|
||||
break;
|
||||
|
||||
case ft_frame_short_le:
|
||||
case ft_frame_ushort_le: /* read a 2-byte little-endian short */
|
||||
value = FT_NEXT_USHORT_LE(cursor);
|
||||
sign_shift = 16;
|
||||
break;
|
||||
|
||||
case ft_frame_long_be:
|
||||
case ft_frame_ulong_be: /* read a 4-byte big-endian long */
|
||||
value = FT_NEXT_ULONG(cursor);
|
||||
sign_shift = 0;
|
||||
break;
|
||||
|
||||
case ft_frame_long_le:
|
||||
case ft_frame_ulong_le: /* read a 4-byte little-endian long */
|
||||
value = FT_NEXT_ULONG_LE(cursor);
|
||||
sign_shift = 0;
|
||||
break;
|
||||
|
||||
case ft_frame_off3_be:
|
||||
case ft_frame_uoff3_be: /* read a 3-byte big-endian long */
|
||||
value = FT_NEXT_UOFF3(cursor);
|
||||
sign_shift = 8;
|
||||
break;
|
||||
|
||||
case ft_frame_off3_le:
|
||||
case ft_frame_uoff3_le: /* read a 3-byte little-endian long */
|
||||
value = FT_NEXT_UOFF3_LE(cursor);
|
||||
sign_shift = 8;
|
||||
break;
|
||||
|
||||
default:
|
||||
/* otherwise, exit the loop */
|
||||
stream->cursor = cursor;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* now, compute the signed value is necessary */
|
||||
if ( fields->value & FT_FRAME_OP_SIGNED )
|
||||
value = (FT_ULong)( (FT_Int32)( value << sign_shift ) >> sign_shift );
|
||||
|
||||
/* finally, store the value in the object */
|
||||
|
||||
p = (FT_Byte*)structure + fields->offset;
|
||||
switch ( fields->size )
|
||||
{
|
||||
case (8 / FT_CHAR_BIT):
|
||||
*(FT_Byte*)p = (FT_Byte)value;
|
||||
break;
|
||||
|
||||
case (16 / FT_CHAR_BIT):
|
||||
*(FT_UShort*)p = (FT_UShort)value;
|
||||
break;
|
||||
|
||||
case (32 / FT_CHAR_BIT):
|
||||
*(FT_UInt32*)p = (FT_UInt32)value;
|
||||
break;
|
||||
|
||||
default: /* for 64-bit systems */
|
||||
*(FT_ULong*)p = (FT_ULong)value;
|
||||
}
|
||||
|
||||
/* go to next field */
|
||||
fields++;
|
||||
}
|
||||
while ( 1 );
|
||||
|
||||
Exit:
|
||||
/* close the frame if it was opened by this read */
|
||||
if ( frame_accessed )
|
||||
FT_Stream_ExitFrame( stream );
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,160 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftsynth.c */
|
||||
/* */
|
||||
/* FreeType synthesizing code for emboldening and slanting (body). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_SYNTHESIS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_OUTLINE_H
|
||||
#include FT_BITMAP_H
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_synth
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** EXPERIMENTAL OBLIQUING SUPPORT ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/* documentation is in ftsynth.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_GlyphSlot_Oblique( FT_GlyphSlot slot )
|
||||
{
|
||||
FT_Matrix transform;
|
||||
FT_Outline* outline = &slot->outline;
|
||||
|
||||
|
||||
/* only oblique outline glyphs */
|
||||
if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )
|
||||
return;
|
||||
|
||||
/* we don't touch the advance width */
|
||||
|
||||
/* For italic, simply apply a shear transform, with an angle */
|
||||
/* of about 12 degrees. */
|
||||
|
||||
transform.xx = 0x10000L;
|
||||
transform.yx = 0x00000L;
|
||||
|
||||
transform.xy = 0x06000L;
|
||||
transform.yy = 0x10000L;
|
||||
|
||||
FT_Outline_Transform( outline, &transform );
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/**** ****/
|
||||
/**** EXPERIMENTAL EMBOLDENING/OUTLINING SUPPORT ****/
|
||||
/**** ****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/* documentation is in ftsynth.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_GlyphSlot_Embolden( FT_GlyphSlot slot )
|
||||
{
|
||||
FT_Library library = slot->library;
|
||||
FT_Face face = slot->face;
|
||||
FT_Error error;
|
||||
FT_Pos xstr, ystr;
|
||||
|
||||
|
||||
if ( slot->format != FT_GLYPH_FORMAT_OUTLINE &&
|
||||
slot->format != FT_GLYPH_FORMAT_BITMAP )
|
||||
return;
|
||||
|
||||
/* some reasonable strength */
|
||||
xstr = FT_MulFix( face->units_per_EM,
|
||||
face->size->metrics.y_scale ) / 24;
|
||||
ystr = xstr;
|
||||
|
||||
if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
|
||||
{
|
||||
/* ignore error */
|
||||
(void)FT_Outline_Embolden( &slot->outline, xstr );
|
||||
|
||||
/* this is more than enough for most glyphs; if you need accurate */
|
||||
/* values, you have to call FT_Outline_Get_CBox */
|
||||
xstr = xstr * 2;
|
||||
ystr = xstr;
|
||||
}
|
||||
else /* slot->format == FT_GLYPH_FORMAT_BITMAP */
|
||||
{
|
||||
/* round to full pixels */
|
||||
xstr &= ~63;
|
||||
if ( xstr == 0 )
|
||||
xstr = 1 << 6;
|
||||
ystr &= ~63;
|
||||
|
||||
/*
|
||||
* XXX: overflow check for 16-bit system, for compatibility
|
||||
* with FT_GlyphSlot_Embolden() since freetype-2.1.10.
|
||||
* unfortunately, this function return no informations
|
||||
* about the cause of error.
|
||||
*/
|
||||
if ( ( ystr >> 6 ) > FT_INT_MAX || ( ystr >> 6 ) < FT_INT_MIN )
|
||||
{
|
||||
FT_TRACE1(( "FT_GlyphSlot_Embolden:" ));
|
||||
FT_TRACE1(( "too strong embolding parameter ystr=%d\n", ystr ));
|
||||
return;
|
||||
}
|
||||
error = FT_GlyphSlot_Own_Bitmap( slot );
|
||||
if ( error )
|
||||
return;
|
||||
|
||||
error = FT_Bitmap_Embolden( library, &slot->bitmap, xstr, ystr );
|
||||
if ( error )
|
||||
return;
|
||||
}
|
||||
|
||||
if ( slot->advance.x )
|
||||
slot->advance.x += xstr;
|
||||
|
||||
if ( slot->advance.y )
|
||||
slot->advance.y += ystr;
|
||||
|
||||
slot->metrics.width += xstr;
|
||||
slot->metrics.height += ystr;
|
||||
slot->metrics.horiBearingY += ystr;
|
||||
slot->metrics.horiAdvance += xstr;
|
||||
slot->metrics.vertBearingX -= xstr / 2;
|
||||
slot->metrics.vertBearingY += ystr;
|
||||
slot->metrics.vertAdvance += ystr;
|
||||
|
||||
/* XXX: 16-bit overflow case must be excluded before here */
|
||||
if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
|
||||
slot->bitmap_top += (FT_Int)( ystr >> 6 );
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,320 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftsystem.c */
|
||||
/* */
|
||||
/* ANSI-specific FreeType low-level system interface (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2002, 2006, 2008-2011 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 default interface used by FreeType to access */
|
||||
/* low-level, i.e. memory management, i/o access as well as thread */
|
||||
/* synchronisation. It can be replaced by user-specific routines if */
|
||||
/* necessary. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CONFIG_CONFIG_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_SYSTEM_H
|
||||
#include FT_ERRORS_H
|
||||
#include FT_TYPES_H
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* MEMORY MANAGEMENT INTERFACE */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* It is not necessary to do any error checking for the */
|
||||
/* allocation-related functions. This will be done by the higher level */
|
||||
/* routines like ft_mem_alloc() or ft_mem_realloc(). */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* ft_alloc */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* The memory allocation function. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* memory :: A pointer to the memory object. */
|
||||
/* */
|
||||
/* size :: The requested size in bytes. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* The address of newly allocated block. */
|
||||
/* */
|
||||
FT_CALLBACK_DEF( void* )
|
||||
ft_alloc( FT_Memory memory,
|
||||
long size )
|
||||
{
|
||||
FT_UNUSED( memory );
|
||||
|
||||
return ft_smalloc( size );
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* ft_realloc */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* The memory reallocation function. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* memory :: A pointer to the memory object. */
|
||||
/* */
|
||||
/* cur_size :: The current size of the allocated memory block. */
|
||||
/* */
|
||||
/* new_size :: The newly requested size in bytes. */
|
||||
/* */
|
||||
/* block :: The current address of the block in memory. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* The address of the reallocated memory block. */
|
||||
/* */
|
||||
FT_CALLBACK_DEF( void* )
|
||||
ft_realloc( FT_Memory memory,
|
||||
long cur_size,
|
||||
long new_size,
|
||||
void* block )
|
||||
{
|
||||
FT_UNUSED( memory );
|
||||
FT_UNUSED( cur_size );
|
||||
|
||||
return ft_srealloc( block, new_size );
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* ft_free */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* The memory release function. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* memory :: A pointer to the memory object. */
|
||||
/* */
|
||||
/* block :: The address of block in memory to be freed. */
|
||||
/* */
|
||||
FT_CALLBACK_DEF( void )
|
||||
ft_free( FT_Memory memory,
|
||||
void* block )
|
||||
{
|
||||
FT_UNUSED( memory );
|
||||
|
||||
ft_sfree( block );
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* RESOURCE MANAGEMENT INTERFACE */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_io
|
||||
|
||||
/* We use the macro STREAM_FILE for convenience to extract the */
|
||||
/* system-specific stream handle from a given FreeType stream object */
|
||||
#define STREAM_FILE( stream ) ( (FT_FILE*)stream->descriptor.pointer )
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* ft_ansi_stream_close */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* The function to close a stream. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* stream :: A pointer to the stream object. */
|
||||
/* */
|
||||
FT_CALLBACK_DEF( void )
|
||||
ft_ansi_stream_close( FT_Stream stream )
|
||||
{
|
||||
ft_fclose( STREAM_FILE( stream ) );
|
||||
|
||||
stream->descriptor.pointer = NULL;
|
||||
stream->size = 0;
|
||||
stream->base = 0;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* ft_ansi_stream_io */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* The function to open a stream. */
|
||||
/* */
|
||||
/* <Input> */
|
||||
/* stream :: A pointer to the stream object. */
|
||||
/* */
|
||||
/* offset :: The position in the data stream to start reading. */
|
||||
/* */
|
||||
/* buffer :: The address of buffer to store the read data. */
|
||||
/* */
|
||||
/* count :: The number of bytes to read from the stream. */
|
||||
/* */
|
||||
/* <Return> */
|
||||
/* The number of bytes actually read. If `count' is zero (this is, */
|
||||
/* the function is used for seeking), a non-zero return value */
|
||||
/* indicates an error. */
|
||||
/* */
|
||||
FT_CALLBACK_DEF( unsigned long )
|
||||
ft_ansi_stream_io( FT_Stream stream,
|
||||
unsigned long offset,
|
||||
unsigned char* buffer,
|
||||
unsigned long count )
|
||||
{
|
||||
FT_FILE* file;
|
||||
|
||||
|
||||
if ( !count && offset > stream->size )
|
||||
return 1;
|
||||
|
||||
file = STREAM_FILE( stream );
|
||||
|
||||
if ( stream->pos != offset )
|
||||
ft_fseek( file, offset, SEEK_SET );
|
||||
|
||||
return (unsigned long)ft_fread( buffer, 1, count, file );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftstream.h */
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Stream_Open( FT_Stream stream,
|
||||
const char* filepathname )
|
||||
{
|
||||
FT_FILE* file;
|
||||
|
||||
|
||||
if ( !stream )
|
||||
return FT_Err_Invalid_Stream_Handle;
|
||||
|
||||
stream->descriptor.pointer = NULL;
|
||||
stream->pathname.pointer = (char*)filepathname;
|
||||
stream->base = 0;
|
||||
stream->pos = 0;
|
||||
stream->read = NULL;
|
||||
stream->close = NULL;
|
||||
|
||||
file = ft_fopen( filepathname, "rb" );
|
||||
if ( !file )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_Open:"
|
||||
" could not open `%s'\n", filepathname ));
|
||||
|
||||
return FT_Err_Cannot_Open_Resource;
|
||||
}
|
||||
|
||||
ft_fseek( file, 0, SEEK_END );
|
||||
stream->size = ft_ftell( file );
|
||||
if ( !stream->size )
|
||||
{
|
||||
FT_ERROR(( "FT_Stream_Open:" ));
|
||||
FT_ERROR(( " opened `%s' but zero-sized\n", filepathname ));
|
||||
ft_fclose( file );
|
||||
return FT_Err_Cannot_Open_Stream;
|
||||
}
|
||||
ft_fseek( file, 0, SEEK_SET );
|
||||
|
||||
stream->descriptor.pointer = file;
|
||||
stream->read = ft_ansi_stream_io;
|
||||
stream->close = ft_ansi_stream_close;
|
||||
|
||||
FT_TRACE1(( "FT_Stream_Open:" ));
|
||||
FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
|
||||
filepathname, stream->size ));
|
||||
|
||||
return FT_Err_Ok;
|
||||
}
|
||||
|
||||
#endif /* !FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT */
|
||||
|
||||
#ifdef FT_DEBUG_MEMORY
|
||||
|
||||
extern FT_Int
|
||||
ft_mem_debug_init( FT_Memory memory );
|
||||
|
||||
extern void
|
||||
ft_mem_debug_done( FT_Memory memory );
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* documentation is in ftobjs.h */
|
||||
|
||||
FT_BASE_DEF( FT_Memory )
|
||||
FT_New_Memory( void )
|
||||
{
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) );
|
||||
if ( memory )
|
||||
{
|
||||
memory->user = 0;
|
||||
memory->alloc = ft_alloc;
|
||||
memory->realloc = ft_realloc;
|
||||
memory->free = ft_free;
|
||||
#ifdef FT_DEBUG_MEMORY
|
||||
ft_mem_debug_init( memory );
|
||||
#endif
|
||||
}
|
||||
|
||||
return memory;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftobjs.h */
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Done_Memory( FT_Memory memory )
|
||||
{
|
||||
#ifdef FT_DEBUG_MEMORY
|
||||
ft_mem_debug_done( memory );
|
||||
#endif
|
||||
ft_sfree( memory );
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,546 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* fttrigon.c */
|
||||
/* */
|
||||
/* FreeType trigonometric functions (body). */
|
||||
/* */
|
||||
/* Copyright 2001, 2002, 2003, 2004, 2005 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_TRIGONOMETRY_H
|
||||
|
||||
|
||||
/* the following is 0.2715717684432231 * 2^30 */
|
||||
#define FT_TRIG_COSCALE 0x11616E8EUL
|
||||
|
||||
/* this table was generated for FT_PI = 180L << 16, i.e. degrees */
|
||||
#define FT_TRIG_MAX_ITERS 23
|
||||
|
||||
static const FT_Fixed
|
||||
ft_trig_arctan_table[24] =
|
||||
{
|
||||
4157273L, 2949120L, 1740967L, 919879L, 466945L, 234379L, 117304L,
|
||||
58666L, 29335L, 14668L, 7334L, 3667L, 1833L, 917L, 458L, 229L, 115L,
|
||||
57L, 29L, 14L, 7L, 4L, 2L, 1L
|
||||
};
|
||||
|
||||
/* the Cordic shrink factor, multiplied by 2^32 */
|
||||
#define FT_TRIG_SCALE 1166391785UL /* 0x4585BA38UL */
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_HAS_INT64
|
||||
|
||||
/* multiply a given value by the CORDIC shrink factor */
|
||||
static FT_Fixed
|
||||
ft_trig_downscale( FT_Fixed val )
|
||||
{
|
||||
FT_Fixed s;
|
||||
FT_Int64 v;
|
||||
|
||||
|
||||
s = val;
|
||||
val = ( val >= 0 ) ? val : -val;
|
||||
|
||||
v = ( val * (FT_Int64)FT_TRIG_SCALE ) + 0x100000000UL;
|
||||
val = (FT_Fixed)( v >> 32 );
|
||||
|
||||
return ( s >= 0 ) ? val : -val;
|
||||
}
|
||||
|
||||
#else /* !FT_CONFIG_HAS_INT64 */
|
||||
|
||||
/* multiply a given value by the CORDIC shrink factor */
|
||||
static FT_Fixed
|
||||
ft_trig_downscale( FT_Fixed val )
|
||||
{
|
||||
FT_Fixed s;
|
||||
FT_UInt32 v1, v2, k1, k2, hi, lo1, lo2, lo3;
|
||||
|
||||
|
||||
s = val;
|
||||
val = ( val >= 0 ) ? val : -val;
|
||||
|
||||
v1 = (FT_UInt32)val >> 16;
|
||||
v2 = (FT_UInt32)(val & 0xFFFFL);
|
||||
|
||||
k1 = (FT_UInt32)FT_TRIG_SCALE >> 16; /* constant */
|
||||
k2 = (FT_UInt32)(FT_TRIG_SCALE & 0xFFFFL); /* constant */
|
||||
|
||||
hi = k1 * v1;
|
||||
lo1 = k1 * v2 + k2 * v1; /* can't overflow */
|
||||
|
||||
lo2 = ( k2 * v2 ) >> 16;
|
||||
lo3 = ( lo1 >= lo2 ) ? lo1 : lo2;
|
||||
lo1 += lo2;
|
||||
|
||||
hi += lo1 >> 16;
|
||||
if ( lo1 < lo3 )
|
||||
hi += (FT_UInt32)0x10000UL;
|
||||
|
||||
val = (FT_Fixed)hi;
|
||||
|
||||
return ( s >= 0 ) ? val : -val;
|
||||
}
|
||||
|
||||
#endif /* !FT_CONFIG_HAS_INT64 */
|
||||
|
||||
|
||||
static FT_Int
|
||||
ft_trig_prenorm( FT_Vector* vec )
|
||||
{
|
||||
FT_Fixed x, y, z;
|
||||
FT_Int shift;
|
||||
|
||||
|
||||
x = vec->x;
|
||||
y = vec->y;
|
||||
|
||||
z = ( ( x >= 0 ) ? x : - x ) | ( (y >= 0) ? y : -y );
|
||||
shift = 0;
|
||||
|
||||
#if 1
|
||||
/* determine msb bit index in `shift' */
|
||||
if ( z >= ( 1L << 16 ) )
|
||||
{
|
||||
z >>= 16;
|
||||
shift += 16;
|
||||
}
|
||||
if ( z >= ( 1L << 8 ) )
|
||||
{
|
||||
z >>= 8;
|
||||
shift += 8;
|
||||
}
|
||||
if ( z >= ( 1L << 4 ) )
|
||||
{
|
||||
z >>= 4;
|
||||
shift += 4;
|
||||
}
|
||||
if ( z >= ( 1L << 2 ) )
|
||||
{
|
||||
z >>= 2;
|
||||
shift += 2;
|
||||
}
|
||||
if ( z >= ( 1L << 1 ) )
|
||||
{
|
||||
z >>= 1;
|
||||
shift += 1;
|
||||
}
|
||||
|
||||
if ( shift <= 27 )
|
||||
{
|
||||
shift = 27 - shift;
|
||||
vec->x = x << shift;
|
||||
vec->y = y << shift;
|
||||
}
|
||||
else
|
||||
{
|
||||
shift -= 27;
|
||||
vec->x = x >> shift;
|
||||
vec->y = y >> shift;
|
||||
shift = -shift;
|
||||
}
|
||||
|
||||
#else /* 0 */
|
||||
|
||||
if ( z < ( 1L << 27 ) )
|
||||
{
|
||||
do
|
||||
{
|
||||
shift++;
|
||||
z <<= 1;
|
||||
} while ( z < ( 1L << 27 ) );
|
||||
vec->x = x << shift;
|
||||
vec->y = y << shift;
|
||||
}
|
||||
else if ( z > ( 1L << 28 ) )
|
||||
{
|
||||
do
|
||||
{
|
||||
shift++;
|
||||
z >>= 1;
|
||||
} while ( z > ( 1L << 28 ) );
|
||||
|
||||
vec->x = x >> shift;
|
||||
vec->y = y >> shift;
|
||||
shift = -shift;
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
return shift;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_trig_pseudo_rotate( FT_Vector* vec,
|
||||
FT_Angle theta )
|
||||
{
|
||||
FT_Int i;
|
||||
FT_Fixed x, y, xtemp;
|
||||
const FT_Fixed *arctanptr;
|
||||
|
||||
|
||||
x = vec->x;
|
||||
y = vec->y;
|
||||
|
||||
/* Get angle between -90 and 90 degrees */
|
||||
while ( theta <= -FT_ANGLE_PI2 )
|
||||
{
|
||||
x = -x;
|
||||
y = -y;
|
||||
theta += FT_ANGLE_PI;
|
||||
}
|
||||
|
||||
while ( theta > FT_ANGLE_PI2 )
|
||||
{
|
||||
x = -x;
|
||||
y = -y;
|
||||
theta -= FT_ANGLE_PI;
|
||||
}
|
||||
|
||||
/* Initial pseudorotation, with left shift */
|
||||
arctanptr = ft_trig_arctan_table;
|
||||
|
||||
if ( theta < 0 )
|
||||
{
|
||||
xtemp = x + ( y << 1 );
|
||||
y = y - ( x << 1 );
|
||||
x = xtemp;
|
||||
theta += *arctanptr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
xtemp = x - ( y << 1 );
|
||||
y = y + ( x << 1 );
|
||||
x = xtemp;
|
||||
theta -= *arctanptr++;
|
||||
}
|
||||
|
||||
/* Subsequent pseudorotations, with right shifts */
|
||||
i = 0;
|
||||
do
|
||||
{
|
||||
if ( theta < 0 )
|
||||
{
|
||||
xtemp = x + ( y >> i );
|
||||
y = y - ( x >> i );
|
||||
x = xtemp;
|
||||
theta += *arctanptr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
xtemp = x - ( y >> i );
|
||||
y = y + ( x >> i );
|
||||
x = xtemp;
|
||||
theta -= *arctanptr++;
|
||||
}
|
||||
} while ( ++i < FT_TRIG_MAX_ITERS );
|
||||
|
||||
vec->x = x;
|
||||
vec->y = y;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_trig_pseudo_polarize( FT_Vector* vec )
|
||||
{
|
||||
FT_Fixed theta;
|
||||
FT_Fixed yi, i;
|
||||
FT_Fixed x, y;
|
||||
const FT_Fixed *arctanptr;
|
||||
|
||||
|
||||
x = vec->x;
|
||||
y = vec->y;
|
||||
|
||||
/* Get the vector into the right half plane */
|
||||
theta = 0;
|
||||
if ( x < 0 )
|
||||
{
|
||||
x = -x;
|
||||
y = -y;
|
||||
theta = 2 * FT_ANGLE_PI2;
|
||||
}
|
||||
|
||||
if ( y > 0 )
|
||||
theta = - theta;
|
||||
|
||||
arctanptr = ft_trig_arctan_table;
|
||||
|
||||
if ( y < 0 )
|
||||
{
|
||||
/* Rotate positive */
|
||||
yi = y + ( x << 1 );
|
||||
x = x - ( y << 1 );
|
||||
y = yi;
|
||||
theta -= *arctanptr++; /* Subtract angle */
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Rotate negative */
|
||||
yi = y - ( x << 1 );
|
||||
x = x + ( y << 1 );
|
||||
y = yi;
|
||||
theta += *arctanptr++; /* Add angle */
|
||||
}
|
||||
|
||||
i = 0;
|
||||
do
|
||||
{
|
||||
if ( y < 0 )
|
||||
{
|
||||
/* Rotate positive */
|
||||
yi = y + ( x >> i );
|
||||
x = x - ( y >> i );
|
||||
y = yi;
|
||||
theta -= *arctanptr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Rotate negative */
|
||||
yi = y - ( x >> i );
|
||||
x = x + ( y >> i );
|
||||
y = yi;
|
||||
theta += *arctanptr++;
|
||||
}
|
||||
} while ( ++i < FT_TRIG_MAX_ITERS );
|
||||
|
||||
/* round theta */
|
||||
if ( theta >= 0 )
|
||||
theta = FT_PAD_ROUND( theta, 32 );
|
||||
else
|
||||
theta = -FT_PAD_ROUND( -theta, 32 );
|
||||
|
||||
vec->x = x;
|
||||
vec->y = theta;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Fixed )
|
||||
FT_Cos( FT_Angle angle )
|
||||
{
|
||||
FT_Vector v;
|
||||
|
||||
|
||||
v.x = FT_TRIG_COSCALE >> 2;
|
||||
v.y = 0;
|
||||
ft_trig_pseudo_rotate( &v, angle );
|
||||
|
||||
return v.x / ( 1 << 12 );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Fixed )
|
||||
FT_Sin( FT_Angle angle )
|
||||
{
|
||||
return FT_Cos( FT_ANGLE_PI2 - angle );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Fixed )
|
||||
FT_Tan( FT_Angle angle )
|
||||
{
|
||||
FT_Vector v;
|
||||
|
||||
|
||||
v.x = FT_TRIG_COSCALE >> 2;
|
||||
v.y = 0;
|
||||
ft_trig_pseudo_rotate( &v, angle );
|
||||
|
||||
return FT_DivFix( v.y, v.x );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Angle )
|
||||
FT_Atan2( FT_Fixed dx,
|
||||
FT_Fixed dy )
|
||||
{
|
||||
FT_Vector v;
|
||||
|
||||
|
||||
if ( dx == 0 && dy == 0 )
|
||||
return 0;
|
||||
|
||||
v.x = dx;
|
||||
v.y = dy;
|
||||
ft_trig_prenorm( &v );
|
||||
ft_trig_pseudo_polarize( &v );
|
||||
|
||||
return v.y;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Vector_Unit( FT_Vector* vec,
|
||||
FT_Angle angle )
|
||||
{
|
||||
vec->x = FT_TRIG_COSCALE >> 2;
|
||||
vec->y = 0;
|
||||
ft_trig_pseudo_rotate( vec, angle );
|
||||
vec->x >>= 12;
|
||||
vec->y >>= 12;
|
||||
}
|
||||
|
||||
|
||||
/* these macros return 0 for positive numbers,
|
||||
and -1 for negative ones */
|
||||
#define FT_SIGN_LONG( x ) ( (x) >> ( FT_SIZEOF_LONG * 8 - 1 ) )
|
||||
#define FT_SIGN_INT( x ) ( (x) >> ( FT_SIZEOF_INT * 8 - 1 ) )
|
||||
#define FT_SIGN_INT32( x ) ( (x) >> 31 )
|
||||
#define FT_SIGN_INT16( x ) ( (x) >> 15 )
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Vector_Rotate( FT_Vector* vec,
|
||||
FT_Angle angle )
|
||||
{
|
||||
FT_Int shift;
|
||||
FT_Vector v;
|
||||
|
||||
|
||||
v.x = vec->x;
|
||||
v.y = vec->y;
|
||||
|
||||
if ( angle && ( v.x != 0 || v.y != 0 ) )
|
||||
{
|
||||
shift = ft_trig_prenorm( &v );
|
||||
ft_trig_pseudo_rotate( &v, angle );
|
||||
v.x = ft_trig_downscale( v.x );
|
||||
v.y = ft_trig_downscale( v.y );
|
||||
|
||||
if ( shift > 0 )
|
||||
{
|
||||
FT_Int32 half = (FT_Int32)1L << ( shift - 1 );
|
||||
|
||||
|
||||
vec->x = ( v.x + half + FT_SIGN_LONG( v.x ) ) >> shift;
|
||||
vec->y = ( v.y + half + FT_SIGN_LONG( v.y ) ) >> shift;
|
||||
}
|
||||
else
|
||||
{
|
||||
shift = -shift;
|
||||
vec->x = v.x << shift;
|
||||
vec->y = v.y << shift;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Fixed )
|
||||
FT_Vector_Length( FT_Vector* vec )
|
||||
{
|
||||
FT_Int shift;
|
||||
FT_Vector v;
|
||||
|
||||
|
||||
v = *vec;
|
||||
|
||||
/* handle trivial cases */
|
||||
if ( v.x == 0 )
|
||||
{
|
||||
return ( v.y >= 0 ) ? v.y : -v.y;
|
||||
}
|
||||
else if ( v.y == 0 )
|
||||
{
|
||||
return ( v.x >= 0 ) ? v.x : -v.x;
|
||||
}
|
||||
|
||||
/* general case */
|
||||
shift = ft_trig_prenorm( &v );
|
||||
ft_trig_pseudo_polarize( &v );
|
||||
|
||||
v.x = ft_trig_downscale( v.x );
|
||||
|
||||
if ( shift > 0 )
|
||||
return ( v.x + ( 1 << ( shift - 1 ) ) ) >> shift;
|
||||
|
||||
return v.x << -shift;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Vector_Polarize( FT_Vector* vec,
|
||||
FT_Fixed *length,
|
||||
FT_Angle *angle )
|
||||
{
|
||||
FT_Int shift;
|
||||
FT_Vector v;
|
||||
|
||||
|
||||
v = *vec;
|
||||
|
||||
if ( v.x == 0 && v.y == 0 )
|
||||
return;
|
||||
|
||||
shift = ft_trig_prenorm( &v );
|
||||
ft_trig_pseudo_polarize( &v );
|
||||
|
||||
v.x = ft_trig_downscale( v.x );
|
||||
|
||||
*length = ( shift >= 0 ) ? ( v.x >> shift ) : ( v.x << -shift );
|
||||
*angle = v.y;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_Vector_From_Polar( FT_Vector* vec,
|
||||
FT_Fixed length,
|
||||
FT_Angle angle )
|
||||
{
|
||||
vec->x = length;
|
||||
vec->y = 0;
|
||||
|
||||
FT_Vector_Rotate( vec, angle );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in fttrigon.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Angle )
|
||||
FT_Angle_Diff( FT_Angle angle1,
|
||||
FT_Angle angle2 )
|
||||
{
|
||||
FT_Angle delta = angle2 - angle1;
|
||||
|
||||
|
||||
delta %= FT_ANGLE_2PI;
|
||||
if ( delta < 0 )
|
||||
delta += FT_ANGLE_2PI;
|
||||
|
||||
if ( delta > FT_ANGLE_PI )
|
||||
delta -= FT_ANGLE_2PI;
|
||||
|
||||
return delta;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,94 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* fttype1.c */
|
||||
/* */
|
||||
/* FreeType utility file for PS names support (body). */
|
||||
/* */
|
||||
/* Copyright 2002, 2003, 2004 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_SERVICE_H
|
||||
#include FT_SERVICE_POSTSCRIPT_INFO_H
|
||||
|
||||
|
||||
/* documentation is in t1tables.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_PS_Font_Info( FT_Face face,
|
||||
PS_FontInfoRec* afont_info )
|
||||
{
|
||||
FT_Error error = FT_Err_Invalid_Argument;
|
||||
|
||||
|
||||
if ( face )
|
||||
{
|
||||
FT_Service_PsInfo service = NULL;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, POSTSCRIPT_INFO );
|
||||
|
||||
if ( service && service->ps_get_font_info )
|
||||
error = service->ps_get_font_info( face, afont_info );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in t1tables.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Int )
|
||||
FT_Has_PS_Glyph_Names( FT_Face face )
|
||||
{
|
||||
FT_Int result = 0;
|
||||
FT_Service_PsInfo service = NULL;
|
||||
|
||||
|
||||
if ( face )
|
||||
{
|
||||
FT_FACE_FIND_SERVICE( face, service, POSTSCRIPT_INFO );
|
||||
|
||||
if ( service && service->ps_has_glyph_names )
|
||||
result = service->ps_has_glyph_names( face );
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in t1tables.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_PS_Font_Private( FT_Face face,
|
||||
PS_PrivateRec* afont_private )
|
||||
{
|
||||
FT_Error error = FT_Err_Invalid_Argument;
|
||||
|
||||
|
||||
if ( face )
|
||||
{
|
||||
FT_Service_PsInfo service = NULL;
|
||||
|
||||
|
||||
FT_FACE_FIND_SERVICE( face, service, POSTSCRIPT_INFO );
|
||||
|
||||
if ( service && service->ps_get_font_private )
|
||||
error = service->ps_get_font_private( face, afont_private );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,501 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftutil.c */
|
||||
/* */
|
||||
/* FreeType utility file for memory and list management (body). */
|
||||
/* */
|
||||
/* Copyright 2002, 2004, 2005, 2006, 2007 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_MEMORY_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_LIST_H
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_memory
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** *****/
|
||||
/***** M E M O R Y M A N A G E M E N T *****/
|
||||
/***** *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Pointer )
|
||||
ft_mem_alloc( FT_Memory memory,
|
||||
FT_Long size,
|
||||
FT_Error *p_error )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Pointer block = ft_mem_qalloc( memory, size, &error );
|
||||
|
||||
if ( !error && size > 0 )
|
||||
FT_MEM_ZERO( block, size );
|
||||
|
||||
*p_error = error;
|
||||
return block;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Pointer )
|
||||
ft_mem_qalloc( FT_Memory memory,
|
||||
FT_Long size,
|
||||
FT_Error *p_error )
|
||||
{
|
||||
FT_Error error = FT_Err_Ok;
|
||||
FT_Pointer block = NULL;
|
||||
|
||||
|
||||
if ( size > 0 )
|
||||
{
|
||||
block = memory->alloc( memory, size );
|
||||
if ( block == NULL )
|
||||
error = FT_Err_Out_Of_Memory;
|
||||
}
|
||||
else if ( size < 0 )
|
||||
{
|
||||
/* may help catch/prevent security issues */
|
||||
error = FT_Err_Invalid_Argument;
|
||||
}
|
||||
|
||||
*p_error = error;
|
||||
return block;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Pointer )
|
||||
ft_mem_realloc( FT_Memory memory,
|
||||
FT_Long item_size,
|
||||
FT_Long cur_count,
|
||||
FT_Long new_count,
|
||||
void* block,
|
||||
FT_Error *p_error )
|
||||
{
|
||||
FT_Error error = FT_Err_Ok;
|
||||
|
||||
block = ft_mem_qrealloc( memory, item_size,
|
||||
cur_count, new_count, block, &error );
|
||||
if ( !error && new_count > cur_count )
|
||||
FT_MEM_ZERO( (char*)block + cur_count * item_size,
|
||||
( new_count - cur_count ) * item_size );
|
||||
|
||||
*p_error = error;
|
||||
return block;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Pointer )
|
||||
ft_mem_qrealloc( FT_Memory memory,
|
||||
FT_Long item_size,
|
||||
FT_Long cur_count,
|
||||
FT_Long new_count,
|
||||
void* block,
|
||||
FT_Error *p_error )
|
||||
{
|
||||
FT_Error error = FT_Err_Ok;
|
||||
|
||||
|
||||
/* Note that we now accept `item_size == 0' as a valid parameter, in
|
||||
* order to cover very weird cases where an ALLOC_MULT macro would be
|
||||
* called.
|
||||
*/
|
||||
if ( cur_count < 0 || new_count < 0 || item_size < 0 )
|
||||
{
|
||||
/* may help catch/prevent nasty security issues */
|
||||
error = FT_Err_Invalid_Argument;
|
||||
}
|
||||
else if ( new_count == 0 || item_size == 0 )
|
||||
{
|
||||
ft_mem_free( memory, block );
|
||||
block = NULL;
|
||||
}
|
||||
else if ( new_count > FT_INT_MAX/item_size )
|
||||
{
|
||||
error = FT_Err_Array_Too_Large;
|
||||
}
|
||||
else if ( cur_count == 0 )
|
||||
{
|
||||
FT_ASSERT( block == NULL );
|
||||
|
||||
block = ft_mem_alloc( memory, new_count*item_size, &error );
|
||||
}
|
||||
else
|
||||
{
|
||||
FT_Pointer block2;
|
||||
FT_Long cur_size = cur_count*item_size;
|
||||
FT_Long new_size = new_count*item_size;
|
||||
|
||||
|
||||
block2 = memory->realloc( memory, cur_size, new_size, block );
|
||||
if ( block2 == NULL )
|
||||
error = FT_Err_Out_Of_Memory;
|
||||
else
|
||||
block = block2;
|
||||
}
|
||||
|
||||
*p_error = error;
|
||||
return block;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
ft_mem_free( FT_Memory memory,
|
||||
const void *P )
|
||||
{
|
||||
if ( P )
|
||||
memory->free( memory, (void*)P );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Pointer )
|
||||
ft_mem_dup( FT_Memory memory,
|
||||
const void* address,
|
||||
FT_ULong size,
|
||||
FT_Error *p_error )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Pointer p = ft_mem_qalloc( memory, size, &error );
|
||||
|
||||
|
||||
if ( !error && address )
|
||||
ft_memcpy( p, address, size );
|
||||
|
||||
*p_error = error;
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Pointer )
|
||||
ft_mem_strdup( FT_Memory memory,
|
||||
const char* str,
|
||||
FT_Error *p_error )
|
||||
{
|
||||
FT_ULong len = str ? (FT_ULong)ft_strlen( str ) + 1
|
||||
: 0;
|
||||
|
||||
|
||||
return ft_mem_dup( memory, str, len, p_error );
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Int )
|
||||
ft_mem_strcpyn( char* dst,
|
||||
const char* src,
|
||||
FT_ULong size )
|
||||
{
|
||||
while ( size > 1 && *src != 0 )
|
||||
{
|
||||
*dst++ = *src++;
|
||||
size--;
|
||||
}
|
||||
|
||||
*dst = 0; /* always zero-terminate */
|
||||
|
||||
return *src != 0;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** *****/
|
||||
/***** D O U B L Y L I N K E D L I S T S *****/
|
||||
/***** *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_list
|
||||
|
||||
/* documentation is in ftlist.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_ListNode )
|
||||
FT_List_Find( FT_List list,
|
||||
void* data )
|
||||
{
|
||||
FT_ListNode cur;
|
||||
|
||||
|
||||
cur = list->head;
|
||||
while ( cur )
|
||||
{
|
||||
if ( cur->data == data )
|
||||
return cur;
|
||||
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
return (FT_ListNode)0;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftlist.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_List_Add( FT_List list,
|
||||
FT_ListNode node )
|
||||
{
|
||||
FT_ListNode before = list->tail;
|
||||
|
||||
|
||||
node->next = 0;
|
||||
node->prev = before;
|
||||
|
||||
if ( before )
|
||||
before->next = node;
|
||||
else
|
||||
list->head = node;
|
||||
|
||||
list->tail = node;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftlist.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_List_Insert( FT_List list,
|
||||
FT_ListNode node )
|
||||
{
|
||||
FT_ListNode after = list->head;
|
||||
|
||||
|
||||
node->next = after;
|
||||
node->prev = 0;
|
||||
|
||||
if ( !after )
|
||||
list->tail = node;
|
||||
else
|
||||
after->prev = node;
|
||||
|
||||
list->head = node;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftlist.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_List_Remove( FT_List list,
|
||||
FT_ListNode node )
|
||||
{
|
||||
FT_ListNode before, after;
|
||||
|
||||
|
||||
before = node->prev;
|
||||
after = node->next;
|
||||
|
||||
if ( before )
|
||||
before->next = after;
|
||||
else
|
||||
list->head = after;
|
||||
|
||||
if ( after )
|
||||
after->prev = before;
|
||||
else
|
||||
list->tail = before;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftlist.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_List_Up( FT_List list,
|
||||
FT_ListNode node )
|
||||
{
|
||||
FT_ListNode before, after;
|
||||
|
||||
|
||||
before = node->prev;
|
||||
after = node->next;
|
||||
|
||||
/* check whether we are already on top of the list */
|
||||
if ( !before )
|
||||
return;
|
||||
|
||||
before->next = after;
|
||||
|
||||
if ( after )
|
||||
after->prev = before;
|
||||
else
|
||||
list->tail = before;
|
||||
|
||||
node->prev = 0;
|
||||
node->next = list->head;
|
||||
list->head->prev = node;
|
||||
list->head = node;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftlist.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_List_Iterate( FT_List list,
|
||||
FT_List_Iterator iterator,
|
||||
void* user )
|
||||
{
|
||||
FT_ListNode cur = list->head;
|
||||
FT_Error error = FT_Err_Ok;
|
||||
|
||||
|
||||
while ( cur )
|
||||
{
|
||||
FT_ListNode next = cur->next;
|
||||
|
||||
|
||||
error = iterator( cur, user );
|
||||
if ( error )
|
||||
break;
|
||||
|
||||
cur = next;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftlist.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FT_List_Finalize( FT_List list,
|
||||
FT_List_Destructor destroy,
|
||||
FT_Memory memory,
|
||||
void* user )
|
||||
{
|
||||
FT_ListNode cur;
|
||||
|
||||
|
||||
cur = list->head;
|
||||
while ( cur )
|
||||
{
|
||||
FT_ListNode next = cur->next;
|
||||
void* data = cur->data;
|
||||
|
||||
|
||||
if ( destroy )
|
||||
destroy( memory, data, user );
|
||||
|
||||
FT_FREE( cur );
|
||||
cur = next;
|
||||
}
|
||||
|
||||
list->head = 0;
|
||||
list->tail = 0;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_UInt32 )
|
||||
ft_highpow2( FT_UInt32 value )
|
||||
{
|
||||
FT_UInt32 value2;
|
||||
|
||||
|
||||
/*
|
||||
* We simply clear the lowest bit in each iteration. When
|
||||
* we reach 0, we know that the previous value was our result.
|
||||
*/
|
||||
for ( ;; )
|
||||
{
|
||||
value2 = value & (value - 1); /* clear lowest bit */
|
||||
if ( value2 == 0 )
|
||||
break;
|
||||
|
||||
value = value2;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Alloc( FT_Memory memory,
|
||||
FT_Long size,
|
||||
void* *P )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
(void)FT_ALLOC( *P, size );
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_QAlloc( FT_Memory memory,
|
||||
FT_Long size,
|
||||
void* *p )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
(void)FT_QALLOC( *p, size );
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_Realloc( FT_Memory memory,
|
||||
FT_Long current,
|
||||
FT_Long size,
|
||||
void* *P )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
(void)FT_REALLOC( *P, current, size );
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( FT_Error )
|
||||
FT_QRealloc( FT_Memory memory,
|
||||
FT_Long current,
|
||||
FT_Long size,
|
||||
void* *p )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
(void)FT_QREALLOC( *p, current, size );
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_BASE_DEF( void )
|
||||
FT_Free( FT_Memory memory,
|
||||
void* *P )
|
||||
{
|
||||
if ( *P )
|
||||
FT_MEM_FREE( *P );
|
||||
}
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,51 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftwinfnt.c */
|
||||
/* */
|
||||
/* FreeType API for accessing Windows FNT specific info (body). */
|
||||
/* */
|
||||
/* Copyright 2003, 2004 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_WINFONTS_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_SERVICE_WINFNT_H
|
||||
|
||||
|
||||
/* documentation is in ftwinfnt.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Get_WinFNT_Header( FT_Face face,
|
||||
FT_WinFNT_HeaderRec *header )
|
||||
{
|
||||
FT_Service_WinFnt service;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
error = FT_Err_Invalid_Argument;
|
||||
|
||||
if ( face != NULL )
|
||||
{
|
||||
FT_FACE_LOOKUP_SERVICE( face, service, WINFNT );
|
||||
|
||||
if ( service != NULL )
|
||||
{
|
||||
error = service->get_header( face, header );
|
||||
}
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,40 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftxf86.c */
|
||||
/* */
|
||||
/* FreeType utility file for X11 support (body). */
|
||||
/* */
|
||||
/* Copyright 2002, 2003, 2004 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_XFREE86_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_SERVICE_XFREE86_NAME_H
|
||||
|
||||
|
||||
/* documentation is in ftxf86.h */
|
||||
|
||||
FT_EXPORT_DEF( const char* )
|
||||
FT_Get_X11_Font_Format( FT_Face face )
|
||||
{
|
||||
const char* result = NULL;
|
||||
|
||||
|
||||
if ( face )
|
||||
FT_FACE_FIND_SERVICE( face, result, XF86_NAME );
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,96 @@
|
||||
#
|
||||
# FreeType 2 base layer configuration rules
|
||||
#
|
||||
|
||||
|
||||
# Copyright 1996-2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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.
|
||||
|
||||
|
||||
# It sets the following variables which are used by the master Makefile
|
||||
# after the call:
|
||||
#
|
||||
# BASE_OBJ_S: The single-object base layer.
|
||||
# BASE_OBJ_M: A list of all objects for a multiple-objects build.
|
||||
# BASE_EXT_OBJ: A list of base layer extensions, i.e., components found
|
||||
# in `freetype/src/base' which are not compiled within the
|
||||
# base layer proper.
|
||||
|
||||
|
||||
BASE_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(SRC_DIR)/base)
|
||||
|
||||
|
||||
# Base layer sources
|
||||
#
|
||||
# ftsystem, ftinit, and ftdebug are handled by freetype.mk
|
||||
#
|
||||
# All files listed here should be included in `ftbase.c' (for a `single'
|
||||
# build).
|
||||
#
|
||||
BASE_SRC := $(BASE_DIR)/ftadvanc.c \
|
||||
$(BASE_DIR)/ftcalc.c \
|
||||
$(BASE_DIR)/ftdbgmem.c \
|
||||
$(BASE_DIR)/ftgloadr.c \
|
||||
$(BASE_DIR)/ftobjs.c \
|
||||
$(BASE_DIR)/ftoutln.c \
|
||||
$(BASE_DIR)/ftrfork.c \
|
||||
$(BASE_DIR)/ftsnames.c \
|
||||
$(BASE_DIR)/ftstream.c \
|
||||
$(BASE_DIR)/fttrigon.c \
|
||||
$(BASE_DIR)/ftutil.c
|
||||
|
||||
|
||||
ifneq ($(ftmac_c),)
|
||||
BASE_SRC += $(BASE_DIR)/$(ftmac_c)
|
||||
endif
|
||||
|
||||
BASE_H := $(BASE_DIR)/ftbase.h
|
||||
|
||||
# Base layer `extensions' sources
|
||||
#
|
||||
# An extension is added to the library file as a separate object. It is
|
||||
# then linked to the final executable only if one of its symbols is used by
|
||||
# the application.
|
||||
#
|
||||
BASE_EXT_SRC := $(patsubst %,$(BASE_DIR)/%,$(BASE_EXTENSIONS))
|
||||
|
||||
# Default extensions objects
|
||||
#
|
||||
BASE_EXT_OBJ := $(BASE_EXT_SRC:$(BASE_DIR)/%.c=$(OBJ_DIR)/%.$O)
|
||||
|
||||
|
||||
# Base layer object(s)
|
||||
#
|
||||
# BASE_OBJ_M is used during `multi' builds (each base source file compiles
|
||||
# to a single object file).
|
||||
#
|
||||
# BASE_OBJ_S is used during `single' builds (the whole base layer is
|
||||
# compiled as a single object file using ftbase.c).
|
||||
#
|
||||
BASE_OBJ_M := $(BASE_SRC:$(BASE_DIR)/%.c=$(OBJ_DIR)/%.$O)
|
||||
BASE_OBJ_S := $(OBJ_DIR)/ftbase.$O
|
||||
|
||||
# Base layer root source file for single build
|
||||
#
|
||||
BASE_SRC_S := $(BASE_DIR)/ftbase.c
|
||||
|
||||
|
||||
# Base layer - single object build
|
||||
#
|
||||
$(BASE_OBJ_S): $(BASE_SRC_S) $(BASE_SRC) $(FREETYPE_H) $(BASE_H)
|
||||
$(BASE_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(BASE_SRC_S))
|
||||
|
||||
|
||||
# Multiple objects build + extensions
|
||||
#
|
||||
$(OBJ_DIR)/%.$O: $(BASE_DIR)/%.c $(FREETYPE_H) $(BASE_H)
|
||||
$(BASE_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
|
||||
|
||||
|
||||
# EOF
|
||||
@@ -0,0 +1,29 @@
|
||||
# FreeType 2 src/bdf Jamfile
|
||||
#
|
||||
# Copyright 2002 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.
|
||||
|
||||
SubDir FT2_TOP $(FT2_SRC_DIR) bdf ;
|
||||
|
||||
{
|
||||
local _sources ;
|
||||
|
||||
if $(FT2_MULTI)
|
||||
{
|
||||
_sources = bdfdrivr bdflib ;
|
||||
}
|
||||
else
|
||||
{
|
||||
_sources = bdf ;
|
||||
}
|
||||
|
||||
Library $(FT2_LIB) : $(_sources).c ;
|
||||
}
|
||||
|
||||
# end of src/bdf Jamfile
|
||||
@@ -0,0 +1,148 @@
|
||||
FreeType font driver for BDF fonts
|
||||
|
||||
Francesco Zappa Nardelli
|
||||
<francesco.zappa.nardelli@ens.fr>
|
||||
|
||||
|
||||
Introduction
|
||||
************
|
||||
|
||||
BDF (Bitmap Distribution Format) is a bitmap font format defined by Adobe,
|
||||
which is intended to be easily understood by both humans and computers.
|
||||
This code implements a BDF driver for the FreeType library, following the
|
||||
Adobe Specification V 2.2. The specification of the BDF font format is
|
||||
available from Adobe's web site:
|
||||
|
||||
http://partners.adobe.com/public/developer/en/font/5005.BDF_Spec.pdf
|
||||
|
||||
Many good bitmap fonts in bdf format come with XFree86 (www.XFree86.org).
|
||||
They do not define vertical metrics, because the X Consortium BDF
|
||||
specification has removed them.
|
||||
|
||||
|
||||
Encodings
|
||||
*********
|
||||
|
||||
The variety of encodings that accompanies bdf fonts appears to encompass the
|
||||
small set defined in freetype.h. On the other hand, two properties that
|
||||
specify encoding and registry are usually defined in bdf fonts.
|
||||
|
||||
I decided to make these two properties directly accessible, leaving to the
|
||||
client application the work of interpreting them. For instance:
|
||||
|
||||
|
||||
#include FT_INTERNAL_BDF_TYPES_H
|
||||
|
||||
FT_Face face;
|
||||
BDF_Public_Face bdfface;
|
||||
|
||||
|
||||
FT_New_Face( library, ..., &face );
|
||||
|
||||
bdfface = (BDF_Public_Face)face;
|
||||
|
||||
if ( ( bdfface->charset_registry == "ISO10646" ) &&
|
||||
( bdfface->charset_encoding == "1" ) )
|
||||
[..]
|
||||
|
||||
|
||||
Thus the driver always exports `ft_encoding_none' as face->charmap.encoding.
|
||||
FT_Get_Char_Index's behavior is unmodified, that is, it converts the ULong
|
||||
value given as argument into the corresponding glyph number.
|
||||
|
||||
If the two properties are not available, Adobe Standard Encoding should be
|
||||
assumed.
|
||||
|
||||
|
||||
Anti-Aliased Bitmaps
|
||||
********************
|
||||
|
||||
The driver supports an extension to the BDF format as used in Mark Leisher's
|
||||
xmbdfed bitmap font editor. Microsoft's SBIT tool expects bitmap fonts in
|
||||
that format for adding anti-aliased them to TrueType fonts. It introduces a
|
||||
fourth field to the `SIZE' keyword which gives the bpp value (bits per
|
||||
pixel) of the glyph data in the font. Possible values are 1 (the default),
|
||||
2 (four gray levels), 4 (16 gray levels), and 8 (256 gray levels). The
|
||||
driver returns either a bitmap with 1 bit per pixel or a pixmap with 8bits
|
||||
per pixel (using 4, 16, and 256 gray levels, respectively).
|
||||
|
||||
|
||||
Known problems
|
||||
**************
|
||||
|
||||
- A font is entirely loaded into memory. Obviously, this is not the Right
|
||||
Thing(TM). If you have big fonts I suggest you convert them into PCF
|
||||
format (using the bdftopcf utility): the PCF font drive of FreeType can
|
||||
perform incremental glyph loading.
|
||||
|
||||
When I have some time, I will implement on-demand glyph parsing.
|
||||
|
||||
- Except for encodings properties, client applications have no visibility of
|
||||
the PCF_Face object. This means that applications cannot directly access
|
||||
font tables and must trust FreeType.
|
||||
|
||||
- Currently, glyph names are ignored.
|
||||
|
||||
I plan to give full visibility of the BDF_Face object in an upcoming
|
||||
revision of the driver, thus implementing also glyph names.
|
||||
|
||||
- As I have never seen a BDF font that defines vertical metrics, vertical
|
||||
metrics are (parsed and) discarded. If you own a BDF font that defines
|
||||
vertical metrics, please let me know (I will implement them in 5-10
|
||||
minutes).
|
||||
|
||||
|
||||
License
|
||||
*******
|
||||
|
||||
Copyright (C) 2001-2002 by Francesco Zappa Nardelli
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
*** Portions of the driver (that is, bdflib.c and bdf.h):
|
||||
|
||||
Copyright 2000 Computing Research Labs, New Mexico State University
|
||||
Copyright 2001-2002, 2011 Francesco Zappa Nardelli
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a
|
||||
copy of this software and associated documentation files (the "Software"),
|
||||
to deal in the Software without restriction, including without limitation
|
||||
the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
and/or sell copies of the Software, and to permit persons to whom the
|
||||
Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
|
||||
OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
|
||||
THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
Credits
|
||||
*******
|
||||
|
||||
This driver is based on excellent Mark Leisher's bdf library. If you
|
||||
find something good in this driver you should probably thank him, not
|
||||
me.
|
||||
@@ -0,0 +1,34 @@
|
||||
/* bdf.c
|
||||
|
||||
FreeType font driver for bdf files
|
||||
|
||||
Copyright (C) 2001, 2002 by
|
||||
Francesco Zappa Nardelli
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#define FT_MAKE_OPTION_SINGLE_OBJECT
|
||||
|
||||
#include <ft2build.h>
|
||||
#include "bdflib.c"
|
||||
#include "bdfdrivr.c"
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,295 @@
|
||||
/*
|
||||
* Copyright 2000 Computing Research Labs, New Mexico State University
|
||||
* Copyright 2001, 2002, 2003, 2004 Francesco Zappa Nardelli
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
|
||||
* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
|
||||
* THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __BDF_H__
|
||||
#define __BDF_H__
|
||||
|
||||
|
||||
/*
|
||||
* Based on bdf.h,v 1.16 2000/03/16 20:08:51 mleisher
|
||||
*/
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/* Imported from bdfP.h */
|
||||
|
||||
#define _bdf_glyph_modified( map, e ) \
|
||||
( (map)[(e) >> 5] & ( 1 << ( (e) & 31 ) ) )
|
||||
#define _bdf_set_glyph_modified( map, e ) \
|
||||
( (map)[(e) >> 5] |= ( 1 << ( (e) & 31 ) ) )
|
||||
#define _bdf_clear_glyph_modified( map, e ) \
|
||||
( (map)[(e) >> 5] &= ~( 1 << ( (e) & 31 ) ) )
|
||||
|
||||
/* end of bdfP.h */
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* BDF font options macros and types. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#define BDF_CORRECT_METRICS 0x01 /* Correct invalid metrics when loading. */
|
||||
#define BDF_KEEP_COMMENTS 0x02 /* Preserve the font comments. */
|
||||
#define BDF_KEEP_UNENCODED 0x04 /* Keep the unencoded glyphs. */
|
||||
#define BDF_PROPORTIONAL 0x08 /* Font has proportional spacing. */
|
||||
#define BDF_MONOWIDTH 0x10 /* Font has mono width. */
|
||||
#define BDF_CHARCELL 0x20 /* Font has charcell spacing. */
|
||||
|
||||
#define BDF_ALL_SPACING ( BDF_PROPORTIONAL | \
|
||||
BDF_MONOWIDTH | \
|
||||
BDF_CHARCELL )
|
||||
|
||||
#define BDF_DEFAULT_LOAD_OPTIONS ( BDF_CORRECT_METRICS | \
|
||||
BDF_KEEP_COMMENTS | \
|
||||
BDF_KEEP_UNENCODED | \
|
||||
BDF_PROPORTIONAL )
|
||||
|
||||
|
||||
typedef struct bdf_options_t_
|
||||
{
|
||||
int correct_metrics;
|
||||
int keep_unencoded;
|
||||
int keep_comments;
|
||||
int font_spacing;
|
||||
|
||||
} bdf_options_t;
|
||||
|
||||
|
||||
/* Callback function type for unknown configuration options. */
|
||||
typedef int
|
||||
(*bdf_options_callback_t)( bdf_options_t* opts,
|
||||
char** params,
|
||||
unsigned long nparams,
|
||||
void* client_data );
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* BDF font property macros and types. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#define BDF_ATOM 1
|
||||
#define BDF_INTEGER 2
|
||||
#define BDF_CARDINAL 3
|
||||
|
||||
|
||||
/* This structure represents a particular property of a font. */
|
||||
/* There are a set of defaults and each font has their own. */
|
||||
typedef struct bdf_property_t_
|
||||
{
|
||||
char* name; /* Name of the property. */
|
||||
int format; /* Format of the property. */
|
||||
int builtin; /* A builtin property. */
|
||||
union
|
||||
{
|
||||
char* atom;
|
||||
long l;
|
||||
unsigned long ul;
|
||||
|
||||
} value; /* Value of the property. */
|
||||
|
||||
} bdf_property_t;
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* BDF font metric and glyph types. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
typedef struct bdf_bbx_t_
|
||||
{
|
||||
unsigned short width;
|
||||
unsigned short height;
|
||||
|
||||
short x_offset;
|
||||
short y_offset;
|
||||
|
||||
short ascent;
|
||||
short descent;
|
||||
|
||||
} bdf_bbx_t;
|
||||
|
||||
|
||||
typedef struct bdf_glyph_t_
|
||||
{
|
||||
char* name; /* Glyph name. */
|
||||
long encoding; /* Glyph encoding. */
|
||||
unsigned short swidth; /* Scalable width. */
|
||||
unsigned short dwidth; /* Device width. */
|
||||
bdf_bbx_t bbx; /* Glyph bounding box. */
|
||||
unsigned char* bitmap; /* Glyph bitmap. */
|
||||
unsigned long bpr; /* Number of bytes used per row. */
|
||||
unsigned short bytes; /* Number of bytes used for the bitmap. */
|
||||
|
||||
} bdf_glyph_t;
|
||||
|
||||
|
||||
typedef struct _hashnode_
|
||||
{
|
||||
const char* key;
|
||||
size_t data;
|
||||
|
||||
} _hashnode, *hashnode;
|
||||
|
||||
|
||||
typedef struct hashtable_
|
||||
{
|
||||
int limit;
|
||||
int size;
|
||||
int used;
|
||||
hashnode* table;
|
||||
|
||||
} hashtable;
|
||||
|
||||
|
||||
typedef struct bdf_glyphlist_t_
|
||||
{
|
||||
unsigned short pad; /* Pad to 4-byte boundary. */
|
||||
unsigned short bpp; /* Bits per pixel. */
|
||||
long start; /* Beginning encoding value of glyphs. */
|
||||
long end; /* Ending encoding value of glyphs. */
|
||||
bdf_glyph_t* glyphs; /* Glyphs themselves. */
|
||||
unsigned long glyphs_size; /* Glyph structures allocated. */
|
||||
unsigned long glyphs_used; /* Glyph structures used. */
|
||||
bdf_bbx_t bbx; /* Overall bounding box of glyphs. */
|
||||
|
||||
} bdf_glyphlist_t;
|
||||
|
||||
|
||||
typedef struct bdf_font_t_
|
||||
{
|
||||
char* name; /* Name of the font. */
|
||||
bdf_bbx_t bbx; /* Font bounding box. */
|
||||
|
||||
long point_size; /* Point size of the font. */
|
||||
unsigned long resolution_x; /* Font horizontal resolution. */
|
||||
unsigned long resolution_y; /* Font vertical resolution. */
|
||||
|
||||
int spacing; /* Font spacing value. */
|
||||
|
||||
unsigned short monowidth; /* Logical width for monowidth font. */
|
||||
|
||||
long default_char; /* Encoding of the default glyph. */
|
||||
|
||||
long font_ascent; /* Font ascent. */
|
||||
long font_descent; /* Font descent. */
|
||||
|
||||
unsigned long glyphs_size; /* Glyph structures allocated. */
|
||||
unsigned long glyphs_used; /* Glyph structures used. */
|
||||
bdf_glyph_t* glyphs; /* Glyphs themselves. */
|
||||
|
||||
unsigned long unencoded_size; /* Unencoded glyph struct. allocated. */
|
||||
unsigned long unencoded_used; /* Unencoded glyph struct. used. */
|
||||
bdf_glyph_t* unencoded; /* Unencoded glyphs themselves. */
|
||||
|
||||
unsigned long props_size; /* Font properties allocated. */
|
||||
unsigned long props_used; /* Font properties used. */
|
||||
bdf_property_t* props; /* Font properties themselves. */
|
||||
|
||||
char* comments; /* Font comments. */
|
||||
unsigned long comments_len; /* Length of comment string. */
|
||||
|
||||
bdf_glyphlist_t overflow; /* Storage used for glyph insertion. */
|
||||
|
||||
void* internal; /* Internal data for the font. */
|
||||
|
||||
unsigned long nmod[2048]; /* Bitmap indicating modified glyphs. */
|
||||
unsigned long umod[2048]; /* Bitmap indicating modified */
|
||||
/* unencoded glyphs. */
|
||||
unsigned short modified; /* Boolean indicating font modified. */
|
||||
unsigned short bpp; /* Bits per pixel. */
|
||||
|
||||
FT_Memory memory;
|
||||
|
||||
bdf_property_t* user_props;
|
||||
unsigned long nuser_props;
|
||||
hashtable proptbl;
|
||||
|
||||
} bdf_font_t;
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Types for load/save callbacks. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/* Error codes. */
|
||||
#define BDF_MISSING_START -1
|
||||
#define BDF_MISSING_FONTNAME -2
|
||||
#define BDF_MISSING_SIZE -3
|
||||
#define BDF_MISSING_CHARS -4
|
||||
#define BDF_MISSING_STARTCHAR -5
|
||||
#define BDF_MISSING_ENCODING -6
|
||||
#define BDF_MISSING_BBX -7
|
||||
|
||||
#define BDF_OUT_OF_MEMORY -20
|
||||
|
||||
#define BDF_INVALID_LINE -100
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* BDF font API. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
bdf_load_font( FT_Stream stream,
|
||||
FT_Memory memory,
|
||||
bdf_options_t* opts,
|
||||
bdf_font_t* *font );
|
||||
|
||||
FT_LOCAL( void )
|
||||
bdf_free_font( bdf_font_t* font );
|
||||
|
||||
FT_LOCAL( bdf_property_t * )
|
||||
bdf_get_property( char* name,
|
||||
bdf_font_t* font );
|
||||
|
||||
FT_LOCAL( bdf_property_t * )
|
||||
bdf_get_font_property( bdf_font_t* font,
|
||||
const char* name );
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
|
||||
#endif /* __BDF_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,881 @@
|
||||
/* bdfdrivr.c
|
||||
|
||||
FreeType font driver for bdf files
|
||||
|
||||
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by
|
||||
Francesco Zappa Nardelli
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <ft2build.h>
|
||||
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_BDF_H
|
||||
#include FT_TRUETYPE_IDS_H
|
||||
|
||||
#include FT_SERVICE_BDF_H
|
||||
#include FT_SERVICE_XFREE86_NAME_H
|
||||
|
||||
#include "bdf.h"
|
||||
#include "bdfdrivr.h"
|
||||
|
||||
#include "bdferror.h"
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
|
||||
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
|
||||
/* messages during execution. */
|
||||
/* */
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_bdfdriver
|
||||
|
||||
|
||||
typedef struct BDF_CMapRec_
|
||||
{
|
||||
FT_CMapRec cmap;
|
||||
FT_ULong num_encodings; /* ftobjs.h: FT_CMap->clazz->size */
|
||||
BDF_encoding_el* encodings;
|
||||
|
||||
} BDF_CMapRec, *BDF_CMap;
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
bdf_cmap_init( FT_CMap bdfcmap,
|
||||
FT_Pointer init_data )
|
||||
{
|
||||
BDF_CMap cmap = (BDF_CMap)bdfcmap;
|
||||
BDF_Face face = (BDF_Face)FT_CMAP_FACE( cmap );
|
||||
FT_UNUSED( init_data );
|
||||
|
||||
|
||||
cmap->num_encodings = face->bdffont->glyphs_used;
|
||||
cmap->encodings = face->en_table;
|
||||
|
||||
return BDF_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
bdf_cmap_done( FT_CMap bdfcmap )
|
||||
{
|
||||
BDF_CMap cmap = (BDF_CMap)bdfcmap;
|
||||
|
||||
|
||||
cmap->encodings = NULL;
|
||||
cmap->num_encodings = 0;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_UInt )
|
||||
bdf_cmap_char_index( FT_CMap bdfcmap,
|
||||
FT_UInt32 charcode )
|
||||
{
|
||||
BDF_CMap cmap = (BDF_CMap)bdfcmap;
|
||||
BDF_encoding_el* encodings = cmap->encodings;
|
||||
FT_ULong min, max, mid; /* num_encodings */
|
||||
FT_UShort result = 0; /* encodings->glyph */
|
||||
|
||||
|
||||
min = 0;
|
||||
max = cmap->num_encodings;
|
||||
|
||||
while ( min < max )
|
||||
{
|
||||
FT_ULong code;
|
||||
|
||||
|
||||
mid = ( min + max ) >> 1;
|
||||
code = encodings[mid].enc;
|
||||
|
||||
if ( charcode == code )
|
||||
{
|
||||
/* increase glyph index by 1 -- */
|
||||
/* we reserve slot 0 for the undefined glyph */
|
||||
result = encodings[mid].glyph + 1;
|
||||
break;
|
||||
}
|
||||
|
||||
if ( charcode < code )
|
||||
max = mid;
|
||||
else
|
||||
min = mid + 1;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_UInt )
|
||||
bdf_cmap_char_next( FT_CMap bdfcmap,
|
||||
FT_UInt32 *acharcode )
|
||||
{
|
||||
BDF_CMap cmap = (BDF_CMap)bdfcmap;
|
||||
BDF_encoding_el* encodings = cmap->encodings;
|
||||
FT_ULong min, max, mid; /* num_encodings */
|
||||
FT_UShort result = 0; /* encodings->glyph */
|
||||
FT_ULong charcode = *acharcode + 1;
|
||||
|
||||
|
||||
min = 0;
|
||||
max = cmap->num_encodings;
|
||||
|
||||
while ( min < max )
|
||||
{
|
||||
FT_ULong code; /* same as BDF_encoding_el.enc */
|
||||
|
||||
|
||||
mid = ( min + max ) >> 1;
|
||||
code = encodings[mid].enc;
|
||||
|
||||
if ( charcode == code )
|
||||
{
|
||||
/* increase glyph index by 1 -- */
|
||||
/* we reserve slot 0 for the undefined glyph */
|
||||
result = encodings[mid].glyph + 1;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( charcode < code )
|
||||
max = mid;
|
||||
else
|
||||
min = mid + 1;
|
||||
}
|
||||
|
||||
charcode = 0;
|
||||
if ( min < cmap->num_encodings )
|
||||
{
|
||||
charcode = encodings[min].enc;
|
||||
result = encodings[min].glyph + 1;
|
||||
}
|
||||
|
||||
Exit:
|
||||
if ( charcode > 0xFFFFFFFFUL )
|
||||
{
|
||||
FT_TRACE1(( "bdf_cmap_char_next: charcode 0x%x > 32bit API" ));
|
||||
*acharcode = 0;
|
||||
/* XXX: result should be changed to indicate an overflow error */
|
||||
}
|
||||
else
|
||||
*acharcode = (FT_UInt32)charcode;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FT_CMap_ClassRec bdf_cmap_class =
|
||||
{
|
||||
sizeof ( BDF_CMapRec ),
|
||||
bdf_cmap_init,
|
||||
bdf_cmap_done,
|
||||
bdf_cmap_char_index,
|
||||
bdf_cmap_char_next,
|
||||
|
||||
NULL, NULL, NULL, NULL, NULL
|
||||
};
|
||||
|
||||
|
||||
static FT_Error
|
||||
bdf_interpret_style( BDF_Face bdf )
|
||||
{
|
||||
FT_Error error = BDF_Err_Ok;
|
||||
FT_Face face = FT_FACE( bdf );
|
||||
FT_Memory memory = face->memory;
|
||||
bdf_font_t* font = bdf->bdffont;
|
||||
bdf_property_t* prop;
|
||||
|
||||
char* strings[4] = { NULL, NULL, NULL, NULL };
|
||||
size_t nn, len, lengths[4];
|
||||
|
||||
|
||||
face->style_flags = 0;
|
||||
|
||||
prop = bdf_get_font_property( font, (char *)"SLANT" );
|
||||
if ( prop && prop->format == BDF_ATOM &&
|
||||
prop->value.atom &&
|
||||
( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' ||
|
||||
*(prop->value.atom) == 'I' || *(prop->value.atom) == 'i' ) )
|
||||
{
|
||||
face->style_flags |= FT_STYLE_FLAG_ITALIC;
|
||||
strings[2] = ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' )
|
||||
? (char *)"Oblique"
|
||||
: (char *)"Italic";
|
||||
}
|
||||
|
||||
prop = bdf_get_font_property( font, (char *)"WEIGHT_NAME" );
|
||||
if ( prop && prop->format == BDF_ATOM &&
|
||||
prop->value.atom &&
|
||||
( *(prop->value.atom) == 'B' || *(prop->value.atom) == 'b' ) )
|
||||
{
|
||||
face->style_flags |= FT_STYLE_FLAG_BOLD;
|
||||
strings[1] = (char *)"Bold";
|
||||
}
|
||||
|
||||
prop = bdf_get_font_property( font, (char *)"SETWIDTH_NAME" );
|
||||
if ( prop && prop->format == BDF_ATOM &&
|
||||
prop->value.atom && *(prop->value.atom) &&
|
||||
!( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
|
||||
strings[3] = (char *)(prop->value.atom);
|
||||
|
||||
prop = bdf_get_font_property( font, (char *)"ADD_STYLE_NAME" );
|
||||
if ( prop && prop->format == BDF_ATOM &&
|
||||
prop->value.atom && *(prop->value.atom) &&
|
||||
!( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
|
||||
strings[0] = (char *)(prop->value.atom);
|
||||
|
||||
len = 0;
|
||||
|
||||
for ( len = 0, nn = 0; nn < 4; nn++ )
|
||||
{
|
||||
lengths[nn] = 0;
|
||||
if ( strings[nn] )
|
||||
{
|
||||
lengths[nn] = ft_strlen( strings[nn] );
|
||||
len += lengths[nn] + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if ( len == 0 )
|
||||
{
|
||||
strings[0] = (char *)"Regular";
|
||||
lengths[0] = ft_strlen( strings[0] );
|
||||
len = lengths[0] + 1;
|
||||
}
|
||||
|
||||
{
|
||||
char* s;
|
||||
|
||||
|
||||
if ( FT_ALLOC( face->style_name, len ) )
|
||||
return error;
|
||||
|
||||
s = face->style_name;
|
||||
|
||||
for ( nn = 0; nn < 4; nn++ )
|
||||
{
|
||||
char* src = strings[nn];
|
||||
|
||||
|
||||
len = lengths[nn];
|
||||
|
||||
if ( src == NULL )
|
||||
continue;
|
||||
|
||||
/* separate elements with a space */
|
||||
if ( s != face->style_name )
|
||||
*s++ = ' ';
|
||||
|
||||
ft_memcpy( s, src, len );
|
||||
|
||||
/* need to convert spaces to dashes for */
|
||||
/* add_style_name and setwidth_name */
|
||||
if ( nn == 0 || nn == 3 )
|
||||
{
|
||||
size_t mm;
|
||||
|
||||
|
||||
for ( mm = 0; mm < len; mm++ )
|
||||
if ( s[mm] == ' ' )
|
||||
s[mm] = '-';
|
||||
}
|
||||
|
||||
s += len;
|
||||
}
|
||||
*s = 0;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
BDF_Face_Done( FT_Face bdfface ) /* BDF_Face */
|
||||
{
|
||||
BDF_Face face = (BDF_Face)bdfface;
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
if ( !face )
|
||||
return;
|
||||
|
||||
memory = FT_FACE_MEMORY( face );
|
||||
|
||||
bdf_free_font( face->bdffont );
|
||||
|
||||
FT_FREE( face->en_table );
|
||||
|
||||
FT_FREE( face->charset_encoding );
|
||||
FT_FREE( face->charset_registry );
|
||||
FT_FREE( bdfface->family_name );
|
||||
FT_FREE( bdfface->style_name );
|
||||
|
||||
FT_FREE( bdfface->available_sizes );
|
||||
|
||||
FT_FREE( face->bdffont );
|
||||
|
||||
FT_TRACE4(( "BDF_Face_Done: done face\n" ));
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
BDF_Face_Init( FT_Stream stream,
|
||||
FT_Face bdfface, /* BDF_Face */
|
||||
FT_Int face_index,
|
||||
FT_Int num_params,
|
||||
FT_Parameter* params )
|
||||
{
|
||||
FT_Error error = BDF_Err_Ok;
|
||||
BDF_Face face = (BDF_Face)bdfface;
|
||||
FT_Memory memory = FT_FACE_MEMORY( face );
|
||||
|
||||
bdf_font_t* font = NULL;
|
||||
bdf_options_t options;
|
||||
|
||||
FT_UNUSED( num_params );
|
||||
FT_UNUSED( params );
|
||||
FT_UNUSED( face_index );
|
||||
|
||||
|
||||
if ( FT_STREAM_SEEK( 0 ) )
|
||||
goto Exit;
|
||||
|
||||
options.correct_metrics = 1; /* FZ XXX: options semantics */
|
||||
options.keep_unencoded = 1;
|
||||
options.keep_comments = 0;
|
||||
options.font_spacing = BDF_PROPORTIONAL;
|
||||
|
||||
error = bdf_load_font( stream, memory, &options, &font );
|
||||
if ( error == BDF_Err_Missing_Startfont_Field )
|
||||
{
|
||||
FT_TRACE2(( "[not a valid BDF file]\n" ));
|
||||
goto Fail;
|
||||
}
|
||||
else if ( error )
|
||||
goto Exit;
|
||||
|
||||
/* we have a bdf font: let's construct the face object */
|
||||
face->bdffont = font;
|
||||
{
|
||||
bdf_property_t* prop = NULL;
|
||||
|
||||
|
||||
FT_TRACE4(( "number of glyphs: %d (%d)\n",
|
||||
font->glyphs_size,
|
||||
font->glyphs_used ));
|
||||
FT_TRACE4(( "number of unencoded glyphs: %d (%d)\n",
|
||||
font->unencoded_size,
|
||||
font->unencoded_used ));
|
||||
|
||||
bdfface->num_faces = 1;
|
||||
bdfface->face_index = 0;
|
||||
bdfface->face_flags = FT_FACE_FLAG_FIXED_SIZES |
|
||||
FT_FACE_FLAG_HORIZONTAL |
|
||||
FT_FACE_FLAG_FAST_GLYPHS;
|
||||
|
||||
prop = bdf_get_font_property( font, "SPACING" );
|
||||
if ( prop && prop->format == BDF_ATOM &&
|
||||
prop->value.atom &&
|
||||
( *(prop->value.atom) == 'M' || *(prop->value.atom) == 'm' ||
|
||||
*(prop->value.atom) == 'C' || *(prop->value.atom) == 'c' ) )
|
||||
bdfface->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
|
||||
|
||||
/* FZ XXX: TO DO: FT_FACE_FLAGS_VERTICAL */
|
||||
/* FZ XXX: I need a font to implement this */
|
||||
|
||||
prop = bdf_get_font_property( font, "FAMILY_NAME" );
|
||||
if ( prop && prop->value.atom )
|
||||
{
|
||||
if ( FT_STRDUP( bdfface->family_name, prop->value.atom ) )
|
||||
goto Exit;
|
||||
}
|
||||
else
|
||||
bdfface->family_name = 0;
|
||||
|
||||
if ( ( error = bdf_interpret_style( face ) ) != 0 )
|
||||
goto Exit;
|
||||
|
||||
/* the number of glyphs (with one slot for the undefined glyph */
|
||||
/* at position 0 and all unencoded glyphs) */
|
||||
bdfface->num_glyphs = font->glyphs_size + 1;
|
||||
|
||||
bdfface->num_fixed_sizes = 1;
|
||||
if ( FT_NEW_ARRAY( bdfface->available_sizes, 1 ) )
|
||||
goto Exit;
|
||||
|
||||
{
|
||||
FT_Bitmap_Size* bsize = bdfface->available_sizes;
|
||||
FT_Short resolution_x = 0, resolution_y = 0;
|
||||
|
||||
|
||||
FT_MEM_ZERO( bsize, sizeof ( FT_Bitmap_Size ) );
|
||||
|
||||
bsize->height = (FT_Short)( font->font_ascent + font->font_descent );
|
||||
|
||||
prop = bdf_get_font_property( font, "AVERAGE_WIDTH" );
|
||||
if ( prop )
|
||||
bsize->width = (FT_Short)( ( prop->value.l + 5 ) / 10 );
|
||||
else
|
||||
bsize->width = (FT_Short)( bsize->height * 2/3 );
|
||||
|
||||
prop = bdf_get_font_property( font, "POINT_SIZE" );
|
||||
if ( prop )
|
||||
/* convert from 722.7 decipoints to 72 points per inch */
|
||||
bsize->size =
|
||||
(FT_Pos)( ( prop->value.l * 64 * 7200 + 36135L ) / 72270L );
|
||||
else
|
||||
bsize->size = bsize->width << 6;
|
||||
|
||||
prop = bdf_get_font_property( font, "PIXEL_SIZE" );
|
||||
if ( prop )
|
||||
bsize->y_ppem = (FT_Short)prop->value.l << 6;
|
||||
|
||||
prop = bdf_get_font_property( font, "RESOLUTION_X" );
|
||||
if ( prop )
|
||||
resolution_x = (FT_Short)prop->value.l;
|
||||
|
||||
prop = bdf_get_font_property( font, "RESOLUTION_Y" );
|
||||
if ( prop )
|
||||
resolution_y = (FT_Short)prop->value.l;
|
||||
|
||||
if ( bsize->y_ppem == 0 )
|
||||
{
|
||||
bsize->y_ppem = bsize->size;
|
||||
if ( resolution_y )
|
||||
bsize->y_ppem = bsize->y_ppem * resolution_y / 72;
|
||||
}
|
||||
if ( resolution_x && resolution_y )
|
||||
bsize->x_ppem = bsize->y_ppem * resolution_x / resolution_y;
|
||||
else
|
||||
bsize->x_ppem = bsize->y_ppem;
|
||||
}
|
||||
|
||||
/* encoding table */
|
||||
{
|
||||
bdf_glyph_t* cur = font->glyphs;
|
||||
unsigned long n;
|
||||
|
||||
|
||||
if ( FT_NEW_ARRAY( face->en_table, font->glyphs_size ) )
|
||||
goto Exit;
|
||||
|
||||
face->default_glyph = 0;
|
||||
for ( n = 0; n < font->glyphs_size; n++ )
|
||||
{
|
||||
(face->en_table[n]).enc = cur[n].encoding;
|
||||
FT_TRACE4(( "idx %d, val 0x%lX\n", n, cur[n].encoding ));
|
||||
(face->en_table[n]).glyph = (FT_Short)n;
|
||||
|
||||
if ( cur[n].encoding == font->default_char )
|
||||
{
|
||||
if ( n < FT_UINT_MAX )
|
||||
face->default_glyph = (FT_UInt)n;
|
||||
else
|
||||
FT_TRACE1(( "idx %d is too large for this system\n", n ));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* charmaps */
|
||||
{
|
||||
bdf_property_t *charset_registry = 0, *charset_encoding = 0;
|
||||
FT_Bool unicode_charmap = 0;
|
||||
|
||||
|
||||
charset_registry =
|
||||
bdf_get_font_property( font, "CHARSET_REGISTRY" );
|
||||
charset_encoding =
|
||||
bdf_get_font_property( font, "CHARSET_ENCODING" );
|
||||
if ( charset_registry && charset_encoding )
|
||||
{
|
||||
if ( charset_registry->format == BDF_ATOM &&
|
||||
charset_encoding->format == BDF_ATOM &&
|
||||
charset_registry->value.atom &&
|
||||
charset_encoding->value.atom )
|
||||
{
|
||||
const char* s;
|
||||
|
||||
|
||||
if ( FT_STRDUP( face->charset_encoding,
|
||||
charset_encoding->value.atom ) ||
|
||||
FT_STRDUP( face->charset_registry,
|
||||
charset_registry->value.atom ) )
|
||||
goto Exit;
|
||||
|
||||
/* Uh, oh, compare first letters manually to avoid dependency */
|
||||
/* on locales. */
|
||||
s = face->charset_registry;
|
||||
if ( ( s[0] == 'i' || s[0] == 'I' ) &&
|
||||
( s[1] == 's' || s[1] == 'S' ) &&
|
||||
( s[2] == 'o' || s[2] == 'O' ) )
|
||||
{
|
||||
s += 3;
|
||||
if ( !ft_strcmp( s, "10646" ) ||
|
||||
( !ft_strcmp( s, "8859" ) &&
|
||||
!ft_strcmp( face->charset_encoding, "1" ) ) )
|
||||
unicode_charmap = 1;
|
||||
}
|
||||
|
||||
{
|
||||
FT_CharMapRec charmap;
|
||||
|
||||
|
||||
charmap.face = FT_FACE( face );
|
||||
charmap.encoding = FT_ENCODING_NONE;
|
||||
/* initial platform/encoding should indicate unset status? */
|
||||
charmap.platform_id = TT_PLATFORM_APPLE_UNICODE;
|
||||
charmap.encoding_id = TT_APPLE_ID_DEFAULT;
|
||||
|
||||
if ( unicode_charmap )
|
||||
{
|
||||
charmap.encoding = FT_ENCODING_UNICODE;
|
||||
charmap.platform_id = TT_PLATFORM_MICROSOFT;
|
||||
charmap.encoding_id = TT_MS_ID_UNICODE_CS;
|
||||
}
|
||||
|
||||
error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
|
||||
|
||||
#if 0
|
||||
/* Select default charmap */
|
||||
if ( bdfface->num_charmaps )
|
||||
bdfface->charmap = bdfface->charmaps[0];
|
||||
#endif
|
||||
}
|
||||
|
||||
goto Exit;
|
||||
}
|
||||
}
|
||||
|
||||
/* otherwise assume Adobe standard encoding */
|
||||
|
||||
{
|
||||
FT_CharMapRec charmap;
|
||||
|
||||
|
||||
charmap.face = FT_FACE( face );
|
||||
charmap.encoding = FT_ENCODING_ADOBE_STANDARD;
|
||||
charmap.platform_id = TT_PLATFORM_ADOBE;
|
||||
charmap.encoding_id = TT_ADOBE_ID_STANDARD;
|
||||
|
||||
error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );
|
||||
|
||||
/* Select default charmap */
|
||||
if ( bdfface->num_charmaps )
|
||||
bdfface->charmap = bdfface->charmaps[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
|
||||
Fail:
|
||||
BDF_Face_Done( bdfface );
|
||||
return BDF_Err_Unknown_File_Format;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
BDF_Size_Select( FT_Size size,
|
||||
FT_ULong strike_index )
|
||||
{
|
||||
bdf_font_t* bdffont = ( (BDF_Face)size->face )->bdffont;
|
||||
|
||||
|
||||
FT_Select_Metrics( size->face, strike_index );
|
||||
|
||||
size->metrics.ascender = bdffont->font_ascent << 6;
|
||||
size->metrics.descender = -bdffont->font_descent << 6;
|
||||
size->metrics.max_advance = bdffont->bbx.width << 6;
|
||||
|
||||
return BDF_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
BDF_Size_Request( FT_Size size,
|
||||
FT_Size_Request req )
|
||||
{
|
||||
FT_Face face = size->face;
|
||||
FT_Bitmap_Size* bsize = face->available_sizes;
|
||||
bdf_font_t* bdffont = ( (BDF_Face)face )->bdffont;
|
||||
FT_Error error = BDF_Err_Invalid_Pixel_Size;
|
||||
FT_Long height;
|
||||
|
||||
|
||||
height = FT_REQUEST_HEIGHT( req );
|
||||
height = ( height + 32 ) >> 6;
|
||||
|
||||
switch ( req->type )
|
||||
{
|
||||
case FT_SIZE_REQUEST_TYPE_NOMINAL:
|
||||
if ( height == ( ( bsize->y_ppem + 32 ) >> 6 ) )
|
||||
error = BDF_Err_Ok;
|
||||
break;
|
||||
|
||||
case FT_SIZE_REQUEST_TYPE_REAL_DIM:
|
||||
if ( height == ( bdffont->font_ascent +
|
||||
bdffont->font_descent ) )
|
||||
error = BDF_Err_Ok;
|
||||
break;
|
||||
|
||||
default:
|
||||
error = BDF_Err_Unimplemented_Feature;
|
||||
break;
|
||||
}
|
||||
|
||||
if ( error )
|
||||
return error;
|
||||
else
|
||||
return BDF_Size_Select( size, 0 );
|
||||
}
|
||||
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
BDF_Glyph_Load( FT_GlyphSlot slot,
|
||||
FT_Size size,
|
||||
FT_UInt glyph_index,
|
||||
FT_Int32 load_flags )
|
||||
{
|
||||
BDF_Face bdf = (BDF_Face)FT_SIZE_FACE( size );
|
||||
FT_Face face = FT_FACE( bdf );
|
||||
FT_Error error = BDF_Err_Ok;
|
||||
FT_Bitmap* bitmap = &slot->bitmap;
|
||||
bdf_glyph_t glyph;
|
||||
int bpp = bdf->bdffont->bpp;
|
||||
|
||||
FT_UNUSED( load_flags );
|
||||
|
||||
|
||||
if ( !face || glyph_index >= (FT_UInt)face->num_glyphs )
|
||||
{
|
||||
error = BDF_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* index 0 is the undefined glyph */
|
||||
if ( glyph_index == 0 )
|
||||
glyph_index = bdf->default_glyph;
|
||||
else
|
||||
glyph_index--;
|
||||
|
||||
/* slot, bitmap => freetype, glyph => bdflib */
|
||||
glyph = bdf->bdffont->glyphs[glyph_index];
|
||||
|
||||
bitmap->rows = glyph.bbx.height;
|
||||
bitmap->width = glyph.bbx.width;
|
||||
if ( glyph.bpr > INT_MAX )
|
||||
FT_TRACE1(( "BDF_Glyph_Load: too large pitch %d is truncated\n",
|
||||
glyph.bpr ));
|
||||
bitmap->pitch = (int)glyph.bpr; /* same as FT_Bitmap.pitch */
|
||||
|
||||
/* note: we don't allocate a new array to hold the bitmap; */
|
||||
/* we can simply point to it */
|
||||
ft_glyphslot_set_bitmap( slot, glyph.bitmap );
|
||||
|
||||
switch ( bpp )
|
||||
{
|
||||
case 1:
|
||||
bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
|
||||
break;
|
||||
case 2:
|
||||
bitmap->pixel_mode = FT_PIXEL_MODE_GRAY2;
|
||||
break;
|
||||
case 4:
|
||||
bitmap->pixel_mode = FT_PIXEL_MODE_GRAY4;
|
||||
break;
|
||||
case 8:
|
||||
bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
|
||||
bitmap->num_grays = 256;
|
||||
break;
|
||||
}
|
||||
|
||||
slot->format = FT_GLYPH_FORMAT_BITMAP;
|
||||
slot->bitmap_left = glyph.bbx.x_offset;
|
||||
slot->bitmap_top = glyph.bbx.ascent;
|
||||
|
||||
slot->metrics.horiAdvance = glyph.dwidth << 6;
|
||||
slot->metrics.horiBearingX = glyph.bbx.x_offset << 6;
|
||||
slot->metrics.horiBearingY = glyph.bbx.ascent << 6;
|
||||
slot->metrics.width = bitmap->width << 6;
|
||||
slot->metrics.height = bitmap->rows << 6;
|
||||
|
||||
/*
|
||||
* XXX DWIDTH1 and VVECTOR should be parsed and
|
||||
* used here, provided such fonts do exist.
|
||||
*/
|
||||
ft_synthesize_vertical_metrics( &slot->metrics,
|
||||
bdf->bdffont->bbx.height << 6 );
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* BDF SERVICE
|
||||
*
|
||||
*/
|
||||
|
||||
static FT_Error
|
||||
bdf_get_bdf_property( BDF_Face face,
|
||||
const char* prop_name,
|
||||
BDF_PropertyRec *aproperty )
|
||||
{
|
||||
bdf_property_t* prop;
|
||||
|
||||
|
||||
FT_ASSERT( face && face->bdffont );
|
||||
|
||||
prop = bdf_get_font_property( face->bdffont, prop_name );
|
||||
if ( prop )
|
||||
{
|
||||
switch ( prop->format )
|
||||
{
|
||||
case BDF_ATOM:
|
||||
aproperty->type = BDF_PROPERTY_TYPE_ATOM;
|
||||
aproperty->u.atom = prop->value.atom;
|
||||
break;
|
||||
|
||||
case BDF_INTEGER:
|
||||
if ( prop->value.l > 0x7FFFFFFFL || prop->value.l < ( -1 - 0x7FFFFFFFL ) )
|
||||
{
|
||||
FT_TRACE1(( "bdf_get_bdf_property: " ));
|
||||
FT_TRACE1(( "too large integer 0x%x is truncated\n" ));
|
||||
}
|
||||
aproperty->type = BDF_PROPERTY_TYPE_INTEGER;
|
||||
aproperty->u.integer = (FT_Int32)prop->value.l;
|
||||
break;
|
||||
|
||||
case BDF_CARDINAL:
|
||||
if ( prop->value.ul > 0xFFFFFFFFUL )
|
||||
{
|
||||
FT_TRACE1(( "bdf_get_bdf_property: " ));
|
||||
FT_TRACE1(( "too large cardinal 0x%x is truncated\n" ));
|
||||
}
|
||||
aproperty->type = BDF_PROPERTY_TYPE_CARDINAL;
|
||||
aproperty->u.cardinal = (FT_UInt32)prop->value.ul;
|
||||
break;
|
||||
|
||||
default:
|
||||
goto Fail;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
Fail:
|
||||
return BDF_Err_Invalid_Argument;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
bdf_get_charset_id( BDF_Face face,
|
||||
const char* *acharset_encoding,
|
||||
const char* *acharset_registry )
|
||||
{
|
||||
*acharset_encoding = face->charset_encoding;
|
||||
*acharset_registry = face->charset_registry;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static const FT_Service_BDFRec bdf_service_bdf =
|
||||
{
|
||||
(FT_BDF_GetCharsetIdFunc)bdf_get_charset_id,
|
||||
(FT_BDF_GetPropertyFunc) bdf_get_bdf_property
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* SERVICES LIST
|
||||
*
|
||||
*/
|
||||
|
||||
static const FT_ServiceDescRec bdf_services[] =
|
||||
{
|
||||
{ FT_SERVICE_ID_BDF, &bdf_service_bdf },
|
||||
{ FT_SERVICE_ID_XF86_NAME, FT_XF86_FORMAT_BDF },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Module_Interface )
|
||||
bdf_driver_requester( FT_Module module,
|
||||
const char* name )
|
||||
{
|
||||
FT_UNUSED( module );
|
||||
|
||||
return ft_service_list_lookup( bdf_services, name );
|
||||
}
|
||||
|
||||
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FT_Driver_ClassRec bdf_driver_class =
|
||||
{
|
||||
{
|
||||
FT_MODULE_FONT_DRIVER |
|
||||
FT_MODULE_DRIVER_NO_OUTLINES,
|
||||
sizeof ( FT_DriverRec ),
|
||||
|
||||
"bdf",
|
||||
0x10000L,
|
||||
0x20000L,
|
||||
|
||||
0,
|
||||
|
||||
(FT_Module_Constructor)0,
|
||||
(FT_Module_Destructor) 0,
|
||||
(FT_Module_Requester) bdf_driver_requester
|
||||
},
|
||||
|
||||
sizeof ( BDF_FaceRec ),
|
||||
sizeof ( FT_SizeRec ),
|
||||
sizeof ( FT_GlyphSlotRec ),
|
||||
|
||||
BDF_Face_Init,
|
||||
BDF_Face_Done,
|
||||
0, /* FT_Size_InitFunc */
|
||||
0, /* FT_Size_DoneFunc */
|
||||
0, /* FT_Slot_InitFunc */
|
||||
0, /* FT_Slot_DoneFunc */
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
ft_stub_set_char_sizes,
|
||||
ft_stub_set_pixel_sizes,
|
||||
#endif
|
||||
BDF_Glyph_Load,
|
||||
|
||||
0, /* FT_Face_GetKerningFunc */
|
||||
0, /* FT_Face_AttachFunc */
|
||||
0, /* FT_Face_GetAdvancesFunc */
|
||||
|
||||
BDF_Size_Request,
|
||||
BDF_Size_Select
|
||||
};
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,80 @@
|
||||
/* bdfdrivr.h
|
||||
|
||||
FreeType font driver for bdf fonts
|
||||
|
||||
Copyright (C) 2001, 2002, 2003, 2004 by
|
||||
Francesco Zappa Nardelli
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __BDFDRIVR_H__
|
||||
#define __BDFDRIVR_H__
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_DRIVER_H
|
||||
|
||||
#include "bdf.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_PIC
|
||||
#error "this module does not support PIC yet"
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct BDF_encoding_el_
|
||||
{
|
||||
FT_ULong enc;
|
||||
FT_UShort glyph;
|
||||
|
||||
} BDF_encoding_el;
|
||||
|
||||
|
||||
typedef struct BDF_FaceRec_
|
||||
{
|
||||
FT_FaceRec root;
|
||||
|
||||
char* charset_encoding;
|
||||
char* charset_registry;
|
||||
|
||||
bdf_font_t* bdffont;
|
||||
|
||||
BDF_encoding_el* en_table;
|
||||
|
||||
FT_CharMap charmap_handle;
|
||||
FT_CharMapRec charmap; /* a single charmap per face */
|
||||
|
||||
FT_UInt default_glyph;
|
||||
|
||||
} BDF_FaceRec, *BDF_Face;
|
||||
|
||||
|
||||
FT_EXPORT_VAR( const FT_Driver_ClassRec ) bdf_driver_class;
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
|
||||
#endif /* __BDFDRIVR_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,44 @@
|
||||
/*
|
||||
* Copyright 2001, 2002 Francesco Zappa Nardelli
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE COMPUTING RESEARCH LAB OR NEW MEXICO STATE UNIVERSITY BE LIABLE FOR ANY
|
||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
|
||||
* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
|
||||
* THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* This file is used to define the BDF error enumeration constants. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef __BDFERROR_H__
|
||||
#define __BDFERROR_H__
|
||||
|
||||
#include FT_MODULE_ERRORS_H
|
||||
|
||||
#undef __FTERRORS_H__
|
||||
|
||||
#define FT_ERR_PREFIX BDF_Err_
|
||||
#define FT_ERR_BASE FT_Mod_Err_BDF
|
||||
|
||||
#include FT_ERRORS_H
|
||||
|
||||
#endif /* __BDFERROR_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,34 @@
|
||||
#
|
||||
# FreeType 2 BDF module definition
|
||||
#
|
||||
|
||||
# Copyright 2001, 2002, 2006 by
|
||||
# Francesco Zappa Nardelli
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
|
||||
|
||||
FTMODULE_H_COMMANDS += BDF_DRIVER
|
||||
|
||||
define BDF_DRIVER
|
||||
$(OPEN_DRIVER) FT_Driver_ClassRec, bdf_driver_class $(CLOSE_DRIVER)
|
||||
$(ECHO_DRIVER)bdf $(ECHO_DRIVER_DESC)bdf bitmap fonts$(ECHO_DRIVER_DONE)
|
||||
endef
|
||||
|
||||
# EOF
|
||||
@@ -0,0 +1,81 @@
|
||||
#
|
||||
# FreeType 2 bdf driver configuration rules
|
||||
#
|
||||
|
||||
|
||||
# Copyright (C) 2001, 2002, 2003, 2008 by
|
||||
# Francesco Zappa Nardelli
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
# of this software and associated documentation files (the "Software"), to deal
|
||||
# in the Software without restriction, including without limitation the rights
|
||||
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
# copies of the Software, and to permit persons to whom the Software is
|
||||
# furnished to do so, subject to the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included in
|
||||
# all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
# THE SOFTWARE.
|
||||
|
||||
|
||||
|
||||
|
||||
# bdf driver directory
|
||||
#
|
||||
BDF_DIR := $(SRC_DIR)/bdf
|
||||
|
||||
|
||||
BDF_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(BDF_DIR))
|
||||
|
||||
|
||||
# bdf driver sources (i.e., C files)
|
||||
#
|
||||
BDF_DRV_SRC := $(BDF_DIR)/bdflib.c \
|
||||
$(BDF_DIR)/bdfdrivr.c
|
||||
|
||||
|
||||
# bdf driver headers
|
||||
#
|
||||
BDF_DRV_H := $(BDF_DIR)/bdf.h \
|
||||
$(BDF_DIR)/bdfdrivr.h \
|
||||
$(BDF_DIR)/bdferror.h
|
||||
|
||||
# bdf driver object(s)
|
||||
#
|
||||
# BDF_DRV_OBJ_M is used during `multi' builds
|
||||
# BDF_DRV_OBJ_S is used during `single' builds
|
||||
#
|
||||
BDF_DRV_OBJ_M := $(BDF_DRV_SRC:$(BDF_DIR)/%.c=$(OBJ_DIR)/%.$O)
|
||||
BDF_DRV_OBJ_S := $(OBJ_DIR)/bdf.$O
|
||||
|
||||
# bdf driver source file for single build
|
||||
#
|
||||
BDF_DRV_SRC_S := $(BDF_DIR)/bdf.c
|
||||
|
||||
|
||||
# bdf driver - single object
|
||||
#
|
||||
$(BDF_DRV_OBJ_S): $(BDF_DRV_SRC_S) $(BDF_DRV_SRC) $(FREETYPE_H) $(BDF_DRV_H)
|
||||
$(BDF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(BDF_DRV_SRC_S))
|
||||
|
||||
|
||||
# bdf driver - multiple objects
|
||||
#
|
||||
$(OBJ_DIR)/%.$O: $(BDF_DIR)/%.c $(FREETYPE_H) $(BDF_DRV_H)
|
||||
$(BDF_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
|
||||
|
||||
|
||||
# update main driver object lists
|
||||
#
|
||||
DRV_OBJS_S += $(BDF_DRV_OBJ_S)
|
||||
DRV_OBJS_M += $(BDF_DRV_OBJ_M)
|
||||
|
||||
|
||||
# EOF
|
||||
@@ -0,0 +1,19 @@
|
||||
# FreeType 2 src/bzip2 Jamfile
|
||||
#
|
||||
# Copyright 2010 by
|
||||
# Joel Klinghed
|
||||
#
|
||||
# Based on src/lzw/Jamfile, Copyright 2004, 2006 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.
|
||||
|
||||
SubDir FT2_TOP $(FT2_SRC_DIR) bzip2 ;
|
||||
|
||||
Library $(FT2_LIB) : ftbzip2.c ;
|
||||
|
||||
# end of src/bzip2 Jamfile
|
||||
@@ -0,0 +1,510 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftbzip2.c */
|
||||
/* */
|
||||
/* FreeType support for .bz2 compressed files. */
|
||||
/* */
|
||||
/* This optional component relies on libbz2. It should mainly be used to */
|
||||
/* parse compressed PCF fonts, as found with many X11 server */
|
||||
/* distributions. */
|
||||
/* */
|
||||
/* Copyright 2010 by */
|
||||
/* Joel Klinghed. */
|
||||
/* */
|
||||
/* Based on src/gzip/ftgzip.c, Copyright 2002 - 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_MEMORY_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_BZIP2_H
|
||||
#include FT_CONFIG_STANDARD_LIBRARY_H
|
||||
|
||||
|
||||
#include FT_MODULE_ERRORS_H
|
||||
|
||||
#undef __FTERRORS_H__
|
||||
|
||||
#define FT_ERR_PREFIX Bzip2_Err_
|
||||
#define FT_ERR_BASE FT_Mod_Err_Bzip2
|
||||
|
||||
#include FT_ERRORS_H
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_USE_BZIP2
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_PIC
|
||||
#error "bzip2 code does not support PIC yet"
|
||||
#endif
|
||||
|
||||
#define BZ_NO_STDIO /* Do not need FILE */
|
||||
#include <bzlib.h>
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
/***** *****/
|
||||
/***** B Z I P 2 M E M O R Y M A N A G E M E N T *****/
|
||||
/***** *****/
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
|
||||
/* it is better to use FreeType memory routines instead of raw
|
||||
'malloc/free' */
|
||||
|
||||
typedef void *(* alloc_func)(void*, int, int);
|
||||
typedef void (* free_func)(void*, void*);
|
||||
|
||||
static void*
|
||||
ft_bzip2_alloc( FT_Memory memory,
|
||||
int items,
|
||||
int size )
|
||||
{
|
||||
FT_ULong sz = (FT_ULong)size * items;
|
||||
FT_Error error;
|
||||
FT_Pointer p = NULL;
|
||||
|
||||
|
||||
(void)FT_ALLOC( p, sz );
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_bzip2_free( FT_Memory memory,
|
||||
void* address )
|
||||
{
|
||||
FT_MEM_FREE( address );
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
/***** *****/
|
||||
/***** B Z I P 2 F I L E D E S C R I P T O R *****/
|
||||
/***** *****/
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
|
||||
#define FT_BZIP2_BUFFER_SIZE 4096
|
||||
|
||||
typedef struct FT_BZip2FileRec_
|
||||
{
|
||||
FT_Stream source; /* parent/source stream */
|
||||
FT_Stream stream; /* embedding stream */
|
||||
FT_Memory memory; /* memory allocator */
|
||||
bz_stream bzstream; /* bzlib input stream */
|
||||
|
||||
FT_Byte input[FT_BZIP2_BUFFER_SIZE]; /* input read buffer */
|
||||
|
||||
FT_Byte buffer[FT_BZIP2_BUFFER_SIZE]; /* output buffer */
|
||||
FT_ULong pos; /* position in output */
|
||||
FT_Byte* cursor;
|
||||
FT_Byte* limit;
|
||||
|
||||
} FT_BZip2FileRec, *FT_BZip2File;
|
||||
|
||||
|
||||
/* check and skip .bz2 header - we don't support `transparent' compression */
|
||||
static FT_Error
|
||||
ft_bzip2_check_header( FT_Stream stream )
|
||||
{
|
||||
FT_Error error = Bzip2_Err_Ok;
|
||||
FT_Byte head[4];
|
||||
|
||||
|
||||
if ( FT_STREAM_SEEK( 0 ) ||
|
||||
FT_STREAM_READ( head, 4 ) )
|
||||
goto Exit;
|
||||
|
||||
/* head[0] && head[1] are the magic numbers; */
|
||||
/* head[2] is the version, and head[3] the blocksize */
|
||||
if ( head[0] != 0x42 ||
|
||||
head[1] != 0x5a ||
|
||||
head[2] != 0x68 ) /* only support bzip2 (huffman) */
|
||||
{
|
||||
error = Bzip2_Err_Invalid_File_Format;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_bzip2_file_init( FT_BZip2File zip,
|
||||
FT_Stream stream,
|
||||
FT_Stream source )
|
||||
{
|
||||
bz_stream* bzstream = &zip->bzstream;
|
||||
FT_Error error = Bzip2_Err_Ok;
|
||||
|
||||
|
||||
zip->stream = stream;
|
||||
zip->source = source;
|
||||
zip->memory = stream->memory;
|
||||
|
||||
zip->limit = zip->buffer + FT_BZIP2_BUFFER_SIZE;
|
||||
zip->cursor = zip->limit;
|
||||
zip->pos = 0;
|
||||
|
||||
/* check .bz2 header */
|
||||
{
|
||||
stream = source;
|
||||
|
||||
error = ft_bzip2_check_header( stream );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
if ( FT_STREAM_SEEK( 0 ) )
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* initialize bzlib */
|
||||
bzstream->bzalloc = (alloc_func)ft_bzip2_alloc;
|
||||
bzstream->bzfree = (free_func) ft_bzip2_free;
|
||||
bzstream->opaque = zip->memory;
|
||||
|
||||
bzstream->avail_in = 0;
|
||||
bzstream->next_in = (char*)zip->buffer;
|
||||
|
||||
if ( BZ2_bzDecompressInit( bzstream, 0, 0 ) != BZ_OK ||
|
||||
bzstream->next_in == NULL )
|
||||
error = Bzip2_Err_Invalid_File_Format;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_bzip2_file_done( FT_BZip2File zip )
|
||||
{
|
||||
bz_stream* bzstream = &zip->bzstream;
|
||||
|
||||
|
||||
BZ2_bzDecompressEnd( bzstream );
|
||||
|
||||
/* clear the rest */
|
||||
bzstream->bzalloc = NULL;
|
||||
bzstream->bzfree = NULL;
|
||||
bzstream->opaque = NULL;
|
||||
bzstream->next_in = NULL;
|
||||
bzstream->next_out = NULL;
|
||||
bzstream->avail_in = 0;
|
||||
bzstream->avail_out = 0;
|
||||
|
||||
zip->memory = NULL;
|
||||
zip->source = NULL;
|
||||
zip->stream = NULL;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_bzip2_file_reset( FT_BZip2File zip )
|
||||
{
|
||||
FT_Stream stream = zip->source;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
if ( !FT_STREAM_SEEK( 0 ) )
|
||||
{
|
||||
bz_stream* bzstream = &zip->bzstream;
|
||||
|
||||
|
||||
BZ2_bzDecompressEnd( bzstream );
|
||||
|
||||
bzstream->avail_in = 0;
|
||||
bzstream->next_in = (char*)zip->input;
|
||||
bzstream->avail_out = 0;
|
||||
bzstream->next_out = (char*)zip->buffer;
|
||||
|
||||
zip->limit = zip->buffer + FT_BZIP2_BUFFER_SIZE;
|
||||
zip->cursor = zip->limit;
|
||||
zip->pos = 0;
|
||||
|
||||
BZ2_bzDecompressInit( bzstream, 0, 0 );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_bzip2_file_fill_input( FT_BZip2File zip )
|
||||
{
|
||||
bz_stream* bzstream = &zip->bzstream;
|
||||
FT_Stream stream = zip->source;
|
||||
FT_ULong size;
|
||||
|
||||
|
||||
if ( stream->read )
|
||||
{
|
||||
size = stream->read( stream, stream->pos, zip->input,
|
||||
FT_BZIP2_BUFFER_SIZE );
|
||||
if ( size == 0 )
|
||||
return Bzip2_Err_Invalid_Stream_Operation;
|
||||
}
|
||||
else
|
||||
{
|
||||
size = stream->size - stream->pos;
|
||||
if ( size > FT_BZIP2_BUFFER_SIZE )
|
||||
size = FT_BZIP2_BUFFER_SIZE;
|
||||
|
||||
if ( size == 0 )
|
||||
return Bzip2_Err_Invalid_Stream_Operation;
|
||||
|
||||
FT_MEM_COPY( zip->input, stream->base + stream->pos, size );
|
||||
}
|
||||
stream->pos += size;
|
||||
|
||||
bzstream->next_in = (char*)zip->input;
|
||||
bzstream->avail_in = size;
|
||||
|
||||
return Bzip2_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_bzip2_file_fill_output( FT_BZip2File zip )
|
||||
{
|
||||
bz_stream* bzstream = &zip->bzstream;
|
||||
FT_Error error = Bzip2_Err_Ok;
|
||||
|
||||
|
||||
zip->cursor = zip->buffer;
|
||||
bzstream->next_out = (char*)zip->cursor;
|
||||
bzstream->avail_out = FT_BZIP2_BUFFER_SIZE;
|
||||
|
||||
while ( bzstream->avail_out > 0 )
|
||||
{
|
||||
int err;
|
||||
|
||||
|
||||
if ( bzstream->avail_in == 0 )
|
||||
{
|
||||
error = ft_bzip2_file_fill_input( zip );
|
||||
if ( error )
|
||||
break;
|
||||
}
|
||||
|
||||
err = BZ2_bzDecompress( bzstream );
|
||||
|
||||
if ( err == BZ_STREAM_END )
|
||||
{
|
||||
zip->limit = (FT_Byte*)bzstream->next_out;
|
||||
if ( zip->limit == zip->cursor )
|
||||
error = Bzip2_Err_Invalid_Stream_Operation;
|
||||
break;
|
||||
}
|
||||
else if ( err != BZ_OK )
|
||||
{
|
||||
error = Bzip2_Err_Invalid_Stream_Operation;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* fill output buffer; `count' must be <= FT_BZIP2_BUFFER_SIZE */
|
||||
static FT_Error
|
||||
ft_bzip2_file_skip_output( FT_BZip2File zip,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_Error error = Bzip2_Err_Ok;
|
||||
FT_ULong delta;
|
||||
|
||||
|
||||
for (;;)
|
||||
{
|
||||
delta = (FT_ULong)( zip->limit - zip->cursor );
|
||||
if ( delta >= count )
|
||||
delta = count;
|
||||
|
||||
zip->cursor += delta;
|
||||
zip->pos += delta;
|
||||
|
||||
count -= delta;
|
||||
if ( count == 0 )
|
||||
break;
|
||||
|
||||
error = ft_bzip2_file_fill_output( zip );
|
||||
if ( error )
|
||||
break;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_ULong
|
||||
ft_bzip2_file_io( FT_BZip2File zip,
|
||||
FT_ULong pos,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_ULong result = 0;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
/* Reset inflate stream if we're seeking backwards. */
|
||||
/* Yes, that is not too efficient, but it saves memory :-) */
|
||||
if ( pos < zip->pos )
|
||||
{
|
||||
error = ft_bzip2_file_reset( zip );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* skip unwanted bytes */
|
||||
if ( pos > zip->pos )
|
||||
{
|
||||
error = ft_bzip2_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( count == 0 )
|
||||
goto Exit;
|
||||
|
||||
/* now read the data */
|
||||
for (;;)
|
||||
{
|
||||
FT_ULong delta;
|
||||
|
||||
|
||||
delta = (FT_ULong)( zip->limit - zip->cursor );
|
||||
if ( delta >= count )
|
||||
delta = count;
|
||||
|
||||
FT_MEM_COPY( buffer, zip->cursor, delta );
|
||||
buffer += delta;
|
||||
result += delta;
|
||||
zip->cursor += delta;
|
||||
zip->pos += delta;
|
||||
|
||||
count -= delta;
|
||||
if ( count == 0 )
|
||||
break;
|
||||
|
||||
error = ft_bzip2_file_fill_output( zip );
|
||||
if ( error )
|
||||
break;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
/***** *****/
|
||||
/***** B Z E M B E D D I N G S T R E A M *****/
|
||||
/***** *****/
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
|
||||
static void
|
||||
ft_bzip2_stream_close( FT_Stream stream )
|
||||
{
|
||||
FT_BZip2File zip = (FT_BZip2File)stream->descriptor.pointer;
|
||||
FT_Memory memory = stream->memory;
|
||||
|
||||
|
||||
if ( zip )
|
||||
{
|
||||
/* finalize bzip file descriptor */
|
||||
ft_bzip2_file_done( zip );
|
||||
|
||||
FT_FREE( zip );
|
||||
|
||||
stream->descriptor.pointer = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static FT_ULong
|
||||
ft_bzip2_stream_io( FT_Stream stream,
|
||||
FT_ULong pos,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_BZip2File zip = (FT_BZip2File)stream->descriptor.pointer;
|
||||
|
||||
|
||||
return ft_bzip2_file_io( zip, pos, buffer, count );
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Stream_OpenBzip2( FT_Stream stream,
|
||||
FT_Stream source )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory = source->memory;
|
||||
FT_BZip2File zip = NULL;
|
||||
|
||||
|
||||
/*
|
||||
* check the header right now; this prevents allocating unnecessary
|
||||
* objects when we don't need them
|
||||
*/
|
||||
error = ft_bzip2_check_header( source );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
FT_ZERO( stream );
|
||||
stream->memory = memory;
|
||||
|
||||
if ( !FT_QNEW( zip ) )
|
||||
{
|
||||
error = ft_bzip2_file_init( zip, stream, source );
|
||||
if ( error )
|
||||
{
|
||||
FT_FREE( zip );
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
stream->descriptor.pointer = zip;
|
||||
}
|
||||
|
||||
stream->size = 0x7FFFFFFFL; /* don't know the real size! */
|
||||
stream->pos = 0;
|
||||
stream->base = 0;
|
||||
stream->read = ft_bzip2_stream_io;
|
||||
stream->close = ft_bzip2_stream_close;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
#else /* !FT_CONFIG_OPTION_USE_BZIP2 */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Stream_OpenBzip2( FT_Stream stream,
|
||||
FT_Stream source )
|
||||
{
|
||||
FT_UNUSED( stream );
|
||||
FT_UNUSED( source );
|
||||
|
||||
return Bzip2_Err_Unimplemented_Feature;
|
||||
}
|
||||
|
||||
#endif /* !FT_CONFIG_OPTION_USE_BZIP2 */
|
||||
|
||||
|
||||
/* END */
|
||||
@@ -0,0 +1,63 @@
|
||||
#
|
||||
# FreeType 2 BZIP2 support configuration rules
|
||||
#
|
||||
|
||||
# Copyright 2010 by
|
||||
# Joel Klinghed.
|
||||
#
|
||||
# Based on src/lzw/rules.mk, Copyright 2004-2006 by
|
||||
# Albert Chin-A-Young.
|
||||
#
|
||||
# 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.
|
||||
|
||||
|
||||
# BZIP2 driver directory
|
||||
#
|
||||
BZIP2_DIR := $(SRC_DIR)/bzip2
|
||||
|
||||
|
||||
# compilation flags for the driver
|
||||
#
|
||||
BZIP2_COMPILE := $(FT_COMPILE)
|
||||
|
||||
|
||||
# BZIP2 support sources (i.e., C files)
|
||||
#
|
||||
BZIP2_DRV_SRC := $(BZIP2_DIR)/ftbzip2.c
|
||||
|
||||
# BZIP2 driver object(s)
|
||||
#
|
||||
# BZIP2_DRV_OBJ_M is used during `multi' builds
|
||||
# BZIP2_DRV_OBJ_S is used during `single' builds
|
||||
#
|
||||
BZIP2_DRV_OBJ_M := $(OBJ_DIR)/ftbzip2.$O
|
||||
BZIP2_DRV_OBJ_S := $(OBJ_DIR)/ftbzip2.$O
|
||||
|
||||
# BZIP2 support source file for single build
|
||||
#
|
||||
BZIP2_DRV_SRC_S := $(BZIP2_DIR)/ftbzip2.c
|
||||
|
||||
|
||||
# BZIP2 support - single object
|
||||
#
|
||||
$(BZIP2_DRV_OBJ_S): $(BZIP2_DRV_SRC_S) $(BZIP2_DRV_SRC) $(FREETYPE_H) $(BZIP2_DRV_H)
|
||||
$(BZIP2_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(BZIP2_DRV_SRC_S))
|
||||
|
||||
|
||||
# BZIP2 support - multiple objects
|
||||
#
|
||||
$(OBJ_DIR)/%.$O: $(BZIP2_DIR)/%.c $(FREETYPE_H) $(BZIP2_DRV_H)
|
||||
$(BZIP2_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
|
||||
|
||||
|
||||
# update main driver object lists
|
||||
#
|
||||
DRV_OBJS_S += $(BZIP2_DRV_OBJ_S)
|
||||
DRV_OBJS_M += $(BZIP2_DRV_OBJ_M)
|
||||
|
||||
|
||||
# EOF
|
||||
Vendored
+43
@@ -0,0 +1,43 @@
|
||||
# FreeType 2 src/cache Jamfile
|
||||
#
|
||||
# Copyright 2001, 2003, 2004 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.
|
||||
|
||||
SubDir FT2_TOP $(FT2_SRC_DIR) cache ;
|
||||
|
||||
# The file <freetype/ftcache.h> contains some macro definitions that are
|
||||
# later used in #include statements related to the cache sub-system. It
|
||||
# needs to be parsed through a HDRMACRO rule for macro definitions.
|
||||
#
|
||||
HDRMACRO [ FT2_SubDir include ftcache.h ] ;
|
||||
|
||||
{
|
||||
local _sources ;
|
||||
|
||||
if $(FT2_MULTI)
|
||||
{
|
||||
_sources = ftcmru
|
||||
ftcmanag
|
||||
ftccache
|
||||
ftcglyph
|
||||
ftcsbits
|
||||
ftcimage
|
||||
ftcbasic
|
||||
ftccmap
|
||||
;
|
||||
}
|
||||
else
|
||||
{
|
||||
_sources = ftcache ;
|
||||
}
|
||||
|
||||
Library $(FT2_LIB) : $(_sources).c ;
|
||||
}
|
||||
|
||||
# end of src/cache Jamfile
|
||||
Vendored
+31
@@ -0,0 +1,31 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcache.c */
|
||||
/* */
|
||||
/* The FreeType Caching sub-system (body only). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2003 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#define FT_MAKE_OPTION_SINGLE_OBJECT
|
||||
|
||||
#include <ft2build.h>
|
||||
#include "ftcmru.c"
|
||||
#include "ftcmanag.c"
|
||||
#include "ftccache.c"
|
||||
#include "ftccmap.c"
|
||||
#include "ftcglyph.c"
|
||||
#include "ftcimage.c"
|
||||
#include "ftcsbits.c"
|
||||
#include "ftcbasic.c"
|
||||
|
||||
/* END */
|
||||
+855
@@ -0,0 +1,855 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcbasic.c */
|
||||
/* */
|
||||
/* The FreeType basic cache interface (body). */
|
||||
/* */
|
||||
/* Copyright 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_CACHE_H
|
||||
#include "ftcglyph.h"
|
||||
#include "ftcimage.h"
|
||||
#include "ftcsbits.h"
|
||||
|
||||
#include "ftccback.h"
|
||||
#include "ftcerror.h"
|
||||
|
||||
#define FT_COMPONENT trace_cache
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
/*
|
||||
* These structures correspond to the FTC_Font and FTC_ImageDesc types
|
||||
* that were defined in version 2.1.7.
|
||||
*/
|
||||
typedef struct FTC_OldFontRec_
|
||||
{
|
||||
FTC_FaceID face_id;
|
||||
FT_UShort pix_width;
|
||||
FT_UShort pix_height;
|
||||
|
||||
} FTC_OldFontRec, *FTC_OldFont;
|
||||
|
||||
|
||||
typedef struct FTC_OldImageDescRec_
|
||||
{
|
||||
FTC_OldFontRec font;
|
||||
FT_UInt32 flags;
|
||||
|
||||
} FTC_OldImageDescRec, *FTC_OldImageDesc;
|
||||
|
||||
|
||||
/*
|
||||
* Notice that FTC_OldImageDescRec and FTC_ImageTypeRec are nearly
|
||||
* identical, bit-wise. The only difference is that the `width' and
|
||||
* `height' fields are expressed as 16-bit integers in the old structure,
|
||||
* and as normal `int' in the new one.
|
||||
*
|
||||
* We are going to perform a weird hack to detect which structure is
|
||||
* being passed to the image and sbit caches. If the new structure's
|
||||
* `width' is larger than 0x10000, we assume that we are really receiving
|
||||
* an FTC_OldImageDesc.
|
||||
*/
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
|
||||
/*
|
||||
* Basic Families
|
||||
*
|
||||
*/
|
||||
typedef struct FTC_BasicAttrRec_
|
||||
{
|
||||
FTC_ScalerRec scaler;
|
||||
FT_UInt load_flags;
|
||||
|
||||
} FTC_BasicAttrRec, *FTC_BasicAttrs;
|
||||
|
||||
#define FTC_BASIC_ATTR_COMPARE( a, b ) \
|
||||
FT_BOOL( FTC_SCALER_COMPARE( &(a)->scaler, &(b)->scaler ) && \
|
||||
(a)->load_flags == (b)->load_flags )
|
||||
|
||||
#define FTC_BASIC_ATTR_HASH( a ) \
|
||||
( FTC_SCALER_HASH( &(a)->scaler ) + 31*(a)->load_flags )
|
||||
|
||||
|
||||
typedef struct FTC_BasicQueryRec_
|
||||
{
|
||||
FTC_GQueryRec gquery;
|
||||
FTC_BasicAttrRec attrs;
|
||||
|
||||
} FTC_BasicQueryRec, *FTC_BasicQuery;
|
||||
|
||||
|
||||
typedef struct FTC_BasicFamilyRec_
|
||||
{
|
||||
FTC_FamilyRec family;
|
||||
FTC_BasicAttrRec attrs;
|
||||
|
||||
} FTC_BasicFamilyRec, *FTC_BasicFamily;
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Bool )
|
||||
ftc_basic_family_compare( FTC_MruNode ftcfamily,
|
||||
FT_Pointer ftcquery )
|
||||
{
|
||||
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
|
||||
FTC_BasicQuery query = (FTC_BasicQuery)ftcquery;
|
||||
|
||||
|
||||
return FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ftc_basic_family_init( FTC_MruNode ftcfamily,
|
||||
FT_Pointer ftcquery,
|
||||
FT_Pointer ftccache )
|
||||
{
|
||||
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
|
||||
FTC_BasicQuery query = (FTC_BasicQuery)ftcquery;
|
||||
FTC_Cache cache = (FTC_Cache)ftccache;
|
||||
|
||||
|
||||
FTC_Family_Init( FTC_FAMILY( family ), cache );
|
||||
family->attrs = query->attrs;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_UInt )
|
||||
ftc_basic_family_get_count( FTC_Family ftcfamily,
|
||||
FTC_Manager manager )
|
||||
{
|
||||
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
|
||||
FT_Error error;
|
||||
FT_Face face;
|
||||
FT_UInt result = 0;
|
||||
|
||||
|
||||
error = FTC_Manager_LookupFace( manager, family->attrs.scaler.face_id,
|
||||
&face );
|
||||
|
||||
if ( error || !face )
|
||||
return result;
|
||||
|
||||
if ( (FT_ULong)face->num_glyphs > FT_UINT_MAX || 0 > face->num_glyphs )
|
||||
{
|
||||
FT_TRACE1(( "ftc_basic_family_get_count: too large number of glyphs " ));
|
||||
FT_TRACE1(( "in this face, truncated\n", face->num_glyphs ));
|
||||
}
|
||||
|
||||
if ( !error )
|
||||
result = (FT_UInt)face->num_glyphs;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ftc_basic_family_load_bitmap( FTC_Family ftcfamily,
|
||||
FT_UInt gindex,
|
||||
FTC_Manager manager,
|
||||
FT_Face *aface )
|
||||
{
|
||||
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
|
||||
FT_Error error;
|
||||
FT_Size size;
|
||||
|
||||
|
||||
error = FTC_Manager_LookupSize( manager, &family->attrs.scaler, &size );
|
||||
if ( !error )
|
||||
{
|
||||
FT_Face face = size->face;
|
||||
|
||||
|
||||
error = FT_Load_Glyph( face, gindex,
|
||||
family->attrs.load_flags | FT_LOAD_RENDER );
|
||||
if ( !error )
|
||||
*aface = face;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ftc_basic_family_load_glyph( FTC_Family ftcfamily,
|
||||
FT_UInt gindex,
|
||||
FTC_Cache cache,
|
||||
FT_Glyph *aglyph )
|
||||
{
|
||||
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
|
||||
FT_Error error;
|
||||
FTC_Scaler scaler = &family->attrs.scaler;
|
||||
FT_Face face;
|
||||
FT_Size size;
|
||||
|
||||
|
||||
/* we will now load the glyph image */
|
||||
error = FTC_Manager_LookupSize( cache->manager,
|
||||
scaler,
|
||||
&size );
|
||||
if ( !error )
|
||||
{
|
||||
face = size->face;
|
||||
|
||||
error = FT_Load_Glyph( face, gindex, family->attrs.load_flags );
|
||||
if ( !error )
|
||||
{
|
||||
if ( face->glyph->format == FT_GLYPH_FORMAT_BITMAP ||
|
||||
face->glyph->format == FT_GLYPH_FORMAT_OUTLINE )
|
||||
{
|
||||
/* ok, copy it */
|
||||
FT_Glyph glyph;
|
||||
|
||||
|
||||
error = FT_Get_Glyph( face->glyph, &glyph );
|
||||
if ( !error )
|
||||
{
|
||||
*aglyph = glyph;
|
||||
goto Exit;
|
||||
}
|
||||
}
|
||||
else
|
||||
error = FTC_Err_Invalid_Argument;
|
||||
}
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Bool )
|
||||
ftc_basic_gnode_compare_faceid( FTC_Node ftcgnode,
|
||||
FT_Pointer ftcface_id,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed )
|
||||
{
|
||||
FTC_GNode gnode = (FTC_GNode)ftcgnode;
|
||||
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
|
||||
FTC_BasicFamily family = (FTC_BasicFamily)gnode->family;
|
||||
FT_Bool result;
|
||||
|
||||
|
||||
if ( list_changed )
|
||||
*list_changed = FALSE;
|
||||
result = FT_BOOL( family->attrs.scaler.face_id == face_id );
|
||||
if ( result )
|
||||
{
|
||||
/* we must call this function to avoid this node from appearing
|
||||
* in later lookups with the same face_id!
|
||||
*/
|
||||
FTC_GNode_UnselectFamily( gnode, cache );
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* basic image cache
|
||||
*
|
||||
*/
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FTC_IFamilyClassRec ftc_basic_image_family_class =
|
||||
{
|
||||
{
|
||||
sizeof ( FTC_BasicFamilyRec ),
|
||||
ftc_basic_family_compare,
|
||||
ftc_basic_family_init,
|
||||
0, /* FTC_MruNode_ResetFunc */
|
||||
0 /* FTC_MruNode_DoneFunc */
|
||||
},
|
||||
ftc_basic_family_load_glyph
|
||||
};
|
||||
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FTC_GCacheClassRec ftc_basic_image_cache_class =
|
||||
{
|
||||
{
|
||||
ftc_inode_new,
|
||||
ftc_inode_weight,
|
||||
ftc_gnode_compare,
|
||||
ftc_basic_gnode_compare_faceid,
|
||||
ftc_inode_free,
|
||||
|
||||
sizeof ( FTC_GCacheRec ),
|
||||
ftc_gcache_init,
|
||||
ftc_gcache_done
|
||||
},
|
||||
(FTC_MruListClass)&ftc_basic_image_family_class
|
||||
};
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_ImageCache_New( FTC_Manager manager,
|
||||
FTC_ImageCache *acache )
|
||||
{
|
||||
return FTC_GCache_New( manager, &ftc_basic_image_cache_class,
|
||||
(FTC_GCache*)acache );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_ImageCache_Lookup( FTC_ImageCache cache,
|
||||
FTC_ImageType type,
|
||||
FT_UInt gindex,
|
||||
FT_Glyph *aglyph,
|
||||
FTC_Node *anode )
|
||||
{
|
||||
FTC_BasicQueryRec query;
|
||||
FTC_Node node = 0; /* make compiler happy */
|
||||
FT_Error error;
|
||||
FT_PtrDist hash;
|
||||
|
||||
|
||||
/* some argument checks are delayed to FTC_Cache_Lookup */
|
||||
if ( !aglyph )
|
||||
{
|
||||
error = FTC_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
*aglyph = NULL;
|
||||
if ( anode )
|
||||
*anode = NULL;
|
||||
|
||||
#if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU )
|
||||
|
||||
/*
|
||||
* This one is a major hack used to detect whether we are passed a
|
||||
* regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one.
|
||||
*/
|
||||
if ( (FT_ULong)type->width >= 0x10000L )
|
||||
{
|
||||
FTC_OldImageDesc desc = (FTC_OldImageDesc)type;
|
||||
|
||||
|
||||
query.attrs.scaler.face_id = desc->font.face_id;
|
||||
query.attrs.scaler.width = desc->font.pix_width;
|
||||
query.attrs.scaler.height = desc->font.pix_height;
|
||||
query.attrs.load_flags = desc->flags;
|
||||
}
|
||||
else
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
{
|
||||
if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
|
||||
{
|
||||
FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
|
||||
FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
|
||||
}
|
||||
|
||||
query.attrs.scaler.face_id = type->face_id;
|
||||
query.attrs.scaler.width = type->width;
|
||||
query.attrs.scaler.height = type->height;
|
||||
query.attrs.load_flags = (FT_UInt)type->flags;
|
||||
}
|
||||
|
||||
query.attrs.scaler.pixel = 1;
|
||||
query.attrs.scaler.x_res = 0; /* make compilers happy */
|
||||
query.attrs.scaler.y_res = 0;
|
||||
|
||||
hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
|
||||
|
||||
#if 1 /* inlining is about 50% faster! */
|
||||
FTC_GCACHE_LOOKUP_CMP( cache,
|
||||
ftc_basic_family_compare,
|
||||
FTC_GNode_Compare,
|
||||
hash, gindex,
|
||||
&query,
|
||||
node,
|
||||
error );
|
||||
#else
|
||||
error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
|
||||
hash, gindex,
|
||||
FTC_GQUERY( &query ),
|
||||
&node );
|
||||
#endif
|
||||
if ( !error )
|
||||
{
|
||||
*aglyph = FTC_INODE( node )->glyph;
|
||||
|
||||
if ( anode )
|
||||
{
|
||||
*anode = node;
|
||||
node->ref_count++;
|
||||
}
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_ImageCache_LookupScaler( FTC_ImageCache cache,
|
||||
FTC_Scaler scaler,
|
||||
FT_ULong load_flags,
|
||||
FT_UInt gindex,
|
||||
FT_Glyph *aglyph,
|
||||
FTC_Node *anode )
|
||||
{
|
||||
FTC_BasicQueryRec query;
|
||||
FTC_Node node = 0; /* make compiler happy */
|
||||
FT_Error error;
|
||||
FT_PtrDist hash;
|
||||
|
||||
|
||||
/* some argument checks are delayed to FTC_Cache_Lookup */
|
||||
if ( !aglyph || !scaler )
|
||||
{
|
||||
error = FTC_Err_Invalid_Argument;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
*aglyph = NULL;
|
||||
if ( anode )
|
||||
*anode = NULL;
|
||||
|
||||
/* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
|
||||
if ( load_flags > FT_UINT_MAX )
|
||||
{
|
||||
FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
|
||||
FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
|
||||
}
|
||||
|
||||
query.attrs.scaler = scaler[0];
|
||||
query.attrs.load_flags = (FT_UInt)load_flags;
|
||||
|
||||
hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
|
||||
|
||||
FTC_GCACHE_LOOKUP_CMP( cache,
|
||||
ftc_basic_family_compare,
|
||||
FTC_GNode_Compare,
|
||||
hash, gindex,
|
||||
&query,
|
||||
node,
|
||||
error );
|
||||
if ( !error )
|
||||
{
|
||||
*aglyph = FTC_INODE( node )->glyph;
|
||||
|
||||
if ( anode )
|
||||
{
|
||||
*anode = node;
|
||||
node->ref_count++;
|
||||
}
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
/* yet another backwards-legacy structure */
|
||||
typedef struct FTC_OldImage_Desc_
|
||||
{
|
||||
FTC_FontRec font;
|
||||
FT_UInt image_type;
|
||||
|
||||
} FTC_OldImage_Desc;
|
||||
|
||||
|
||||
#define FTC_OLD_IMAGE_FORMAT( x ) ( (x) & 7 )
|
||||
|
||||
|
||||
#define ftc_old_image_format_bitmap 0x0000
|
||||
#define ftc_old_image_format_outline 0x0001
|
||||
|
||||
#define ftc_old_image_format_mask 0x000F
|
||||
|
||||
#define ftc_old_image_flag_monochrome 0x0010
|
||||
#define ftc_old_image_flag_unhinted 0x0020
|
||||
#define ftc_old_image_flag_autohinted 0x0040
|
||||
#define ftc_old_image_flag_unscaled 0x0080
|
||||
#define ftc_old_image_flag_no_sbits 0x0100
|
||||
|
||||
/* monochrome bitmap */
|
||||
#define ftc_old_image_mono ftc_old_image_format_bitmap | \
|
||||
ftc_old_image_flag_monochrome
|
||||
|
||||
/* anti-aliased bitmap */
|
||||
#define ftc_old_image_grays ftc_old_image_format_bitmap
|
||||
|
||||
/* scaled outline */
|
||||
#define ftc_old_image_outline ftc_old_image_format_outline
|
||||
|
||||
|
||||
static void
|
||||
ftc_image_type_from_old_desc( FTC_ImageType typ,
|
||||
FTC_OldImage_Desc* desc )
|
||||
{
|
||||
typ->face_id = desc->font.face_id;
|
||||
typ->width = desc->font.pix_width;
|
||||
typ->height = desc->font.pix_height;
|
||||
|
||||
/* convert image type flags to load flags */
|
||||
{
|
||||
FT_UInt load_flags = FT_LOAD_DEFAULT;
|
||||
FT_UInt type = desc->image_type;
|
||||
|
||||
|
||||
/* determine load flags, depending on the font description's */
|
||||
/* image type */
|
||||
|
||||
if ( FTC_OLD_IMAGE_FORMAT( type ) == ftc_old_image_format_bitmap )
|
||||
{
|
||||
if ( type & ftc_old_image_flag_monochrome )
|
||||
load_flags |= FT_LOAD_MONOCHROME;
|
||||
|
||||
/* disable embedded bitmaps loading if necessary */
|
||||
if ( type & ftc_old_image_flag_no_sbits )
|
||||
load_flags |= FT_LOAD_NO_BITMAP;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* we want an outline, don't load embedded bitmaps */
|
||||
load_flags |= FT_LOAD_NO_BITMAP;
|
||||
|
||||
if ( type & ftc_old_image_flag_unscaled )
|
||||
load_flags |= FT_LOAD_NO_SCALE;
|
||||
}
|
||||
|
||||
/* always render glyphs to bitmaps */
|
||||
load_flags |= FT_LOAD_RENDER;
|
||||
|
||||
if ( type & ftc_old_image_flag_unhinted )
|
||||
load_flags |= FT_LOAD_NO_HINTING;
|
||||
|
||||
if ( type & ftc_old_image_flag_autohinted )
|
||||
load_flags |= FT_LOAD_FORCE_AUTOHINT;
|
||||
|
||||
typ->flags = load_flags;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT( FT_Error )
|
||||
FTC_Image_Cache_New( FTC_Manager manager,
|
||||
FTC_ImageCache *acache );
|
||||
|
||||
FT_EXPORT( FT_Error )
|
||||
FTC_Image_Cache_Lookup( FTC_ImageCache icache,
|
||||
FTC_OldImage_Desc* desc,
|
||||
FT_UInt gindex,
|
||||
FT_Glyph *aglyph );
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_Image_Cache_New( FTC_Manager manager,
|
||||
FTC_ImageCache *acache )
|
||||
{
|
||||
return FTC_ImageCache_New( manager, (FTC_ImageCache*)acache );
|
||||
}
|
||||
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_Image_Cache_Lookup( FTC_ImageCache icache,
|
||||
FTC_OldImage_Desc* desc,
|
||||
FT_UInt gindex,
|
||||
FT_Glyph *aglyph )
|
||||
{
|
||||
FTC_ImageTypeRec type0;
|
||||
|
||||
|
||||
if ( !desc )
|
||||
return FTC_Err_Invalid_Argument;
|
||||
|
||||
ftc_image_type_from_old_desc( &type0, desc );
|
||||
|
||||
return FTC_ImageCache_Lookup( (FTC_ImageCache)icache,
|
||||
&type0,
|
||||
gindex,
|
||||
aglyph,
|
||||
NULL );
|
||||
}
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* basic small bitmap cache
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FTC_SFamilyClassRec ftc_basic_sbit_family_class =
|
||||
{
|
||||
{
|
||||
sizeof( FTC_BasicFamilyRec ),
|
||||
ftc_basic_family_compare,
|
||||
ftc_basic_family_init,
|
||||
0, /* FTC_MruNode_ResetFunc */
|
||||
0 /* FTC_MruNode_DoneFunc */
|
||||
},
|
||||
ftc_basic_family_get_count,
|
||||
ftc_basic_family_load_bitmap
|
||||
};
|
||||
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FTC_GCacheClassRec ftc_basic_sbit_cache_class =
|
||||
{
|
||||
{
|
||||
ftc_snode_new,
|
||||
ftc_snode_weight,
|
||||
ftc_snode_compare,
|
||||
ftc_basic_gnode_compare_faceid,
|
||||
ftc_snode_free,
|
||||
|
||||
sizeof ( FTC_GCacheRec ),
|
||||
ftc_gcache_init,
|
||||
ftc_gcache_done
|
||||
},
|
||||
(FTC_MruListClass)&ftc_basic_sbit_family_class
|
||||
};
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_SBitCache_New( FTC_Manager manager,
|
||||
FTC_SBitCache *acache )
|
||||
{
|
||||
return FTC_GCache_New( manager, &ftc_basic_sbit_cache_class,
|
||||
(FTC_GCache*)acache );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_SBitCache_Lookup( FTC_SBitCache cache,
|
||||
FTC_ImageType type,
|
||||
FT_UInt gindex,
|
||||
FTC_SBit *ansbit,
|
||||
FTC_Node *anode )
|
||||
{
|
||||
FT_Error error;
|
||||
FTC_BasicQueryRec query;
|
||||
FTC_Node node = 0; /* make compiler happy */
|
||||
FT_PtrDist hash;
|
||||
|
||||
|
||||
if ( anode )
|
||||
*anode = NULL;
|
||||
|
||||
/* other argument checks delayed to FTC_Cache_Lookup */
|
||||
if ( !ansbit )
|
||||
return FTC_Err_Invalid_Argument;
|
||||
|
||||
*ansbit = NULL;
|
||||
|
||||
#if defined( FT_CONFIG_OPTION_OLD_INTERNALS ) && ( FT_INT_MAX > 0xFFFFU )
|
||||
|
||||
/* This one is a major hack used to detect whether we are passed a
|
||||
* regular FTC_ImageType handle, or a legacy FTC_OldImageDesc one.
|
||||
*/
|
||||
if ( (FT_ULong)type->width >= 0x10000L )
|
||||
{
|
||||
FTC_OldImageDesc desc = (FTC_OldImageDesc)type;
|
||||
|
||||
|
||||
query.attrs.scaler.face_id = desc->font.face_id;
|
||||
query.attrs.scaler.width = desc->font.pix_width;
|
||||
query.attrs.scaler.height = desc->font.pix_height;
|
||||
query.attrs.load_flags = desc->flags;
|
||||
}
|
||||
else
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
{
|
||||
if ( (FT_ULong)(type->flags - FT_INT_MIN) > FT_UINT_MAX )
|
||||
{
|
||||
FT_TRACE1(( "FTC_ImageCache_Lookup: higher bits in load_flags" ));
|
||||
FT_TRACE1(( "0x%x are dropped\n", (type->flags & ~((FT_ULong)FT_UINT_MAX)) ));
|
||||
}
|
||||
|
||||
query.attrs.scaler.face_id = type->face_id;
|
||||
query.attrs.scaler.width = type->width;
|
||||
query.attrs.scaler.height = type->height;
|
||||
query.attrs.load_flags = (FT_UInt)type->flags;
|
||||
}
|
||||
|
||||
query.attrs.scaler.pixel = 1;
|
||||
query.attrs.scaler.x_res = 0; /* make compilers happy */
|
||||
query.attrs.scaler.y_res = 0;
|
||||
|
||||
/* beware, the hash must be the same for all glyph ranges! */
|
||||
hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
|
||||
gindex / FTC_SBIT_ITEMS_PER_NODE;
|
||||
|
||||
#if 1 /* inlining is about 50% faster! */
|
||||
FTC_GCACHE_LOOKUP_CMP( cache,
|
||||
ftc_basic_family_compare,
|
||||
FTC_SNode_Compare,
|
||||
hash, gindex,
|
||||
&query,
|
||||
node,
|
||||
error );
|
||||
#else
|
||||
error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
|
||||
hash,
|
||||
gindex,
|
||||
FTC_GQUERY( &query ),
|
||||
&node );
|
||||
#endif
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
*ansbit = FTC_SNODE( node )->sbits +
|
||||
( gindex - FTC_GNODE( node )->gindex );
|
||||
|
||||
if ( anode )
|
||||
{
|
||||
*anode = node;
|
||||
node->ref_count++;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_SBitCache_LookupScaler( FTC_SBitCache cache,
|
||||
FTC_Scaler scaler,
|
||||
FT_ULong load_flags,
|
||||
FT_UInt gindex,
|
||||
FTC_SBit *ansbit,
|
||||
FTC_Node *anode )
|
||||
{
|
||||
FT_Error error;
|
||||
FTC_BasicQueryRec query;
|
||||
FTC_Node node = 0; /* make compiler happy */
|
||||
FT_PtrDist hash;
|
||||
|
||||
|
||||
if ( anode )
|
||||
*anode = NULL;
|
||||
|
||||
/* other argument checks delayed to FTC_Cache_Lookup */
|
||||
if ( !ansbit || !scaler )
|
||||
return FTC_Err_Invalid_Argument;
|
||||
|
||||
*ansbit = NULL;
|
||||
|
||||
/* FT_Load_Glyph(), FT_Load_Char() take FT_UInt flags */
|
||||
if ( load_flags > FT_UINT_MAX )
|
||||
{
|
||||
FT_TRACE1(( "FTC_ImageCache_LookupScaler: higher bits in load_flags" ));
|
||||
FT_TRACE1(( "0x%x are dropped\n", (load_flags & ~((FT_ULong)FT_UINT_MAX)) ));
|
||||
}
|
||||
|
||||
query.attrs.scaler = scaler[0];
|
||||
query.attrs.load_flags = (FT_UInt)load_flags;
|
||||
|
||||
/* beware, the hash must be the same for all glyph ranges! */
|
||||
hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
|
||||
gindex / FTC_SBIT_ITEMS_PER_NODE;
|
||||
|
||||
FTC_GCACHE_LOOKUP_CMP( cache,
|
||||
ftc_basic_family_compare,
|
||||
FTC_SNode_Compare,
|
||||
hash, gindex,
|
||||
&query,
|
||||
node,
|
||||
error );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
*ansbit = FTC_SNODE( node )->sbits +
|
||||
( gindex - FTC_GNODE( node )->gindex );
|
||||
|
||||
if ( anode )
|
||||
{
|
||||
*anode = node;
|
||||
node->ref_count++;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
FT_EXPORT( FT_Error )
|
||||
FTC_SBit_Cache_New( FTC_Manager manager,
|
||||
FTC_SBitCache *acache );
|
||||
|
||||
FT_EXPORT( FT_Error )
|
||||
FTC_SBit_Cache_Lookup( FTC_SBitCache cache,
|
||||
FTC_OldImage_Desc* desc,
|
||||
FT_UInt gindex,
|
||||
FTC_SBit *ansbit );
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_SBit_Cache_New( FTC_Manager manager,
|
||||
FTC_SBitCache *acache )
|
||||
{
|
||||
return FTC_SBitCache_New( manager, (FTC_SBitCache*)acache );
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_SBit_Cache_Lookup( FTC_SBitCache cache,
|
||||
FTC_OldImage_Desc* desc,
|
||||
FT_UInt gindex,
|
||||
FTC_SBit *ansbit )
|
||||
{
|
||||
FTC_ImageTypeRec type0;
|
||||
|
||||
|
||||
if ( !desc )
|
||||
return FTC_Err_Invalid_Argument;
|
||||
|
||||
ftc_image_type_from_old_desc( &type0, desc );
|
||||
|
||||
return FTC_SBitCache_Lookup( (FTC_SBitCache)cache,
|
||||
&type0,
|
||||
gindex,
|
||||
ansbit,
|
||||
NULL );
|
||||
}
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
|
||||
/* END */
|
||||
+626
@@ -0,0 +1,626 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftccache.c */
|
||||
/* */
|
||||
/* The FreeType internal cache interface (body). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, */
|
||||
/* 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include "ftcmanag.h"
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
|
||||
#include "ftccback.h"
|
||||
#include "ftcerror.h"
|
||||
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_cache
|
||||
|
||||
|
||||
#define FTC_HASH_MAX_LOAD 2
|
||||
#define FTC_HASH_MIN_LOAD 1
|
||||
#define FTC_HASH_SUB_LOAD ( FTC_HASH_MAX_LOAD - FTC_HASH_MIN_LOAD )
|
||||
|
||||
/* this one _must_ be a power of 2! */
|
||||
#define FTC_HASH_INITIAL_SIZE 8
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** CACHE NODE DEFINITIONS *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/* add a new node to the head of the manager's circular MRU list */
|
||||
static void
|
||||
ftc_node_mru_link( FTC_Node node,
|
||||
FTC_Manager manager )
|
||||
{
|
||||
void *nl = &manager->nodes_list;
|
||||
|
||||
|
||||
FTC_MruNode_Prepend( (FTC_MruNode*)nl,
|
||||
(FTC_MruNode)node );
|
||||
manager->num_nodes++;
|
||||
}
|
||||
|
||||
|
||||
/* remove a node from the manager's MRU list */
|
||||
static void
|
||||
ftc_node_mru_unlink( FTC_Node node,
|
||||
FTC_Manager manager )
|
||||
{
|
||||
void *nl = &manager->nodes_list;
|
||||
|
||||
|
||||
FTC_MruNode_Remove( (FTC_MruNode*)nl,
|
||||
(FTC_MruNode)node );
|
||||
manager->num_nodes--;
|
||||
}
|
||||
|
||||
|
||||
#ifndef FTC_INLINE
|
||||
|
||||
/* move a node to the head of the manager's MRU list */
|
||||
static void
|
||||
ftc_node_mru_up( FTC_Node node,
|
||||
FTC_Manager manager )
|
||||
{
|
||||
FTC_MruNode_Up( (FTC_MruNode*)&manager->nodes_list,
|
||||
(FTC_MruNode)node );
|
||||
}
|
||||
|
||||
|
||||
/* get a top bucket for specified hash from cache,
|
||||
* body for FTC_NODE__TOP_FOR_HASH( cache, hash )
|
||||
*/
|
||||
FT_LOCAL_DEF( FTC_Node* )
|
||||
ftc_get_top_node_for_hash( FTC_Cache cache,
|
||||
FT_PtrDist hash )
|
||||
{
|
||||
FTC_Node* pnode;
|
||||
FT_UInt idx;
|
||||
|
||||
|
||||
idx = (FT_UInt)( hash & cache->mask );
|
||||
if ( idx < cache->p )
|
||||
idx = (FT_UInt)( hash & ( 2 * cache->mask + 1 ) );
|
||||
pnode = cache->buckets + idx;
|
||||
return pnode;
|
||||
}
|
||||
|
||||
#endif /* !FTC_INLINE */
|
||||
|
||||
|
||||
/* Note that this function cannot fail. If we cannot re-size the
|
||||
* buckets array appropriately, we simply degrade the hash table's
|
||||
* performance!
|
||||
*/
|
||||
static void
|
||||
ftc_cache_resize( FTC_Cache cache )
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
FTC_Node node, *pnode;
|
||||
FT_UFast p = cache->p;
|
||||
FT_UFast mask = cache->mask;
|
||||
FT_UFast count = mask + p + 1; /* number of buckets */
|
||||
|
||||
|
||||
/* do we need to shrink the buckets array? */
|
||||
if ( cache->slack < 0 )
|
||||
{
|
||||
FTC_Node new_list = NULL;
|
||||
|
||||
|
||||
/* try to expand the buckets array _before_ splitting
|
||||
* the bucket lists
|
||||
*/
|
||||
if ( p >= mask )
|
||||
{
|
||||
FT_Memory memory = cache->memory;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
/* if we can't expand the array, leave immediately */
|
||||
if ( FT_RENEW_ARRAY( cache->buckets,
|
||||
( mask + 1 ) * 2, ( mask + 1 ) * 4 ) )
|
||||
break;
|
||||
}
|
||||
|
||||
/* split a single bucket */
|
||||
pnode = cache->buckets + p;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
node = *pnode;
|
||||
if ( node == NULL )
|
||||
break;
|
||||
|
||||
if ( node->hash & ( mask + 1 ) )
|
||||
{
|
||||
*pnode = node->link;
|
||||
node->link = new_list;
|
||||
new_list = node;
|
||||
}
|
||||
else
|
||||
pnode = &node->link;
|
||||
}
|
||||
|
||||
cache->buckets[p + mask + 1] = new_list;
|
||||
|
||||
cache->slack += FTC_HASH_MAX_LOAD;
|
||||
|
||||
if ( p >= mask )
|
||||
{
|
||||
cache->mask = 2 * mask + 1;
|
||||
cache->p = 0;
|
||||
}
|
||||
else
|
||||
cache->p = p + 1;
|
||||
}
|
||||
|
||||
/* do we need to expand the buckets array? */
|
||||
else if ( cache->slack > (FT_Long)count * FTC_HASH_SUB_LOAD )
|
||||
{
|
||||
FT_UFast old_index = p + mask;
|
||||
FTC_Node* pold;
|
||||
|
||||
|
||||
if ( old_index + 1 <= FTC_HASH_INITIAL_SIZE )
|
||||
break;
|
||||
|
||||
if ( p == 0 )
|
||||
{
|
||||
FT_Memory memory = cache->memory;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
/* if we can't shrink the array, leave immediately */
|
||||
if ( FT_RENEW_ARRAY( cache->buckets,
|
||||
( mask + 1 ) * 2, mask + 1 ) )
|
||||
break;
|
||||
|
||||
cache->mask >>= 1;
|
||||
p = cache->mask;
|
||||
}
|
||||
else
|
||||
p--;
|
||||
|
||||
pnode = cache->buckets + p;
|
||||
while ( *pnode )
|
||||
pnode = &(*pnode)->link;
|
||||
|
||||
pold = cache->buckets + old_index;
|
||||
*pnode = *pold;
|
||||
*pold = NULL;
|
||||
|
||||
cache->slack -= FTC_HASH_MAX_LOAD;
|
||||
cache->p = p;
|
||||
}
|
||||
|
||||
/* otherwise, the hash table is balanced */
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* remove a node from its cache's hash table */
|
||||
static void
|
||||
ftc_node_hash_unlink( FTC_Node node0,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FTC_Node *pnode = FTC_NODE__TOP_FOR_HASH( cache, node0->hash );
|
||||
|
||||
|
||||
for (;;)
|
||||
{
|
||||
FTC_Node node = *pnode;
|
||||
|
||||
|
||||
if ( node == NULL )
|
||||
{
|
||||
FT_TRACE0(( "ftc_node_hash_unlink: unknown node\n" ));
|
||||
return;
|
||||
}
|
||||
|
||||
if ( node == node0 )
|
||||
break;
|
||||
|
||||
pnode = &(*pnode)->link;
|
||||
}
|
||||
|
||||
*pnode = node0->link;
|
||||
node0->link = NULL;
|
||||
|
||||
cache->slack++;
|
||||
ftc_cache_resize( cache );
|
||||
}
|
||||
|
||||
|
||||
/* add a node to the `top' of its cache's hash table */
|
||||
static void
|
||||
ftc_node_hash_link( FTC_Node node,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FTC_Node *pnode = FTC_NODE__TOP_FOR_HASH( cache, node->hash );
|
||||
|
||||
|
||||
node->link = *pnode;
|
||||
*pnode = node;
|
||||
|
||||
cache->slack--;
|
||||
ftc_cache_resize( cache );
|
||||
}
|
||||
|
||||
|
||||
/* remove a node from the cache manager */
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
FT_BASE_DEF( void )
|
||||
#else
|
||||
FT_LOCAL_DEF( void )
|
||||
#endif
|
||||
ftc_node_destroy( FTC_Node node,
|
||||
FTC_Manager manager )
|
||||
{
|
||||
FTC_Cache cache;
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_ERROR
|
||||
/* find node's cache */
|
||||
if ( node->cache_index >= manager->num_caches )
|
||||
{
|
||||
FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
cache = manager->caches[node->cache_index];
|
||||
|
||||
#ifdef FT_DEBUG_ERROR
|
||||
if ( cache == NULL )
|
||||
{
|
||||
FT_TRACE0(( "ftc_node_destroy: invalid node handle\n" ));
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
manager->cur_weight -= cache->clazz.node_weight( node, cache );
|
||||
|
||||
/* remove node from mru list */
|
||||
ftc_node_mru_unlink( node, manager );
|
||||
|
||||
/* remove node from cache's hash table */
|
||||
ftc_node_hash_unlink( node, cache );
|
||||
|
||||
/* now finalize it */
|
||||
cache->clazz.node_free( node, cache );
|
||||
|
||||
#if 0
|
||||
/* check, just in case of general corruption :-) */
|
||||
if ( manager->num_nodes == 0 )
|
||||
FT_TRACE0(( "ftc_node_destroy: invalid cache node count (%d)\n",
|
||||
manager->num_nodes ));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** ABSTRACT CACHE CLASS *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_Cache_Init( FTC_Cache cache )
|
||||
{
|
||||
return ftc_cache_init( cache );
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
ftc_cache_init( FTC_Cache cache )
|
||||
{
|
||||
FT_Memory memory = cache->memory;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
cache->p = 0;
|
||||
cache->mask = FTC_HASH_INITIAL_SIZE - 1;
|
||||
cache->slack = FTC_HASH_INITIAL_SIZE * FTC_HASH_MAX_LOAD;
|
||||
|
||||
(void)FT_NEW_ARRAY( cache->buckets, FTC_HASH_INITIAL_SIZE * 2 );
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
FTC_Cache_Clear( FTC_Cache cache )
|
||||
{
|
||||
if ( cache && cache->buckets )
|
||||
{
|
||||
FTC_Manager manager = cache->manager;
|
||||
FT_UFast i;
|
||||
FT_UFast count;
|
||||
|
||||
|
||||
count = cache->p + cache->mask + 1;
|
||||
|
||||
for ( i = 0; i < count; i++ )
|
||||
{
|
||||
FTC_Node *pnode = cache->buckets + i, next, node = *pnode;
|
||||
|
||||
|
||||
while ( node )
|
||||
{
|
||||
next = node->link;
|
||||
node->link = NULL;
|
||||
|
||||
/* remove node from mru list */
|
||||
ftc_node_mru_unlink( node, manager );
|
||||
|
||||
/* now finalize it */
|
||||
manager->cur_weight -= cache->clazz.node_weight( node, cache );
|
||||
|
||||
cache->clazz.node_free( node, cache );
|
||||
node = next;
|
||||
}
|
||||
cache->buckets[i] = NULL;
|
||||
}
|
||||
ftc_cache_resize( cache );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
ftc_cache_done( FTC_Cache cache )
|
||||
{
|
||||
if ( cache->memory )
|
||||
{
|
||||
FT_Memory memory = cache->memory;
|
||||
|
||||
|
||||
FTC_Cache_Clear( cache );
|
||||
|
||||
FT_FREE( cache->buckets );
|
||||
cache->mask = 0;
|
||||
cache->p = 0;
|
||||
cache->slack = 0;
|
||||
|
||||
cache->memory = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_Cache_Done( FTC_Cache cache )
|
||||
{
|
||||
ftc_cache_done( cache );
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ftc_cache_add( FTC_Cache cache,
|
||||
FT_PtrDist hash,
|
||||
FTC_Node node )
|
||||
{
|
||||
node->hash = hash;
|
||||
node->cache_index = (FT_UInt16)cache->index;
|
||||
node->ref_count = 0;
|
||||
|
||||
ftc_node_hash_link( node, cache );
|
||||
ftc_node_mru_link( node, cache->manager );
|
||||
|
||||
{
|
||||
FTC_Manager manager = cache->manager;
|
||||
|
||||
|
||||
manager->cur_weight += cache->clazz.node_weight( node, cache );
|
||||
|
||||
if ( manager->cur_weight >= manager->max_weight )
|
||||
{
|
||||
node->ref_count++;
|
||||
FTC_Manager_Compress( manager );
|
||||
node->ref_count--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_Cache_NewNode( FTC_Cache cache,
|
||||
FT_PtrDist hash,
|
||||
FT_Pointer query,
|
||||
FTC_Node *anode )
|
||||
{
|
||||
FT_Error error;
|
||||
FTC_Node node;
|
||||
|
||||
|
||||
/*
|
||||
* We use the FTC_CACHE_TRYLOOP macros to support out-of-memory
|
||||
* errors (OOM) correctly, i.e., by flushing the cache progressively
|
||||
* in order to make more room.
|
||||
*/
|
||||
|
||||
FTC_CACHE_TRYLOOP( cache )
|
||||
{
|
||||
error = cache->clazz.node_new( &node, query, cache );
|
||||
}
|
||||
FTC_CACHE_TRYLOOP_END( NULL );
|
||||
|
||||
if ( error )
|
||||
node = NULL;
|
||||
else
|
||||
{
|
||||
/* don't assume that the cache has the same number of buckets, since
|
||||
* our allocation request might have triggered global cache flushing
|
||||
*/
|
||||
ftc_cache_add( cache, hash, node );
|
||||
}
|
||||
|
||||
*anode = node;
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
#ifndef FTC_INLINE
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_Cache_Lookup( FTC_Cache cache,
|
||||
FT_PtrDist hash,
|
||||
FT_Pointer query,
|
||||
FTC_Node *anode )
|
||||
{
|
||||
FTC_Node* bucket;
|
||||
FTC_Node* pnode;
|
||||
FTC_Node node;
|
||||
FT_Error error = FTC_Err_Ok;
|
||||
FT_Bool list_changed = FALSE;
|
||||
|
||||
FTC_Node_CompareFunc compare = cache->clazz.node_compare;
|
||||
|
||||
|
||||
if ( cache == NULL || anode == NULL )
|
||||
return FTC_Err_Invalid_Argument;
|
||||
|
||||
/* Go to the `top' node of the list sharing same masked hash */
|
||||
bucket = pnode = FTC_NODE__TOP_FOR_HASH( cache, hash );
|
||||
|
||||
/* Lookup a node with exactly same hash and queried properties. */
|
||||
/* NOTE: _nodcomp() may change the linked list to reduce memory. */
|
||||
for (;;)
|
||||
{
|
||||
node = *pnode;
|
||||
if ( node == NULL )
|
||||
goto NewNode;
|
||||
|
||||
if ( node->hash == hash &&
|
||||
compare( node, query, cache, &list_changed ) )
|
||||
break;
|
||||
|
||||
pnode = &node->link;
|
||||
}
|
||||
|
||||
if ( list_changed )
|
||||
{
|
||||
/* Update bucket by modified linked list */
|
||||
bucket = pnode = FTC_NODE__TOP_FOR_HASH( cache, hash );
|
||||
|
||||
/* Update pnode by modified linked list */
|
||||
while ( *pnode != node )
|
||||
{
|
||||
if ( *pnode == NULL )
|
||||
{
|
||||
FT_ERROR(( "FTC_Cache_Lookup: oops!!! node missing\n" ));
|
||||
goto NewNode;
|
||||
}
|
||||
else
|
||||
pnode = &((*pnode)->link);
|
||||
}
|
||||
}
|
||||
|
||||
/* Reorder the list to move the found node to the `top' */
|
||||
if ( node != *bucket )
|
||||
{
|
||||
*pnode = node->link;
|
||||
node->link = *bucket;
|
||||
*bucket = node;
|
||||
}
|
||||
|
||||
/* move to head of MRU list */
|
||||
{
|
||||
FTC_Manager manager = cache->manager;
|
||||
|
||||
|
||||
if ( node != manager->nodes_list )
|
||||
ftc_node_mru_up( node, manager );
|
||||
}
|
||||
*anode = node;
|
||||
|
||||
return error;
|
||||
|
||||
NewNode:
|
||||
return FTC_Cache_NewNode( cache, hash, query, anode );
|
||||
}
|
||||
|
||||
#endif /* !FTC_INLINE */
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_Cache_RemoveFaceID( FTC_Cache cache,
|
||||
FTC_FaceID face_id )
|
||||
{
|
||||
FT_UFast i, count;
|
||||
FTC_Manager manager = cache->manager;
|
||||
FTC_Node frees = NULL;
|
||||
|
||||
|
||||
count = cache->p + cache->mask + 1;
|
||||
for ( i = 0; i < count; i++ )
|
||||
{
|
||||
FTC_Node* bucket = cache->buckets + i;
|
||||
FTC_Node* pnode = bucket;
|
||||
|
||||
|
||||
for ( ;; )
|
||||
{
|
||||
FTC_Node node = *pnode;
|
||||
FT_Bool list_changed = FALSE;
|
||||
|
||||
|
||||
if ( node == NULL )
|
||||
break;
|
||||
|
||||
if ( cache->clazz.node_remove_faceid( node, face_id,
|
||||
cache, &list_changed ) )
|
||||
{
|
||||
*pnode = node->link;
|
||||
node->link = frees;
|
||||
frees = node;
|
||||
}
|
||||
else
|
||||
pnode = &node->link;
|
||||
}
|
||||
}
|
||||
|
||||
/* remove all nodes in the free list */
|
||||
while ( frees )
|
||||
{
|
||||
FTC_Node node;
|
||||
|
||||
|
||||
node = frees;
|
||||
frees = node->link;
|
||||
|
||||
manager->cur_weight -= cache->clazz.node_weight( node, cache );
|
||||
ftc_node_mru_unlink( node, manager );
|
||||
|
||||
cache->clazz.node_free( node, cache );
|
||||
|
||||
cache->slack++;
|
||||
}
|
||||
|
||||
ftc_cache_resize( cache );
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
+359
@@ -0,0 +1,359 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftccache.h */
|
||||
/* */
|
||||
/* FreeType internal cache interface (specification). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, */
|
||||
/* 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#ifndef __FTCCACHE_H__
|
||||
#define __FTCCACHE_H__
|
||||
|
||||
|
||||
#include "ftcmru.h"
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
#define _FTC_FACE_ID_HASH( i ) \
|
||||
((FT_PtrDist)(( (FT_PtrDist)(i) >> 3 ) ^ ( (FT_PtrDist)(i) << 7 )))
|
||||
|
||||
/* handle to cache object */
|
||||
typedef struct FTC_CacheRec_* FTC_Cache;
|
||||
|
||||
/* handle to cache class */
|
||||
typedef const struct FTC_CacheClassRec_* FTC_CacheClass;
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** CACHE NODE DEFINITIONS *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Each cache controls one or more cache nodes. Each node is part of */
|
||||
/* the global_lru list of the manager. Its `data' field however is used */
|
||||
/* as a reference count for now. */
|
||||
/* */
|
||||
/* A node can be anything, depending on the type of information held by */
|
||||
/* the cache. It can be an individual glyph image, a set of bitmaps */
|
||||
/* glyphs for a given size, some metrics, etc. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
/* structure size should be 20 bytes on 32-bits machines */
|
||||
typedef struct FTC_NodeRec_
|
||||
{
|
||||
FTC_MruNodeRec mru; /* circular mru list pointer */
|
||||
FTC_Node link; /* used for hashing */
|
||||
FT_PtrDist hash; /* used for hashing too */
|
||||
FT_UShort cache_index; /* index of cache the node belongs to */
|
||||
FT_Short ref_count; /* reference count for this node */
|
||||
|
||||
} FTC_NodeRec;
|
||||
|
||||
|
||||
#define FTC_NODE( x ) ( (FTC_Node)(x) )
|
||||
#define FTC_NODE_P( x ) ( (FTC_Node*)(x) )
|
||||
|
||||
#define FTC_NODE__NEXT( x ) FTC_NODE( (x)->mru.next )
|
||||
#define FTC_NODE__PREV( x ) FTC_NODE( (x)->mru.prev )
|
||||
|
||||
#ifdef FTC_INLINE
|
||||
#define FTC_NODE__TOP_FOR_HASH( cache, hash ) \
|
||||
( ( cache )->buckets + \
|
||||
( ( ( ( hash ) & ( cache )->mask ) < ( cache )->p ) \
|
||||
? ( ( hash ) & ( ( cache )->mask * 2 + 1 ) ) \
|
||||
: ( ( hash ) & ( cache )->mask ) ) )
|
||||
#else
|
||||
FT_LOCAL( FTC_Node* )
|
||||
ftc_get_top_node_for_hash( FTC_Cache cache,
|
||||
FT_PtrDist hash );
|
||||
#define FTC_NODE__TOP_FOR_HASH( cache, hash ) \
|
||||
ftc_get_top_node_for_hash( ( cache ), ( hash ) )
|
||||
#endif
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
FT_BASE( void )
|
||||
ftc_node_destroy( FTC_Node node,
|
||||
FTC_Manager manager );
|
||||
#endif
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** CACHE DEFINITIONS *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
/* initialize a new cache node */
|
||||
typedef FT_Error
|
||||
(*FTC_Node_NewFunc)( FTC_Node *pnode,
|
||||
FT_Pointer query,
|
||||
FTC_Cache cache );
|
||||
|
||||
typedef FT_Offset
|
||||
(*FTC_Node_WeightFunc)( FTC_Node node,
|
||||
FTC_Cache cache );
|
||||
|
||||
/* compare a node to a given key pair */
|
||||
typedef FT_Bool
|
||||
(*FTC_Node_CompareFunc)( FTC_Node node,
|
||||
FT_Pointer key,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed );
|
||||
|
||||
|
||||
typedef void
|
||||
(*FTC_Node_FreeFunc)( FTC_Node node,
|
||||
FTC_Cache cache );
|
||||
|
||||
typedef FT_Error
|
||||
(*FTC_Cache_InitFunc)( FTC_Cache cache );
|
||||
|
||||
typedef void
|
||||
(*FTC_Cache_DoneFunc)( FTC_Cache cache );
|
||||
|
||||
|
||||
typedef struct FTC_CacheClassRec_
|
||||
{
|
||||
FTC_Node_NewFunc node_new;
|
||||
FTC_Node_WeightFunc node_weight;
|
||||
FTC_Node_CompareFunc node_compare;
|
||||
FTC_Node_CompareFunc node_remove_faceid;
|
||||
FTC_Node_FreeFunc node_free;
|
||||
|
||||
FT_Offset cache_size;
|
||||
FTC_Cache_InitFunc cache_init;
|
||||
FTC_Cache_DoneFunc cache_done;
|
||||
|
||||
} FTC_CacheClassRec;
|
||||
|
||||
|
||||
/* each cache really implements a dynamic hash table to manage its nodes */
|
||||
typedef struct FTC_CacheRec_
|
||||
{
|
||||
FT_UFast p;
|
||||
FT_UFast mask;
|
||||
FT_Long slack;
|
||||
FTC_Node* buckets;
|
||||
|
||||
FTC_CacheClassRec clazz; /* local copy, for speed */
|
||||
|
||||
FTC_Manager manager;
|
||||
FT_Memory memory;
|
||||
FT_UInt index; /* in manager's table */
|
||||
|
||||
FTC_CacheClass org_class; /* original class pointer */
|
||||
|
||||
} FTC_CacheRec;
|
||||
|
||||
|
||||
#define FTC_CACHE( x ) ( (FTC_Cache)(x) )
|
||||
#define FTC_CACHE_P( x ) ( (FTC_Cache*)(x) )
|
||||
|
||||
|
||||
/* default cache initialize */
|
||||
FT_LOCAL( FT_Error )
|
||||
FTC_Cache_Init( FTC_Cache cache );
|
||||
|
||||
/* default cache finalizer */
|
||||
FT_LOCAL( void )
|
||||
FTC_Cache_Done( FTC_Cache cache );
|
||||
|
||||
/* Call this function to look up the cache. If no corresponding
|
||||
* node is found, a new one is automatically created. This function
|
||||
* is capable of flushing the cache adequately to make room for the
|
||||
* new cache object.
|
||||
*/
|
||||
|
||||
#ifndef FTC_INLINE
|
||||
FT_LOCAL( FT_Error )
|
||||
FTC_Cache_Lookup( FTC_Cache cache,
|
||||
FT_PtrDist hash,
|
||||
FT_Pointer query,
|
||||
FTC_Node *anode );
|
||||
#endif
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
FTC_Cache_NewNode( FTC_Cache cache,
|
||||
FT_PtrDist hash,
|
||||
FT_Pointer query,
|
||||
FTC_Node *anode );
|
||||
|
||||
/* Remove all nodes that relate to a given face_id. This is useful
|
||||
* when un-installing fonts. Note that if a cache node relates to
|
||||
* the face_id but is locked (i.e., has `ref_count > 0'), the node
|
||||
* will _not_ be destroyed, but its internal face_id reference will
|
||||
* be modified.
|
||||
*
|
||||
* The final result will be that the node will never come back
|
||||
* in further lookup requests, and will be flushed on demand from
|
||||
* the cache normally when its reference count reaches 0.
|
||||
*/
|
||||
FT_LOCAL( void )
|
||||
FTC_Cache_RemoveFaceID( FTC_Cache cache,
|
||||
FTC_FaceID face_id );
|
||||
|
||||
|
||||
#ifdef FTC_INLINE
|
||||
|
||||
#define FTC_CACHE_LOOKUP_CMP( cache, nodecmp, hash, query, node, error ) \
|
||||
FT_BEGIN_STMNT \
|
||||
FTC_Node *_bucket, *_pnode, _node; \
|
||||
FTC_Cache _cache = FTC_CACHE(cache); \
|
||||
FT_PtrDist _hash = (FT_PtrDist)(hash); \
|
||||
FTC_Node_CompareFunc _nodcomp = (FTC_Node_CompareFunc)(nodecmp); \
|
||||
FT_Bool _list_changed = FALSE; \
|
||||
\
|
||||
\
|
||||
error = FTC_Err_Ok; \
|
||||
node = NULL; \
|
||||
\
|
||||
/* Go to the `top' node of the list sharing same masked hash */ \
|
||||
_bucket = _pnode = FTC_NODE__TOP_FOR_HASH( _cache, _hash ); \
|
||||
\
|
||||
/* Look up a node with identical hash and queried properties. */ \
|
||||
/* NOTE: _nodcomp() may change the linked list to reduce memory. */ \
|
||||
for (;;) \
|
||||
{ \
|
||||
_node = *_pnode; \
|
||||
if ( _node == NULL ) \
|
||||
goto _NewNode; \
|
||||
\
|
||||
if ( _node->hash == _hash && \
|
||||
_nodcomp( _node, query, _cache, &_list_changed ) ) \
|
||||
break; \
|
||||
\
|
||||
_pnode = &_node->link; \
|
||||
} \
|
||||
\
|
||||
if ( _list_changed ) \
|
||||
{ \
|
||||
/* Update _bucket by possibly modified linked list */ \
|
||||
_bucket = _pnode = FTC_NODE__TOP_FOR_HASH( _cache, _hash ); \
|
||||
\
|
||||
/* Update _pnode by possibly modified linked list */ \
|
||||
while ( *_pnode != _node ) \
|
||||
{ \
|
||||
if ( *_pnode == NULL ) \
|
||||
{ \
|
||||
FT_ERROR(( "FTC_CACHE_LOOKUP_CMP: oops!!! node missing\n" )); \
|
||||
goto _NewNode; \
|
||||
} \
|
||||
else \
|
||||
_pnode = &((*_pnode)->link); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
/* Reorder the list to move the found node to the `top' */ \
|
||||
if ( _node != *_bucket ) \
|
||||
{ \
|
||||
*_pnode = _node->link; \
|
||||
_node->link = *_bucket; \
|
||||
*_bucket = _node; \
|
||||
} \
|
||||
\
|
||||
/* Update MRU list */ \
|
||||
{ \
|
||||
FTC_Manager _manager = _cache->manager; \
|
||||
void* _nl = &_manager->nodes_list; \
|
||||
\
|
||||
\
|
||||
if ( _node != _manager->nodes_list ) \
|
||||
FTC_MruNode_Up( (FTC_MruNode*)_nl, \
|
||||
(FTC_MruNode)_node ); \
|
||||
} \
|
||||
goto _Ok; \
|
||||
\
|
||||
_NewNode: \
|
||||
error = FTC_Cache_NewNode( _cache, _hash, query, &_node ); \
|
||||
\
|
||||
_Ok: \
|
||||
node = _node; \
|
||||
FT_END_STMNT
|
||||
|
||||
#else /* !FTC_INLINE */
|
||||
|
||||
#define FTC_CACHE_LOOKUP_CMP( cache, nodecmp, hash, query, node, error ) \
|
||||
FT_BEGIN_STMNT \
|
||||
error = FTC_Cache_Lookup( FTC_CACHE( cache ), hash, query, \
|
||||
(FTC_Node*)&(node) ); \
|
||||
FT_END_STMNT
|
||||
|
||||
#endif /* !FTC_INLINE */
|
||||
|
||||
|
||||
/*
|
||||
* This macro, together with FTC_CACHE_TRYLOOP_END, defines a retry
|
||||
* loop to flush the cache repeatedly in case of memory overflows.
|
||||
*
|
||||
* It is used when creating a new cache node, or within a lookup
|
||||
* that needs to allocate data (e.g. the sbit cache lookup).
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* {
|
||||
* FTC_CACHE_TRYLOOP( cache )
|
||||
* error = load_data( ... );
|
||||
* FTC_CACHE_TRYLOOP_END()
|
||||
* }
|
||||
*
|
||||
*/
|
||||
#define FTC_CACHE_TRYLOOP( cache ) \
|
||||
{ \
|
||||
FTC_Manager _try_manager = FTC_CACHE( cache )->manager; \
|
||||
FT_UInt _try_count = 4; \
|
||||
\
|
||||
\
|
||||
for (;;) \
|
||||
{ \
|
||||
FT_UInt _try_done;
|
||||
|
||||
|
||||
#define FTC_CACHE_TRYLOOP_END( list_changed ) \
|
||||
if ( !error || error != FTC_Err_Out_Of_Memory ) \
|
||||
break; \
|
||||
\
|
||||
_try_done = FTC_Manager_FlushN( _try_manager, _try_count ); \
|
||||
if ( _try_done > 0 && ( list_changed ) ) \
|
||||
*(FT_Bool*)( list_changed ) = TRUE; \
|
||||
\
|
||||
if ( _try_done == 0 ) \
|
||||
break; \
|
||||
\
|
||||
if ( _try_done == _try_count ) \
|
||||
{ \
|
||||
_try_count *= 2; \
|
||||
if ( _try_count < _try_done || \
|
||||
_try_count > _try_manager->num_nodes ) \
|
||||
_try_count = _try_manager->num_nodes; \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
|
||||
#endif /* __FTCCACHE_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftccback.h */
|
||||
/* */
|
||||
/* Callback functions of the caching sub-system (specification only). */
|
||||
/* */
|
||||
/* Copyright 2004, 2005, 2006, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
#ifndef __FTCCBACK_H__
|
||||
#define __FTCCBACK_H__
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CACHE_H
|
||||
#include "ftcmru.h"
|
||||
#include "ftcimage.h"
|
||||
#include "ftcmanag.h"
|
||||
#include "ftcglyph.h"
|
||||
#include "ftcsbits.h"
|
||||
|
||||
|
||||
FT_LOCAL( void )
|
||||
ftc_inode_free( FTC_Node inode,
|
||||
FTC_Cache cache );
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
ftc_inode_new( FTC_Node *pinode,
|
||||
FT_Pointer gquery,
|
||||
FTC_Cache cache );
|
||||
|
||||
FT_LOCAL( FT_Offset )
|
||||
ftc_inode_weight( FTC_Node inode,
|
||||
FTC_Cache cache );
|
||||
|
||||
|
||||
FT_LOCAL( void )
|
||||
ftc_snode_free( FTC_Node snode,
|
||||
FTC_Cache cache );
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
ftc_snode_new( FTC_Node *psnode,
|
||||
FT_Pointer gquery,
|
||||
FTC_Cache cache );
|
||||
|
||||
FT_LOCAL( FT_Offset )
|
||||
ftc_snode_weight( FTC_Node snode,
|
||||
FTC_Cache cache );
|
||||
|
||||
FT_LOCAL( FT_Bool )
|
||||
ftc_snode_compare( FTC_Node snode,
|
||||
FT_Pointer gquery,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed );
|
||||
|
||||
|
||||
FT_LOCAL( FT_Bool )
|
||||
ftc_gnode_compare( FTC_Node gnode,
|
||||
FT_Pointer gquery,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed );
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
ftc_gcache_init( FTC_Cache cache );
|
||||
|
||||
FT_LOCAL( void )
|
||||
ftc_gcache_done( FTC_Cache cache );
|
||||
|
||||
|
||||
FT_LOCAL( FT_Error )
|
||||
ftc_cache_init( FTC_Cache cache );
|
||||
|
||||
FT_LOCAL( void )
|
||||
ftc_cache_done( FTC_Cache cache );
|
||||
|
||||
#ifndef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
FT_LOCAL( void )
|
||||
ftc_node_destroy( FTC_Node node,
|
||||
FTC_Manager manager );
|
||||
#endif
|
||||
|
||||
#endif /* __FTCCBACK_H__ */
|
||||
|
||||
/* END */
|
||||
Vendored
+438
@@ -0,0 +1,438 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftccmap.c */
|
||||
/* */
|
||||
/* FreeType CharMap cache (body) */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */
|
||||
/* 2010, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_FREETYPE_H
|
||||
#include FT_CACHE_H
|
||||
#include "ftcmanag.h"
|
||||
#include FT_INTERNAL_MEMORY_H
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
|
||||
#include "ftccback.h"
|
||||
#include "ftcerror.h"
|
||||
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_cache
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
typedef enum FTC_OldCMapType_
|
||||
{
|
||||
FTC_OLD_CMAP_BY_INDEX = 0,
|
||||
FTC_OLD_CMAP_BY_ENCODING = 1,
|
||||
FTC_OLD_CMAP_BY_ID = 2
|
||||
|
||||
} FTC_OldCMapType;
|
||||
|
||||
|
||||
typedef struct FTC_OldCMapIdRec_
|
||||
{
|
||||
FT_UInt platform;
|
||||
FT_UInt encoding;
|
||||
|
||||
} FTC_OldCMapIdRec, *FTC_OldCMapId;
|
||||
|
||||
|
||||
typedef struct FTC_OldCMapDescRec_
|
||||
{
|
||||
FTC_FaceID face_id;
|
||||
FTC_OldCMapType type;
|
||||
|
||||
union
|
||||
{
|
||||
FT_UInt index;
|
||||
FT_Encoding encoding;
|
||||
FTC_OldCMapIdRec id;
|
||||
|
||||
} u;
|
||||
|
||||
} FTC_OldCMapDescRec, *FTC_OldCMapDesc;
|
||||
|
||||
#endif /* FT_CONFIG_OLD_INTERNALS */
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Each FTC_CMapNode contains a simple array to map a range of character */
|
||||
/* codes to equivalent glyph indices. */
|
||||
/* */
|
||||
/* For now, the implementation is very basic: Each node maps a range of */
|
||||
/* 128 consecutive character codes to their corresponding glyph indices. */
|
||||
/* */
|
||||
/* We could do more complex things, but I don't think it is really very */
|
||||
/* useful. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/* number of glyph indices / character code per node */
|
||||
#define FTC_CMAP_INDICES_MAX 128
|
||||
|
||||
/* compute a query/node hash */
|
||||
#define FTC_CMAP_HASH( faceid, index, charcode ) \
|
||||
( _FTC_FACE_ID_HASH( faceid ) + 211 * (index) + \
|
||||
( (charcode) / FTC_CMAP_INDICES_MAX ) )
|
||||
|
||||
/* the charmap query */
|
||||
typedef struct FTC_CMapQueryRec_
|
||||
{
|
||||
FTC_FaceID face_id;
|
||||
FT_UInt cmap_index;
|
||||
FT_UInt32 char_code;
|
||||
|
||||
} FTC_CMapQueryRec, *FTC_CMapQuery;
|
||||
|
||||
#define FTC_CMAP_QUERY( x ) ((FTC_CMapQuery)(x))
|
||||
#define FTC_CMAP_QUERY_HASH( x ) \
|
||||
FTC_CMAP_HASH( (x)->face_id, (x)->cmap_index, (x)->char_code )
|
||||
|
||||
/* the cmap cache node */
|
||||
typedef struct FTC_CMapNodeRec_
|
||||
{
|
||||
FTC_NodeRec node;
|
||||
FTC_FaceID face_id;
|
||||
FT_UInt cmap_index;
|
||||
FT_UInt32 first; /* first character in node */
|
||||
FT_UInt16 indices[FTC_CMAP_INDICES_MAX]; /* array of glyph indices */
|
||||
|
||||
} FTC_CMapNodeRec, *FTC_CMapNode;
|
||||
|
||||
#define FTC_CMAP_NODE( x ) ( (FTC_CMapNode)( x ) )
|
||||
#define FTC_CMAP_NODE_HASH( x ) \
|
||||
FTC_CMAP_HASH( (x)->face_id, (x)->cmap_index, (x)->first )
|
||||
|
||||
/* if (indices[n] == FTC_CMAP_UNKNOWN), we assume that the corresponding */
|
||||
/* glyph indices haven't been queried through FT_Get_Glyph_Index() yet */
|
||||
#define FTC_CMAP_UNKNOWN ( (FT_UInt16)-1 )
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** CHARMAP NODES *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
ftc_cmap_node_free( FTC_Node ftcnode,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FTC_CMapNode node = (FTC_CMapNode)ftcnode;
|
||||
FT_Memory memory = cache->memory;
|
||||
|
||||
|
||||
FT_FREE( node );
|
||||
}
|
||||
|
||||
|
||||
/* initialize a new cmap node */
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ftc_cmap_node_new( FTC_Node *ftcanode,
|
||||
FT_Pointer ftcquery,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FTC_CMapNode *anode = (FTC_CMapNode*)ftcanode;
|
||||
FTC_CMapQuery query = (FTC_CMapQuery)ftcquery;
|
||||
FT_Error error;
|
||||
FT_Memory memory = cache->memory;
|
||||
FTC_CMapNode node = NULL;
|
||||
FT_UInt nn;
|
||||
|
||||
|
||||
if ( !FT_NEW( node ) )
|
||||
{
|
||||
node->face_id = query->face_id;
|
||||
node->cmap_index = query->cmap_index;
|
||||
node->first = (query->char_code / FTC_CMAP_INDICES_MAX) *
|
||||
FTC_CMAP_INDICES_MAX;
|
||||
|
||||
for ( nn = 0; nn < FTC_CMAP_INDICES_MAX; nn++ )
|
||||
node->indices[nn] = FTC_CMAP_UNKNOWN;
|
||||
}
|
||||
|
||||
*anode = node;
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* compute the weight of a given cmap node */
|
||||
FT_CALLBACK_DEF( FT_Offset )
|
||||
ftc_cmap_node_weight( FTC_Node cnode,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FT_UNUSED( cnode );
|
||||
FT_UNUSED( cache );
|
||||
|
||||
return sizeof ( *cnode );
|
||||
}
|
||||
|
||||
|
||||
/* compare a cmap node to a given query */
|
||||
FT_CALLBACK_DEF( FT_Bool )
|
||||
ftc_cmap_node_compare( FTC_Node ftcnode,
|
||||
FT_Pointer ftcquery,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed )
|
||||
{
|
||||
FTC_CMapNode node = (FTC_CMapNode)ftcnode;
|
||||
FTC_CMapQuery query = (FTC_CMapQuery)ftcquery;
|
||||
FT_UNUSED( cache );
|
||||
|
||||
|
||||
if ( list_changed )
|
||||
*list_changed = FALSE;
|
||||
if ( node->face_id == query->face_id &&
|
||||
node->cmap_index == query->cmap_index )
|
||||
{
|
||||
FT_UInt32 offset = (FT_UInt32)( query->char_code - node->first );
|
||||
|
||||
|
||||
return FT_BOOL( offset < FTC_CMAP_INDICES_MAX );
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Bool )
|
||||
ftc_cmap_node_remove_faceid( FTC_Node ftcnode,
|
||||
FT_Pointer ftcface_id,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed )
|
||||
{
|
||||
FTC_CMapNode node = (FTC_CMapNode)ftcnode;
|
||||
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
|
||||
FT_UNUSED( cache );
|
||||
|
||||
|
||||
if ( list_changed )
|
||||
*list_changed = FALSE;
|
||||
return FT_BOOL( node->face_id == face_id );
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** GLYPH IMAGE CACHE *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FTC_CacheClassRec ftc_cmap_cache_class =
|
||||
{
|
||||
ftc_cmap_node_new,
|
||||
ftc_cmap_node_weight,
|
||||
ftc_cmap_node_compare,
|
||||
ftc_cmap_node_remove_faceid,
|
||||
ftc_cmap_node_free,
|
||||
|
||||
sizeof ( FTC_CacheRec ),
|
||||
ftc_cache_init,
|
||||
ftc_cache_done,
|
||||
};
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_CMapCache_New( FTC_Manager manager,
|
||||
FTC_CMapCache *acache )
|
||||
{
|
||||
return FTC_Manager_RegisterCache( manager,
|
||||
&ftc_cmap_cache_class,
|
||||
FTC_CACHE_P( acache ) );
|
||||
}
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
/*
|
||||
* Unfortunately, it is not possible to support binary backwards
|
||||
* compatibility in the cmap cache. The FTC_CMapCache_Lookup signature
|
||||
* changes were too deep, and there is no clever hackish way to detect
|
||||
* what kind of structure we are being passed.
|
||||
*
|
||||
* On the other hand it seems that no production code is using this
|
||||
* function on Unix distributions.
|
||||
*/
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_UInt )
|
||||
FTC_CMapCache_Lookup( FTC_CMapCache cmap_cache,
|
||||
FTC_FaceID face_id,
|
||||
FT_Int cmap_index,
|
||||
FT_UInt32 char_code )
|
||||
{
|
||||
FTC_Cache cache = FTC_CACHE( cmap_cache );
|
||||
FTC_CMapQueryRec query;
|
||||
FTC_Node node;
|
||||
FT_Error error;
|
||||
FT_UInt gindex = 0;
|
||||
FT_PtrDist hash;
|
||||
FT_Int no_cmap_change = 0;
|
||||
|
||||
|
||||
if ( cmap_index < 0 )
|
||||
{
|
||||
/* Treat a negative cmap index as a special value, meaning that you */
|
||||
/* don't want to change the FT_Face's character map through this */
|
||||
/* call. This can be useful if the face requester callback already */
|
||||
/* sets the face's charmap to the appropriate value. */
|
||||
|
||||
no_cmap_change = 1;
|
||||
cmap_index = 0;
|
||||
}
|
||||
|
||||
if ( !cache )
|
||||
{
|
||||
FT_TRACE0(( "FTC_CMapCache_Lookup: bad arguments, returning 0\n" ));
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
/*
|
||||
* If cmap_index is greater than the maximum number of cachable
|
||||
* charmaps, we assume the request is from a legacy rogue client
|
||||
* using old internal header. See include/config/ftoption.h.
|
||||
*/
|
||||
if ( cmap_index > FT_MAX_CHARMAP_CACHEABLE && !no_cmap_change )
|
||||
{
|
||||
FTC_OldCMapDesc desc = (FTC_OldCMapDesc) face_id;
|
||||
|
||||
|
||||
char_code = (FT_UInt32)cmap_index;
|
||||
query.face_id = desc->face_id;
|
||||
|
||||
|
||||
switch ( desc->type )
|
||||
{
|
||||
case FTC_OLD_CMAP_BY_INDEX:
|
||||
query.cmap_index = desc->u.index;
|
||||
query.char_code = (FT_UInt32)cmap_index;
|
||||
break;
|
||||
|
||||
case FTC_OLD_CMAP_BY_ENCODING:
|
||||
{
|
||||
FT_Face face;
|
||||
|
||||
|
||||
error = FTC_Manager_LookupFace( cache->manager, desc->face_id,
|
||||
&face );
|
||||
if ( error )
|
||||
return 0;
|
||||
|
||||
FT_Select_Charmap( face, desc->u.encoding );
|
||||
|
||||
return FT_Get_Char_Index( face, char_code );
|
||||
}
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
{
|
||||
query.face_id = face_id;
|
||||
query.cmap_index = (FT_UInt)cmap_index;
|
||||
query.char_code = char_code;
|
||||
}
|
||||
|
||||
hash = FTC_CMAP_HASH( face_id, cmap_index, char_code );
|
||||
|
||||
#if 1
|
||||
FTC_CACHE_LOOKUP_CMP( cache, ftc_cmap_node_compare, hash, &query,
|
||||
node, error );
|
||||
#else
|
||||
error = FTC_Cache_Lookup( cache, hash, &query, &node );
|
||||
#endif
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
FT_ASSERT( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first ) <
|
||||
FTC_CMAP_INDICES_MAX );
|
||||
|
||||
/* something rotten can happen with rogue clients */
|
||||
if ( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first >=
|
||||
FTC_CMAP_INDICES_MAX ) )
|
||||
return 0; /* XXX: should return appropriate error */
|
||||
|
||||
gindex = FTC_CMAP_NODE( node )->indices[char_code -
|
||||
FTC_CMAP_NODE( node )->first];
|
||||
if ( gindex == FTC_CMAP_UNKNOWN )
|
||||
{
|
||||
FT_Face face;
|
||||
|
||||
|
||||
gindex = 0;
|
||||
|
||||
error = FTC_Manager_LookupFace( cache->manager,
|
||||
FTC_CMAP_NODE( node )->face_id,
|
||||
&face );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
#ifdef FT_MAX_CHARMAP_CACHEABLE
|
||||
/* something rotten can happen with rogue clients */
|
||||
if ( cmap_index > FT_MAX_CHARMAP_CACHEABLE )
|
||||
return 0; /* XXX: should return appropriate error */
|
||||
#endif
|
||||
|
||||
if ( (FT_UInt)cmap_index < (FT_UInt)face->num_charmaps )
|
||||
{
|
||||
FT_CharMap old, cmap = NULL;
|
||||
|
||||
|
||||
old = face->charmap;
|
||||
cmap = face->charmaps[cmap_index];
|
||||
|
||||
if ( old != cmap && !no_cmap_change )
|
||||
FT_Set_Charmap( face, cmap );
|
||||
|
||||
gindex = FT_Get_Char_Index( face, char_code );
|
||||
|
||||
if ( old != cmap && !no_cmap_change )
|
||||
FT_Set_Charmap( face, old );
|
||||
}
|
||||
|
||||
FTC_CMAP_NODE( node )->indices[char_code -
|
||||
FTC_CMAP_NODE( node )->first]
|
||||
= (FT_UShort)gindex;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return gindex;
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcerror.h */
|
||||
/* */
|
||||
/* Caching sub-system error codes (specification only). */
|
||||
/* */
|
||||
/* Copyright 2001 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 is used to define the caching sub-system error enumeration */
|
||||
/* constants. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
#ifndef __FTCERROR_H__
|
||||
#define __FTCERROR_H__
|
||||
|
||||
#include FT_MODULE_ERRORS_H
|
||||
|
||||
#undef __FTERRORS_H__
|
||||
|
||||
#define FT_ERR_PREFIX FTC_Err_
|
||||
#define FT_ERR_BASE FT_Mod_Err_Cache
|
||||
|
||||
#include FT_ERRORS_H
|
||||
|
||||
#endif /* __FTCERROR_H__ */
|
||||
|
||||
/* END */
|
||||
+219
@@ -0,0 +1,219 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcglyph.c */
|
||||
/* */
|
||||
/* FreeType Glyph Image (FT_Glyph) cache (body). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2003, 2004, 2006, 2009, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_CACHE_H
|
||||
#include "ftcglyph.h"
|
||||
#include FT_ERRORS_H
|
||||
|
||||
#include "ftccback.h"
|
||||
#include "ftcerror.h"
|
||||
|
||||
|
||||
/* create a new chunk node, setting its cache index and ref count */
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_GNode_Init( FTC_GNode gnode,
|
||||
FT_UInt gindex,
|
||||
FTC_Family family )
|
||||
{
|
||||
gnode->family = family;
|
||||
gnode->gindex = gindex;
|
||||
family->num_nodes++;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_GNode_UnselectFamily( FTC_GNode gnode,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FTC_Family family = gnode->family;
|
||||
|
||||
|
||||
gnode->family = NULL;
|
||||
if ( family && --family->num_nodes == 0 )
|
||||
FTC_FAMILY_FREE( family, cache );
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_GNode_Done( FTC_GNode gnode,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
/* finalize the node */
|
||||
gnode->gindex = 0;
|
||||
|
||||
FTC_GNode_UnselectFamily( gnode, cache );
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Bool )
|
||||
ftc_gnode_compare( FTC_Node ftcgnode,
|
||||
FT_Pointer ftcgquery,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed )
|
||||
{
|
||||
FTC_GNode gnode = (FTC_GNode)ftcgnode;
|
||||
FTC_GQuery gquery = (FTC_GQuery)ftcgquery;
|
||||
FT_UNUSED( cache );
|
||||
|
||||
|
||||
if ( list_changed )
|
||||
*list_changed = FALSE;
|
||||
return FT_BOOL( gnode->family == gquery->family &&
|
||||
gnode->gindex == gquery->gindex );
|
||||
}
|
||||
|
||||
|
||||
#ifdef FTC_INLINE
|
||||
|
||||
FT_LOCAL_DEF( FT_Bool )
|
||||
FTC_GNode_Compare( FTC_GNode gnode,
|
||||
FTC_GQuery gquery,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed )
|
||||
{
|
||||
return ftc_gnode_compare( FTC_NODE( gnode ), gquery,
|
||||
cache, list_changed );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** CHUNK SETS *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_Family_Init( FTC_Family family,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FTC_GCacheClass clazz = FTC_CACHE__GCACHE_CLASS( cache );
|
||||
|
||||
|
||||
family->clazz = clazz->family_class;
|
||||
family->num_nodes = 0;
|
||||
family->cache = cache;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
ftc_gcache_init( FTC_Cache ftccache )
|
||||
{
|
||||
FTC_GCache cache = (FTC_GCache)ftccache;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
error = FTC_Cache_Init( FTC_CACHE( cache ) );
|
||||
if ( !error )
|
||||
{
|
||||
FTC_GCacheClass clazz = (FTC_GCacheClass)FTC_CACHE( cache )->org_class;
|
||||
|
||||
FTC_MruList_Init( &cache->families,
|
||||
clazz->family_class,
|
||||
0, /* no maximum here! */
|
||||
cache,
|
||||
FTC_CACHE( cache )->memory );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_GCache_Init( FTC_GCache cache )
|
||||
{
|
||||
return ftc_gcache_init( FTC_CACHE( cache ) );
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
ftc_gcache_done( FTC_Cache ftccache )
|
||||
{
|
||||
FTC_GCache cache = (FTC_GCache)ftccache;
|
||||
|
||||
|
||||
FTC_Cache_Done( (FTC_Cache)cache );
|
||||
FTC_MruList_Done( &cache->families );
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_GCache_Done( FTC_GCache cache )
|
||||
{
|
||||
ftc_gcache_done( FTC_CACHE( cache ) );
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_GCache_New( FTC_Manager manager,
|
||||
FTC_GCacheClass clazz,
|
||||
FTC_GCache *acache )
|
||||
{
|
||||
return FTC_Manager_RegisterCache( manager, (FTC_CacheClass)clazz,
|
||||
(FTC_Cache*)acache );
|
||||
}
|
||||
|
||||
|
||||
#ifndef FTC_INLINE
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_GCache_Lookup( FTC_GCache cache,
|
||||
FT_PtrDist hash,
|
||||
FT_UInt gindex,
|
||||
FTC_GQuery query,
|
||||
FTC_Node *anode )
|
||||
{
|
||||
FT_Error error;
|
||||
|
||||
|
||||
query->gindex = gindex;
|
||||
|
||||
FTC_MRULIST_LOOKUP( &cache->families, query, query->family, error );
|
||||
if ( !error )
|
||||
{
|
||||
FTC_Family family = query->family;
|
||||
|
||||
|
||||
/* prevent the family from being destroyed too early when an */
|
||||
/* out-of-memory condition occurs during glyph node initialization. */
|
||||
family->num_nodes++;
|
||||
|
||||
error = FTC_Cache_Lookup( FTC_CACHE( cache ), hash, query, anode );
|
||||
|
||||
if ( --family->num_nodes == 0 )
|
||||
FTC_FAMILY_FREE( family, cache );
|
||||
}
|
||||
return error;
|
||||
}
|
||||
|
||||
#endif /* !FTC_INLINE */
|
||||
|
||||
|
||||
/* END */
|
||||
+329
@@ -0,0 +1,329 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcglyph.h */
|
||||
/* */
|
||||
/* FreeType abstract glyph cache (specification). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2003, 2004, 2006, 2007, 2011 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* FTC_GCache is an _abstract_ cache object optimized to store glyph
|
||||
* data. It works as follows:
|
||||
*
|
||||
* - It manages FTC_GNode objects. Each one of them can hold one or more
|
||||
* glyph `items'. Item types are not specified in the FTC_GCache but
|
||||
* in classes that extend it.
|
||||
*
|
||||
* - Glyph attributes, like face ID, character size, render mode, etc.,
|
||||
* can be grouped into abstract `glyph families'. This avoids storing
|
||||
* the attributes within the FTC_GCache, since it is likely that many
|
||||
* FTC_GNodes will belong to the same family in typical uses.
|
||||
*
|
||||
* - Each FTC_GNode is thus an FTC_Node with two additional fields:
|
||||
*
|
||||
* * gindex: A glyph index, or the first index in a glyph range.
|
||||
* * family: A pointer to a glyph `family'.
|
||||
*
|
||||
* - Family types are not fully specific in the FTC_Family type, but
|
||||
* by classes that extend it.
|
||||
*
|
||||
* Note that both FTC_ImageCache and FTC_SBitCache extend FTC_GCache.
|
||||
* They share an FTC_Family sub-class called FTC_BasicFamily which is
|
||||
* used to store the following data: face ID, pixel/point sizes, load
|
||||
* flags. For more details see the file `src/cache/ftcbasic.c'.
|
||||
*
|
||||
* Client applications can extend FTC_GNode with their own FTC_GNode
|
||||
* and FTC_Family sub-classes to implement more complex caches (e.g.,
|
||||
* handling automatic synthesis, like obliquing & emboldening, colored
|
||||
* glyphs, etc.).
|
||||
*
|
||||
* See also the FTC_ICache & FTC_SCache classes in `ftcimage.h' and
|
||||
* `ftcsbits.h', which both extend FTC_GCache with additional
|
||||
* optimizations.
|
||||
*
|
||||
* A typical FTC_GCache implementation must provide at least the
|
||||
* following:
|
||||
*
|
||||
* - FTC_GNode sub-class, e.g. MyNode, with relevant methods:
|
||||
* my_node_new (must call FTC_GNode_Init)
|
||||
* my_node_free (must call FTC_GNode_Done)
|
||||
* my_node_compare (must call FTC_GNode_Compare)
|
||||
* my_node_remove_faceid (must call ftc_gnode_unselect in case
|
||||
* of match)
|
||||
*
|
||||
* - FTC_Family sub-class, e.g. MyFamily, with relevant methods:
|
||||
* my_family_compare
|
||||
* my_family_init
|
||||
* my_family_reset (optional)
|
||||
* my_family_done
|
||||
*
|
||||
* - FTC_GQuery sub-class, e.g. MyQuery, to hold cache-specific query
|
||||
* data.
|
||||
*
|
||||
* - Constant structures for a FTC_GNodeClass.
|
||||
*
|
||||
* - MyCacheNew() can be implemented easily as a call to the convenience
|
||||
* function FTC_GCache_New.
|
||||
*
|
||||
* - MyCacheLookup with a call to FTC_GCache_Lookup. This function will
|
||||
* automatically:
|
||||
*
|
||||
* - Search for the corresponding family in the cache, or create
|
||||
* a new one if necessary. Put it in FTC_GQUERY(myquery).family
|
||||
*
|
||||
* - Call FTC_Cache_Lookup.
|
||||
*
|
||||
* If it returns NULL, you should create a new node, then call
|
||||
* ftc_cache_add as usual.
|
||||
*/
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Important: The functions defined in this file are only used to */
|
||||
/* implement an abstract glyph cache class. You need to */
|
||||
/* provide additional logic to implement a complete cache. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/********* *********/
|
||||
/********* WARNING, THIS IS BETA CODE. *********/
|
||||
/********* *********/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#ifndef __FTCGLYPH_H__
|
||||
#define __FTCGLYPH_H__
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include "ftcmanag.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/*
|
||||
* We can group glyphs into `families'. Each family correspond to a
|
||||
* given face ID, character size, transform, etc.
|
||||
*
|
||||
* Families are implemented as MRU list nodes. They are
|
||||
* reference-counted.
|
||||
*/
|
||||
|
||||
typedef struct FTC_FamilyRec_
|
||||
{
|
||||
FTC_MruNodeRec mrunode;
|
||||
FT_UInt num_nodes; /* current number of nodes in this family */
|
||||
FTC_Cache cache;
|
||||
FTC_MruListClass clazz;
|
||||
|
||||
} FTC_FamilyRec, *FTC_Family;
|
||||
|
||||
#define FTC_FAMILY(x) ( (FTC_Family)(x) )
|
||||
#define FTC_FAMILY_P(x) ( (FTC_Family*)(x) )
|
||||
|
||||
|
||||
typedef struct FTC_GNodeRec_
|
||||
{
|
||||
FTC_NodeRec node;
|
||||
FTC_Family family;
|
||||
FT_UInt gindex;
|
||||
|
||||
} FTC_GNodeRec, *FTC_GNode;
|
||||
|
||||
#define FTC_GNODE( x ) ( (FTC_GNode)(x) )
|
||||
#define FTC_GNODE_P( x ) ( (FTC_GNode*)(x) )
|
||||
|
||||
|
||||
typedef struct FTC_GQueryRec_
|
||||
{
|
||||
FT_UInt gindex;
|
||||
FTC_Family family;
|
||||
|
||||
} FTC_GQueryRec, *FTC_GQuery;
|
||||
|
||||
#define FTC_GQUERY( x ) ( (FTC_GQuery)(x) )
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* These functions are exported so that they can be called from */
|
||||
/* user-provided cache classes; otherwise, they are really part of the */
|
||||
/* cache sub-system internals. */
|
||||
/* */
|
||||
|
||||
/* must be called by derived FTC_Node_InitFunc routines */
|
||||
FT_LOCAL( void )
|
||||
FTC_GNode_Init( FTC_GNode node,
|
||||
FT_UInt gindex, /* glyph index for node */
|
||||
FTC_Family family );
|
||||
|
||||
#ifdef FTC_INLINE
|
||||
|
||||
/* returns TRUE iff the query's glyph index correspond to the node; */
|
||||
/* this assumes that the `family' and `hash' fields of the query are */
|
||||
/* already correctly set */
|
||||
FT_LOCAL( FT_Bool )
|
||||
FTC_GNode_Compare( FTC_GNode gnode,
|
||||
FTC_GQuery gquery,
|
||||
FTC_Cache cache,
|
||||
FT_Bool* list_changed );
|
||||
|
||||
#endif
|
||||
|
||||
/* call this function to clear a node's family -- this is necessary */
|
||||
/* to implement the `node_remove_faceid' cache method correctly */
|
||||
FT_LOCAL( void )
|
||||
FTC_GNode_UnselectFamily( FTC_GNode gnode,
|
||||
FTC_Cache cache );
|
||||
|
||||
/* must be called by derived FTC_Node_DoneFunc routines */
|
||||
FT_LOCAL( void )
|
||||
FTC_GNode_Done( FTC_GNode node,
|
||||
FTC_Cache cache );
|
||||
|
||||
|
||||
FT_LOCAL( void )
|
||||
FTC_Family_Init( FTC_Family family,
|
||||
FTC_Cache cache );
|
||||
|
||||
typedef struct FTC_GCacheRec_
|
||||
{
|
||||
FTC_CacheRec cache;
|
||||
FTC_MruListRec families;
|
||||
|
||||
} FTC_GCacheRec, *FTC_GCache;
|
||||
|
||||
#define FTC_GCACHE( x ) ((FTC_GCache)(x))
|
||||
|
||||
|
||||
#if 0
|
||||
/* can be used as @FTC_Cache_InitFunc */
|
||||
FT_LOCAL( FT_Error )
|
||||
FTC_GCache_Init( FTC_GCache cache );
|
||||
#endif
|
||||
|
||||
|
||||
#if 0
|
||||
/* can be used as @FTC_Cache_DoneFunc */
|
||||
FT_LOCAL( void )
|
||||
FTC_GCache_Done( FTC_GCache cache );
|
||||
#endif
|
||||
|
||||
|
||||
/* the glyph cache class adds fields for the family implementation */
|
||||
typedef struct FTC_GCacheClassRec_
|
||||
{
|
||||
FTC_CacheClassRec clazz;
|
||||
FTC_MruListClass family_class;
|
||||
|
||||
} FTC_GCacheClassRec;
|
||||
|
||||
typedef const FTC_GCacheClassRec* FTC_GCacheClass;
|
||||
|
||||
#define FTC_GCACHE_CLASS( x ) ((FTC_GCacheClass)(x))
|
||||
|
||||
#define FTC_CACHE__GCACHE_CLASS( x ) \
|
||||
FTC_GCACHE_CLASS( FTC_CACHE(x)->org_class )
|
||||
#define FTC_CACHE__FAMILY_CLASS( x ) \
|
||||
( (FTC_MruListClass)FTC_CACHE__GCACHE_CLASS( x )->family_class )
|
||||
|
||||
|
||||
/* convenience function; use it instead of FTC_Manager_Register_Cache */
|
||||
FT_LOCAL( FT_Error )
|
||||
FTC_GCache_New( FTC_Manager manager,
|
||||
FTC_GCacheClass clazz,
|
||||
FTC_GCache *acache );
|
||||
|
||||
#ifndef FTC_INLINE
|
||||
FT_LOCAL( FT_Error )
|
||||
FTC_GCache_Lookup( FTC_GCache cache,
|
||||
FT_PtrDist hash,
|
||||
FT_UInt gindex,
|
||||
FTC_GQuery query,
|
||||
FTC_Node *anode );
|
||||
#endif
|
||||
|
||||
|
||||
/* */
|
||||
|
||||
|
||||
#define FTC_FAMILY_FREE( family, cache ) \
|
||||
FTC_MruList_Remove( &FTC_GCACHE((cache))->families, \
|
||||
(FTC_MruNode)(family) )
|
||||
|
||||
|
||||
#ifdef FTC_INLINE
|
||||
|
||||
#define FTC_GCACHE_LOOKUP_CMP( cache, famcmp, nodecmp, hash, \
|
||||
gindex, query, node, error ) \
|
||||
FT_BEGIN_STMNT \
|
||||
FTC_GCache _gcache = FTC_GCACHE( cache ); \
|
||||
FTC_GQuery _gquery = (FTC_GQuery)( query ); \
|
||||
FTC_MruNode_CompareFunc _fcompare = (FTC_MruNode_CompareFunc)(famcmp); \
|
||||
FTC_MruNode _mrunode; \
|
||||
\
|
||||
\
|
||||
_gquery->gindex = (gindex); \
|
||||
\
|
||||
FTC_MRULIST_LOOKUP_CMP( &_gcache->families, _gquery, _fcompare, \
|
||||
_mrunode, error ); \
|
||||
_gquery->family = FTC_FAMILY( _mrunode ); \
|
||||
if ( !error ) \
|
||||
{ \
|
||||
FTC_Family _gqfamily = _gquery->family; \
|
||||
\
|
||||
\
|
||||
_gqfamily->num_nodes++; \
|
||||
\
|
||||
FTC_CACHE_LOOKUP_CMP( cache, nodecmp, hash, query, node, error ); \
|
||||
\
|
||||
if ( --_gqfamily->num_nodes == 0 ) \
|
||||
FTC_FAMILY_FREE( _gqfamily, _gcache ); \
|
||||
} \
|
||||
FT_END_STMNT
|
||||
/* */
|
||||
|
||||
#else /* !FTC_INLINE */
|
||||
|
||||
#define FTC_GCACHE_LOOKUP_CMP( cache, famcmp, nodecmp, hash, \
|
||||
gindex, query, node, error ) \
|
||||
FT_BEGIN_STMNT \
|
||||
\
|
||||
error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, \
|
||||
FTC_GQUERY( query ), &node ); \
|
||||
\
|
||||
FT_END_STMNT
|
||||
|
||||
#endif /* !FTC_INLINE */
|
||||
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
|
||||
#endif /* __FTCGLYPH_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
+163
@@ -0,0 +1,163 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcimage.c */
|
||||
/* */
|
||||
/* FreeType Image cache (body). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2003, 2004, 2006, 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CACHE_H
|
||||
#include "ftcimage.h"
|
||||
#include FT_INTERNAL_MEMORY_H
|
||||
|
||||
#include "ftccback.h"
|
||||
#include "ftcerror.h"
|
||||
|
||||
|
||||
/* finalize a given glyph image node */
|
||||
FT_LOCAL_DEF( void )
|
||||
ftc_inode_free( FTC_Node ftcinode,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FTC_INode inode = (FTC_INode)ftcinode;
|
||||
FT_Memory memory = cache->memory;
|
||||
|
||||
|
||||
if ( inode->glyph )
|
||||
{
|
||||
FT_Done_Glyph( inode->glyph );
|
||||
inode->glyph = NULL;
|
||||
}
|
||||
|
||||
FTC_GNode_Done( FTC_GNODE( inode ), cache );
|
||||
FT_FREE( inode );
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_INode_Free( FTC_INode inode,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
ftc_inode_free( FTC_NODE( inode ), cache );
|
||||
}
|
||||
|
||||
|
||||
/* initialize a new glyph image node */
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_INode_New( FTC_INode *pinode,
|
||||
FTC_GQuery gquery,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FT_Memory memory = cache->memory;
|
||||
FT_Error error;
|
||||
FTC_INode inode = NULL;
|
||||
|
||||
|
||||
if ( !FT_NEW( inode ) )
|
||||
{
|
||||
FTC_GNode gnode = FTC_GNODE( inode );
|
||||
FTC_Family family = gquery->family;
|
||||
FT_UInt gindex = gquery->gindex;
|
||||
FTC_IFamilyClass clazz = FTC_CACHE__IFAMILY_CLASS( cache );
|
||||
|
||||
|
||||
/* initialize its inner fields */
|
||||
FTC_GNode_Init( gnode, gindex, family );
|
||||
|
||||
/* we will now load the glyph image */
|
||||
error = clazz->family_load_glyph( family, gindex, cache,
|
||||
&inode->glyph );
|
||||
if ( error )
|
||||
{
|
||||
FTC_INode_Free( inode, cache );
|
||||
inode = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
*pinode = inode;
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
ftc_inode_new( FTC_Node *ftcpinode,
|
||||
FT_Pointer ftcgquery,
|
||||
FTC_Cache cache )
|
||||
{
|
||||
FTC_INode *pinode = (FTC_INode*)ftcpinode;
|
||||
FTC_GQuery gquery = (FTC_GQuery)ftcgquery;
|
||||
|
||||
|
||||
return FTC_INode_New( pinode, gquery, cache );
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_Offset )
|
||||
ftc_inode_weight( FTC_Node ftcinode,
|
||||
FTC_Cache ftccache )
|
||||
{
|
||||
FTC_INode inode = (FTC_INode)ftcinode;
|
||||
FT_Offset size = 0;
|
||||
FT_Glyph glyph = inode->glyph;
|
||||
|
||||
FT_UNUSED( ftccache );
|
||||
|
||||
|
||||
switch ( glyph->format )
|
||||
{
|
||||
case FT_GLYPH_FORMAT_BITMAP:
|
||||
{
|
||||
FT_BitmapGlyph bitg;
|
||||
|
||||
|
||||
bitg = (FT_BitmapGlyph)glyph;
|
||||
size = bitg->bitmap.rows * ft_labs( bitg->bitmap.pitch ) +
|
||||
sizeof ( *bitg );
|
||||
}
|
||||
break;
|
||||
|
||||
case FT_GLYPH_FORMAT_OUTLINE:
|
||||
{
|
||||
FT_OutlineGlyph outg;
|
||||
|
||||
|
||||
outg = (FT_OutlineGlyph)glyph;
|
||||
size = outg->outline.n_points *
|
||||
( sizeof ( FT_Vector ) + sizeof ( FT_Byte ) ) +
|
||||
outg->outline.n_contours * sizeof ( FT_Short ) +
|
||||
sizeof ( *outg );
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
;
|
||||
}
|
||||
|
||||
size += sizeof ( *inode );
|
||||
return size;
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
FT_LOCAL_DEF( FT_Offset )
|
||||
FTC_INode_Weight( FTC_INode inode )
|
||||
{
|
||||
return ftc_inode_weight( FTC_NODE( inode ), NULL );
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
/* END */
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcimage.h */
|
||||
/* */
|
||||
/* FreeType Generic Image cache (specification) */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2002, 2003, 2006 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
/*
|
||||
* FTC_ICache is an _abstract_ cache used to store a single FT_Glyph
|
||||
* image per cache node.
|
||||
*
|
||||
* FTC_ICache extends FTC_GCache. For an implementation example,
|
||||
* see FTC_ImageCache in `src/cache/ftbasic.c'.
|
||||
*/
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* Each image cache really manages FT_Glyph objects. */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#ifndef __FTCIMAGE_H__
|
||||
#define __FTCIMAGE_H__
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CACHE_H
|
||||
#include "ftcglyph.h"
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/* the FT_Glyph image node type - we store only 1 glyph per node */
|
||||
typedef struct FTC_INodeRec_
|
||||
{
|
||||
FTC_GNodeRec gnode;
|
||||
FT_Glyph glyph;
|
||||
|
||||
} FTC_INodeRec, *FTC_INode;
|
||||
|
||||
#define FTC_INODE( x ) ( (FTC_INode)( x ) )
|
||||
#define FTC_INODE_GINDEX( x ) FTC_GNODE(x)->gindex
|
||||
#define FTC_INODE_FAMILY( x ) FTC_GNODE(x)->family
|
||||
|
||||
typedef FT_Error
|
||||
(*FTC_IFamily_LoadGlyphFunc)( FTC_Family family,
|
||||
FT_UInt gindex,
|
||||
FTC_Cache cache,
|
||||
FT_Glyph *aglyph );
|
||||
|
||||
typedef struct FTC_IFamilyClassRec_
|
||||
{
|
||||
FTC_MruListClassRec clazz;
|
||||
FTC_IFamily_LoadGlyphFunc family_load_glyph;
|
||||
|
||||
} FTC_IFamilyClassRec;
|
||||
|
||||
typedef const FTC_IFamilyClassRec* FTC_IFamilyClass;
|
||||
|
||||
#define FTC_IFAMILY_CLASS( x ) ((FTC_IFamilyClass)(x))
|
||||
|
||||
#define FTC_CACHE__IFAMILY_CLASS( x ) \
|
||||
FTC_IFAMILY_CLASS( FTC_CACHE__GCACHE_CLASS(x)->family_class )
|
||||
|
||||
|
||||
/* can be used as a @FTC_Node_FreeFunc */
|
||||
FT_LOCAL( void )
|
||||
FTC_INode_Free( FTC_INode inode,
|
||||
FTC_Cache cache );
|
||||
|
||||
/* Can be used as @FTC_Node_NewFunc. `gquery.index' and `gquery.family'
|
||||
* must be set correctly. This function will call the `family_load_glyph'
|
||||
* method to load the FT_Glyph into the cache node.
|
||||
*/
|
||||
FT_LOCAL( FT_Error )
|
||||
FTC_INode_New( FTC_INode *pinode,
|
||||
FTC_GQuery gquery,
|
||||
FTC_Cache cache );
|
||||
|
||||
#if 0
|
||||
/* can be used as @FTC_Node_WeightFunc */
|
||||
FT_LOCAL( FT_ULong )
|
||||
FTC_INode_Weight( FTC_INode inode );
|
||||
#endif
|
||||
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __FTCIMAGE_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
+743
@@ -0,0 +1,743 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcmanag.c */
|
||||
/* */
|
||||
/* FreeType Cache Manager (body). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009, 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CACHE_H
|
||||
#include "ftcmanag.h"
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_SIZES_H
|
||||
|
||||
#include "ftccback.h"
|
||||
#include "ftcerror.h"
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_PIC
|
||||
#error "cache system does not support PIC yet"
|
||||
#endif
|
||||
|
||||
|
||||
#undef FT_COMPONENT
|
||||
#define FT_COMPONENT trace_cache
|
||||
|
||||
#define FTC_LRU_GET_MANAGER( lru ) ( (FTC_Manager)(lru)->user_data )
|
||||
|
||||
|
||||
static FT_Error
|
||||
ftc_scaler_lookup_size( FTC_Manager manager,
|
||||
FTC_Scaler scaler,
|
||||
FT_Size *asize )
|
||||
{
|
||||
FT_Face face;
|
||||
FT_Size size = NULL;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
error = FTC_Manager_LookupFace( manager, scaler->face_id, &face );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
error = FT_New_Size( face, &size );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
FT_Activate_Size( size );
|
||||
|
||||
if ( scaler->pixel )
|
||||
error = FT_Set_Pixel_Sizes( face, scaler->width, scaler->height );
|
||||
else
|
||||
error = FT_Set_Char_Size( face, scaler->width, scaler->height,
|
||||
scaler->x_res, scaler->y_res );
|
||||
if ( error )
|
||||
{
|
||||
FT_Done_Size( size );
|
||||
size = NULL;
|
||||
}
|
||||
|
||||
Exit:
|
||||
*asize = size;
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
typedef struct FTC_SizeNodeRec_
|
||||
{
|
||||
FTC_MruNodeRec node;
|
||||
FT_Size size;
|
||||
FTC_ScalerRec scaler;
|
||||
|
||||
} FTC_SizeNodeRec, *FTC_SizeNode;
|
||||
|
||||
#define FTC_SIZE_NODE( x ) ( (FTC_SizeNode)( x ) )
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
ftc_size_node_done( FTC_MruNode ftcnode,
|
||||
FT_Pointer data )
|
||||
{
|
||||
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
|
||||
FT_Size size = node->size;
|
||||
FT_UNUSED( data );
|
||||
|
||||
|
||||
if ( size )
|
||||
FT_Done_Size( size );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Bool )
|
||||
ftc_size_node_compare( FTC_MruNode ftcnode,
|
||||
FT_Pointer ftcscaler )
|
||||
{
|
||||
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
|
||||
FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
|
||||
FTC_Scaler scaler0 = &node->scaler;
|
||||
|
||||
|
||||
if ( FTC_SCALER_COMPARE( scaler0, scaler ) )
|
||||
{
|
||||
FT_Activate_Size( node->size );
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ftc_size_node_init( FTC_MruNode ftcnode,
|
||||
FT_Pointer ftcscaler,
|
||||
FT_Pointer ftcmanager )
|
||||
{
|
||||
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
|
||||
FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
|
||||
FTC_Manager manager = (FTC_Manager)ftcmanager;
|
||||
|
||||
|
||||
node->scaler = scaler[0];
|
||||
|
||||
return ftc_scaler_lookup_size( manager, scaler, &node->size );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ftc_size_node_reset( FTC_MruNode ftcnode,
|
||||
FT_Pointer ftcscaler,
|
||||
FT_Pointer ftcmanager )
|
||||
{
|
||||
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
|
||||
FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
|
||||
FTC_Manager manager = (FTC_Manager)ftcmanager;
|
||||
|
||||
|
||||
FT_Done_Size( node->size );
|
||||
|
||||
node->scaler = scaler[0];
|
||||
|
||||
return ftc_scaler_lookup_size( manager, scaler, &node->size );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FTC_MruListClassRec ftc_size_list_class =
|
||||
{
|
||||
sizeof ( FTC_SizeNodeRec ),
|
||||
ftc_size_node_compare,
|
||||
ftc_size_node_init,
|
||||
ftc_size_node_reset,
|
||||
ftc_size_node_done
|
||||
};
|
||||
|
||||
|
||||
/* helper function used by ftc_face_node_done */
|
||||
static FT_Bool
|
||||
ftc_size_node_compare_faceid( FTC_MruNode ftcnode,
|
||||
FT_Pointer ftcface_id )
|
||||
{
|
||||
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
|
||||
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
|
||||
|
||||
|
||||
return FT_BOOL( node->scaler.face_id == face_id );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_Manager_LookupSize( FTC_Manager manager,
|
||||
FTC_Scaler scaler,
|
||||
FT_Size *asize )
|
||||
{
|
||||
FT_Error error;
|
||||
FTC_MruNode mrunode;
|
||||
|
||||
|
||||
if ( asize == NULL )
|
||||
return FTC_Err_Invalid_Argument;
|
||||
|
||||
*asize = NULL;
|
||||
|
||||
if ( !manager )
|
||||
return FTC_Err_Invalid_Cache_Handle;
|
||||
|
||||
#ifdef FTC_INLINE
|
||||
|
||||
FTC_MRULIST_LOOKUP_CMP( &manager->sizes, scaler, ftc_size_node_compare,
|
||||
mrunode, error );
|
||||
|
||||
#else
|
||||
error = FTC_MruList_Lookup( &manager->sizes, scaler, &mrunode );
|
||||
#endif
|
||||
|
||||
if ( !error )
|
||||
*asize = FTC_SIZE_NODE( mrunode )->size;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** FACE MRU IMPLEMENTATION *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
typedef struct FTC_FaceNodeRec_
|
||||
{
|
||||
FTC_MruNodeRec node;
|
||||
FTC_FaceID face_id;
|
||||
FT_Face face;
|
||||
|
||||
} FTC_FaceNodeRec, *FTC_FaceNode;
|
||||
|
||||
#define FTC_FACE_NODE( x ) ( ( FTC_FaceNode )( x ) )
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Error )
|
||||
ftc_face_node_init( FTC_MruNode ftcnode,
|
||||
FT_Pointer ftcface_id,
|
||||
FT_Pointer ftcmanager )
|
||||
{
|
||||
FTC_FaceNode node = (FTC_FaceNode)ftcnode;
|
||||
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
|
||||
FTC_Manager manager = (FTC_Manager)ftcmanager;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
node->face_id = face_id;
|
||||
|
||||
error = manager->request_face( face_id,
|
||||
manager->library,
|
||||
manager->request_data,
|
||||
&node->face );
|
||||
if ( !error )
|
||||
{
|
||||
/* destroy initial size object; it will be re-created later */
|
||||
if ( node->face->size )
|
||||
FT_Done_Size( node->face->size );
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( void )
|
||||
ftc_face_node_done( FTC_MruNode ftcnode,
|
||||
FT_Pointer ftcmanager )
|
||||
{
|
||||
FTC_FaceNode node = (FTC_FaceNode)ftcnode;
|
||||
FTC_Manager manager = (FTC_Manager)ftcmanager;
|
||||
|
||||
|
||||
/* we must begin by removing all scalers for the target face */
|
||||
/* from the manager's list */
|
||||
FTC_MruList_RemoveSelection( &manager->sizes,
|
||||
ftc_size_node_compare_faceid,
|
||||
node->face_id );
|
||||
|
||||
/* all right, we can discard the face now */
|
||||
FT_Done_Face( node->face );
|
||||
node->face = NULL;
|
||||
node->face_id = NULL;
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_DEF( FT_Bool )
|
||||
ftc_face_node_compare( FTC_MruNode ftcnode,
|
||||
FT_Pointer ftcface_id )
|
||||
{
|
||||
FTC_FaceNode node = (FTC_FaceNode)ftcnode;
|
||||
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
|
||||
|
||||
|
||||
return FT_BOOL( node->face_id == face_id );
|
||||
}
|
||||
|
||||
|
||||
FT_CALLBACK_TABLE_DEF
|
||||
const FTC_MruListClassRec ftc_face_list_class =
|
||||
{
|
||||
sizeof ( FTC_FaceNodeRec),
|
||||
|
||||
ftc_face_node_compare,
|
||||
ftc_face_node_init,
|
||||
0, /* FTC_MruNode_ResetFunc */
|
||||
ftc_face_node_done
|
||||
};
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_Manager_LookupFace( FTC_Manager manager,
|
||||
FTC_FaceID face_id,
|
||||
FT_Face *aface )
|
||||
{
|
||||
FT_Error error;
|
||||
FTC_MruNode mrunode;
|
||||
|
||||
|
||||
if ( aface == NULL )
|
||||
return FTC_Err_Invalid_Argument;
|
||||
|
||||
*aface = NULL;
|
||||
|
||||
if ( !manager )
|
||||
return FTC_Err_Invalid_Cache_Handle;
|
||||
|
||||
/* we break encapsulation for the sake of speed */
|
||||
#ifdef FTC_INLINE
|
||||
|
||||
FTC_MRULIST_LOOKUP_CMP( &manager->faces, face_id, ftc_face_node_compare,
|
||||
mrunode, error );
|
||||
|
||||
#else
|
||||
error = FTC_MruList_Lookup( &manager->faces, face_id, &mrunode );
|
||||
#endif
|
||||
|
||||
if ( !error )
|
||||
*aface = FTC_FACE_NODE( mrunode )->face;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/***** *****/
|
||||
/***** CACHE MANAGER ROUTINES *****/
|
||||
/***** *****/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_Manager_New( FT_Library library,
|
||||
FT_UInt max_faces,
|
||||
FT_UInt max_sizes,
|
||||
FT_ULong max_bytes,
|
||||
FTC_Face_Requester requester,
|
||||
FT_Pointer req_data,
|
||||
FTC_Manager *amanager )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory;
|
||||
FTC_Manager manager = 0;
|
||||
|
||||
|
||||
if ( !library )
|
||||
return FTC_Err_Invalid_Library_Handle;
|
||||
|
||||
memory = library->memory;
|
||||
|
||||
if ( FT_NEW( manager ) )
|
||||
goto Exit;
|
||||
|
||||
if ( max_faces == 0 )
|
||||
max_faces = FTC_MAX_FACES_DEFAULT;
|
||||
|
||||
if ( max_sizes == 0 )
|
||||
max_sizes = FTC_MAX_SIZES_DEFAULT;
|
||||
|
||||
if ( max_bytes == 0 )
|
||||
max_bytes = FTC_MAX_BYTES_DEFAULT;
|
||||
|
||||
manager->library = library;
|
||||
manager->memory = memory;
|
||||
manager->max_weight = max_bytes;
|
||||
|
||||
manager->request_face = requester;
|
||||
manager->request_data = req_data;
|
||||
|
||||
FTC_MruList_Init( &manager->faces,
|
||||
&ftc_face_list_class,
|
||||
max_faces,
|
||||
manager,
|
||||
memory );
|
||||
|
||||
FTC_MruList_Init( &manager->sizes,
|
||||
&ftc_size_list_class,
|
||||
max_sizes,
|
||||
manager,
|
||||
memory );
|
||||
|
||||
*amanager = manager;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FTC_Manager_Done( FTC_Manager manager )
|
||||
{
|
||||
FT_Memory memory;
|
||||
FT_UInt idx;
|
||||
|
||||
|
||||
if ( !manager || !manager->library )
|
||||
return;
|
||||
|
||||
memory = manager->memory;
|
||||
|
||||
/* now discard all caches */
|
||||
for (idx = manager->num_caches; idx-- > 0; )
|
||||
{
|
||||
FTC_Cache cache = manager->caches[idx];
|
||||
|
||||
|
||||
if ( cache )
|
||||
{
|
||||
cache->clazz.cache_done( cache );
|
||||
FT_FREE( cache );
|
||||
manager->caches[idx] = NULL;
|
||||
}
|
||||
}
|
||||
manager->num_caches = 0;
|
||||
|
||||
/* discard faces and sizes */
|
||||
FTC_MruList_Done( &manager->sizes );
|
||||
FTC_MruList_Done( &manager->faces );
|
||||
|
||||
manager->library = NULL;
|
||||
manager->memory = NULL;
|
||||
|
||||
FT_FREE( manager );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FTC_Manager_Reset( FTC_Manager manager )
|
||||
{
|
||||
if ( manager )
|
||||
{
|
||||
FTC_MruList_Reset( &manager->sizes );
|
||||
FTC_MruList_Reset( &manager->faces );
|
||||
}
|
||||
/* XXX: FIXME: flush the caches? */
|
||||
}
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_ERROR
|
||||
|
||||
static void
|
||||
FTC_Manager_Check( FTC_Manager manager )
|
||||
{
|
||||
FTC_Node node, first;
|
||||
|
||||
|
||||
first = manager->nodes_list;
|
||||
|
||||
/* check node weights */
|
||||
if ( first )
|
||||
{
|
||||
FT_ULong weight = 0;
|
||||
|
||||
|
||||
node = first;
|
||||
|
||||
do
|
||||
{
|
||||
FTC_Cache cache = manager->caches[node->cache_index];
|
||||
|
||||
|
||||
if ( (FT_UInt)node->cache_index >= manager->num_caches )
|
||||
FT_TRACE0(( "FTC_Manager_Check: invalid node (cache index = %ld\n",
|
||||
node->cache_index ));
|
||||
else
|
||||
weight += cache->clazz.node_weight( node, cache );
|
||||
|
||||
node = FTC_NODE__NEXT( node );
|
||||
|
||||
} while ( node != first );
|
||||
|
||||
if ( weight != manager->cur_weight )
|
||||
FT_TRACE0(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n",
|
||||
manager->cur_weight, weight ));
|
||||
}
|
||||
|
||||
/* check circular list */
|
||||
if ( first )
|
||||
{
|
||||
FT_UFast count = 0;
|
||||
|
||||
|
||||
node = first;
|
||||
do
|
||||
{
|
||||
count++;
|
||||
node = FTC_NODE__NEXT( node );
|
||||
|
||||
} while ( node != first );
|
||||
|
||||
if ( count != manager->num_nodes )
|
||||
FT_TRACE0(( "FTC_Manager_Check:"
|
||||
" invalid cache node count %d instead of %d\n",
|
||||
manager->num_nodes, count ));
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* FT_DEBUG_ERROR */
|
||||
|
||||
|
||||
/* `Compress' the manager's data, i.e., get rid of old cache nodes */
|
||||
/* that are not referenced anymore in order to limit the total */
|
||||
/* memory used by the cache. */
|
||||
|
||||
/* documentation is in ftcmanag.h */
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_Manager_Compress( FTC_Manager manager )
|
||||
{
|
||||
FTC_Node node, first;
|
||||
|
||||
|
||||
if ( !manager )
|
||||
return;
|
||||
|
||||
first = manager->nodes_list;
|
||||
|
||||
#ifdef FT_DEBUG_ERROR
|
||||
FTC_Manager_Check( manager );
|
||||
|
||||
FT_TRACE0(( "compressing, weight = %ld, max = %ld, nodes = %d\n",
|
||||
manager->cur_weight, manager->max_weight,
|
||||
manager->num_nodes ));
|
||||
#endif
|
||||
|
||||
if ( manager->cur_weight < manager->max_weight || first == NULL )
|
||||
return;
|
||||
|
||||
/* go to last node -- it's a circular list */
|
||||
node = FTC_NODE__PREV( first );
|
||||
do
|
||||
{
|
||||
FTC_Node prev;
|
||||
|
||||
|
||||
prev = ( node == first ) ? NULL : FTC_NODE__PREV( node );
|
||||
|
||||
if ( node->ref_count <= 0 )
|
||||
ftc_node_destroy( node, manager );
|
||||
|
||||
node = prev;
|
||||
|
||||
} while ( node && manager->cur_weight > manager->max_weight );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcmanag.h */
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_Manager_RegisterCache( FTC_Manager manager,
|
||||
FTC_CacheClass clazz,
|
||||
FTC_Cache *acache )
|
||||
{
|
||||
FT_Error error = FTC_Err_Invalid_Argument;
|
||||
FTC_Cache cache = NULL;
|
||||
|
||||
|
||||
if ( manager && clazz && acache )
|
||||
{
|
||||
FT_Memory memory = manager->memory;
|
||||
|
||||
|
||||
if ( manager->num_caches >= FTC_MAX_CACHES )
|
||||
{
|
||||
error = FTC_Err_Too_Many_Caches;
|
||||
FT_ERROR(( "FTC_Manager_RegisterCache:"
|
||||
" too many registered caches\n" ));
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( !FT_ALLOC( cache, clazz->cache_size ) )
|
||||
{
|
||||
cache->manager = manager;
|
||||
cache->memory = memory;
|
||||
cache->clazz = clazz[0];
|
||||
cache->org_class = clazz;
|
||||
|
||||
/* THIS IS VERY IMPORTANT! IT WILL WRETCH THE MANAGER */
|
||||
/* IF IT IS NOT SET CORRECTLY */
|
||||
cache->index = manager->num_caches;
|
||||
|
||||
error = clazz->cache_init( cache );
|
||||
if ( error )
|
||||
{
|
||||
clazz->cache_done( cache );
|
||||
FT_FREE( cache );
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
manager->caches[manager->num_caches++] = cache;
|
||||
}
|
||||
}
|
||||
|
||||
Exit:
|
||||
if ( acache )
|
||||
*acache = cache;
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( FT_UInt )
|
||||
FTC_Manager_FlushN( FTC_Manager manager,
|
||||
FT_UInt count )
|
||||
{
|
||||
FTC_Node first = manager->nodes_list;
|
||||
FTC_Node node;
|
||||
FT_UInt result;
|
||||
|
||||
|
||||
/* try to remove `count' nodes from the list */
|
||||
if ( first == NULL ) /* empty list! */
|
||||
return 0;
|
||||
|
||||
/* go to last node - it's a circular list */
|
||||
node = FTC_NODE__PREV(first);
|
||||
for ( result = 0; result < count; )
|
||||
{
|
||||
FTC_Node prev = FTC_NODE__PREV( node );
|
||||
|
||||
|
||||
/* don't touch locked nodes */
|
||||
if ( node->ref_count <= 0 )
|
||||
{
|
||||
ftc_node_destroy( node, manager );
|
||||
result++;
|
||||
}
|
||||
|
||||
if ( node == first )
|
||||
break;
|
||||
|
||||
node = prev;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FTC_Manager_RemoveFaceID( FTC_Manager manager,
|
||||
FTC_FaceID face_id )
|
||||
{
|
||||
FT_UInt nn;
|
||||
|
||||
/* this will remove all FTC_SizeNode that correspond to
|
||||
* the face_id as well
|
||||
*/
|
||||
FTC_MruList_RemoveSelection( &manager->faces,
|
||||
ftc_face_node_compare,
|
||||
face_id );
|
||||
|
||||
for ( nn = 0; nn < manager->num_caches; nn++ )
|
||||
FTC_Cache_RemoveFaceID( manager->caches[nn], face_id );
|
||||
}
|
||||
|
||||
|
||||
/* documentation is in ftcache.h */
|
||||
|
||||
FT_EXPORT_DEF( void )
|
||||
FTC_Node_Unref( FTC_Node node,
|
||||
FTC_Manager manager )
|
||||
{
|
||||
if ( node && (FT_UInt)node->cache_index < manager->num_caches )
|
||||
node->ref_count--;
|
||||
}
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FTC_Manager_Lookup_Face( FTC_Manager manager,
|
||||
FTC_FaceID face_id,
|
||||
FT_Face *aface )
|
||||
{
|
||||
return FTC_Manager_LookupFace( manager, face_id, aface );
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT( FT_Error )
|
||||
FTC_Manager_Lookup_Size( FTC_Manager manager,
|
||||
FTC_Font font,
|
||||
FT_Face *aface,
|
||||
FT_Size *asize )
|
||||
{
|
||||
FTC_ScalerRec scaler;
|
||||
FT_Error error;
|
||||
FT_Size size;
|
||||
FT_Face face;
|
||||
|
||||
|
||||
scaler.face_id = font->face_id;
|
||||
scaler.width = font->pix_width;
|
||||
scaler.height = font->pix_height;
|
||||
scaler.pixel = TRUE;
|
||||
scaler.x_res = 0;
|
||||
scaler.y_res = 0;
|
||||
|
||||
error = FTC_Manager_LookupSize( manager, &scaler, &size );
|
||||
if ( error )
|
||||
{
|
||||
face = NULL;
|
||||
size = NULL;
|
||||
}
|
||||
else
|
||||
face = size->face;
|
||||
|
||||
if ( aface )
|
||||
*aface = face;
|
||||
|
||||
if ( asize )
|
||||
*asize = size;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
|
||||
|
||||
|
||||
/* END */
|
||||
+175
@@ -0,0 +1,175 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcmanag.h */
|
||||
/* */
|
||||
/* FreeType Cache Manager (specification). */
|
||||
/* */
|
||||
/* Copyright 2000-2001, 2003, 2004, 2006, 2010 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* A cache manager is in charge of the following: */
|
||||
/* */
|
||||
/* - Maintain a mapping between generic FTC_FaceIDs and live FT_Face */
|
||||
/* objects. The mapping itself is performed through a user-provided */
|
||||
/* callback. However, the manager maintains a small cache of FT_Face */
|
||||
/* and FT_Size objects in order to speed up things considerably. */
|
||||
/* */
|
||||
/* - Manage one or more cache objects. Each cache is in charge of */
|
||||
/* holding a varying number of `cache nodes'. Each cache node */
|
||||
/* represents a minimal amount of individually accessible cached */
|
||||
/* data. For example, a cache node can be an FT_Glyph image */
|
||||
/* containing a vector outline, or some glyph metrics, or anything */
|
||||
/* else. */
|
||||
/* */
|
||||
/* Each cache node has a certain size in bytes that is added to the */
|
||||
/* total amount of `cache memory' within the manager. */
|
||||
/* */
|
||||
/* All cache nodes are located in a global LRU list, where the oldest */
|
||||
/* node is at the tail of the list. */
|
||||
/* */
|
||||
/* Each node belongs to a single cache, and includes a reference */
|
||||
/* count to avoid destroying it (due to caching). */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/********* *********/
|
||||
/********* WARNING, THIS IS BETA CODE. *********/
|
||||
/********* *********/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#ifndef __FTCMANAG_H__
|
||||
#define __FTCMANAG_H__
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CACHE_H
|
||||
#include "ftcmru.h"
|
||||
#include "ftccache.h"
|
||||
|
||||
|
||||
FT_BEGIN_HEADER
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Section> */
|
||||
/* cache_subsystem */
|
||||
/* */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#define FTC_MAX_FACES_DEFAULT 2
|
||||
#define FTC_MAX_SIZES_DEFAULT 4
|
||||
#define FTC_MAX_BYTES_DEFAULT 200000L /* ~200kByte by default */
|
||||
|
||||
/* maximum number of caches registered in a single manager */
|
||||
#define FTC_MAX_CACHES 16
|
||||
|
||||
|
||||
typedef struct FTC_ManagerRec_
|
||||
{
|
||||
FT_Library library;
|
||||
FT_Memory memory;
|
||||
|
||||
FTC_Node nodes_list;
|
||||
FT_ULong max_weight;
|
||||
FT_ULong cur_weight;
|
||||
FT_UInt num_nodes;
|
||||
|
||||
FTC_Cache caches[FTC_MAX_CACHES];
|
||||
FT_UInt num_caches;
|
||||
|
||||
FTC_MruListRec faces;
|
||||
FTC_MruListRec sizes;
|
||||
|
||||
FT_Pointer request_data;
|
||||
FTC_Face_Requester request_face;
|
||||
|
||||
} FTC_ManagerRec;
|
||||
|
||||
|
||||
/*************************************************************************/
|
||||
/* */
|
||||
/* <Function> */
|
||||
/* FTC_Manager_Compress */
|
||||
/* */
|
||||
/* <Description> */
|
||||
/* This function is used to check the state of the cache manager if */
|
||||
/* its `num_bytes' field is greater than its `max_bytes' field. It */
|
||||
/* will flush as many old cache nodes as possible (ignoring cache */
|
||||
/* nodes with a non-zero reference count). */
|
||||
/* */
|
||||
/* <InOut> */
|
||||
/* manager :: A handle to the cache manager. */
|
||||
/* */
|
||||
/* <Note> */
|
||||
/* Client applications should not call this function directly. It is */
|
||||
/* normally invoked by specific cache implementations. */
|
||||
/* */
|
||||
/* The reason this function is exported is to allow client-specific */
|
||||
/* cache classes. */
|
||||
/* */
|
||||
FT_LOCAL( void )
|
||||
FTC_Manager_Compress( FTC_Manager manager );
|
||||
|
||||
|
||||
/* try to flush `count' old nodes from the cache; return the number
|
||||
* of really flushed nodes
|
||||
*/
|
||||
FT_LOCAL( FT_UInt )
|
||||
FTC_Manager_FlushN( FTC_Manager manager,
|
||||
FT_UInt count );
|
||||
|
||||
|
||||
/* this must be used internally for the moment */
|
||||
FT_LOCAL( FT_Error )
|
||||
FTC_Manager_RegisterCache( FTC_Manager manager,
|
||||
FTC_CacheClass clazz,
|
||||
FTC_Cache *acache );
|
||||
|
||||
/* */
|
||||
|
||||
#define FTC_SCALER_COMPARE( a, b ) \
|
||||
( (a)->face_id == (b)->face_id && \
|
||||
(a)->width == (b)->width && \
|
||||
(a)->height == (b)->height && \
|
||||
((a)->pixel != 0) == ((b)->pixel != 0) && \
|
||||
( (a)->pixel || \
|
||||
( (a)->x_res == (b)->x_res && \
|
||||
(a)->y_res == (b)->y_res ) ) )
|
||||
|
||||
#define FTC_SCALER_HASH( q ) \
|
||||
( _FTC_FACE_ID_HASH( (q)->face_id ) + \
|
||||
(q)->width + (q)->height*7 + \
|
||||
( (q)->pixel ? 0 : ( (q)->x_res*33 ^ (q)->y_res*61 ) ) )
|
||||
|
||||
/* */
|
||||
|
||||
FT_END_HEADER
|
||||
|
||||
#endif /* __FTCMANAG_H__ */
|
||||
|
||||
|
||||
/* END */
|
||||
Vendored
+357
@@ -0,0 +1,357 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftcmru.c */
|
||||
/* */
|
||||
/* FreeType MRU support (body). */
|
||||
/* */
|
||||
/* Copyright 2003, 2004, 2006, 2009 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. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_CACHE_H
|
||||
#include "ftcmru.h"
|
||||
#include FT_INTERNAL_OBJECTS_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
|
||||
#include "ftcerror.h"
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_MruNode_Prepend( FTC_MruNode *plist,
|
||||
FTC_MruNode node )
|
||||
{
|
||||
FTC_MruNode first = *plist;
|
||||
|
||||
|
||||
if ( first )
|
||||
{
|
||||
FTC_MruNode last = first->prev;
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_ERROR
|
||||
{
|
||||
FTC_MruNode cnode = first;
|
||||
|
||||
|
||||
do
|
||||
{
|
||||
if ( cnode == node )
|
||||
{
|
||||
fprintf( stderr, "FTC_MruNode_Prepend: invalid action\n" );
|
||||
exit( 2 );
|
||||
}
|
||||
cnode = cnode->next;
|
||||
|
||||
} while ( cnode != first );
|
||||
}
|
||||
#endif
|
||||
|
||||
first->prev = node;
|
||||
last->next = node;
|
||||
node->next = first;
|
||||
node->prev = last;
|
||||
}
|
||||
else
|
||||
{
|
||||
node->next = node;
|
||||
node->prev = node;
|
||||
}
|
||||
*plist = node;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_MruNode_Up( FTC_MruNode *plist,
|
||||
FTC_MruNode node )
|
||||
{
|
||||
FTC_MruNode first = *plist;
|
||||
|
||||
|
||||
FT_ASSERT( first != NULL );
|
||||
|
||||
if ( first != node )
|
||||
{
|
||||
FTC_MruNode prev, next, last;
|
||||
|
||||
|
||||
#ifdef FT_DEBUG_ERROR
|
||||
{
|
||||
FTC_MruNode cnode = first;
|
||||
do
|
||||
{
|
||||
if ( cnode == node )
|
||||
goto Ok;
|
||||
cnode = cnode->next;
|
||||
|
||||
} while ( cnode != first );
|
||||
|
||||
fprintf( stderr, "FTC_MruNode_Up: invalid action\n" );
|
||||
exit( 2 );
|
||||
Ok:
|
||||
}
|
||||
#endif
|
||||
prev = node->prev;
|
||||
next = node->next;
|
||||
|
||||
prev->next = next;
|
||||
next->prev = prev;
|
||||
|
||||
last = first->prev;
|
||||
|
||||
last->next = node;
|
||||
first->prev = node;
|
||||
|
||||
node->next = first;
|
||||
node->prev = last;
|
||||
|
||||
*plist = node;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_MruNode_Remove( FTC_MruNode *plist,
|
||||
FTC_MruNode node )
|
||||
{
|
||||
FTC_MruNode first = *plist;
|
||||
FTC_MruNode prev, next;
|
||||
|
||||
|
||||
FT_ASSERT( first != NULL );
|
||||
|
||||
#ifdef FT_DEBUG_ERROR
|
||||
{
|
||||
FTC_MruNode cnode = first;
|
||||
|
||||
|
||||
do
|
||||
{
|
||||
if ( cnode == node )
|
||||
goto Ok;
|
||||
cnode = cnode->next;
|
||||
|
||||
} while ( cnode != first );
|
||||
|
||||
fprintf( stderr, "FTC_MruNode_Remove: invalid action\n" );
|
||||
exit( 2 );
|
||||
Ok:
|
||||
}
|
||||
#endif
|
||||
|
||||
prev = node->prev;
|
||||
next = node->next;
|
||||
|
||||
prev->next = next;
|
||||
next->prev = prev;
|
||||
|
||||
if ( node == next )
|
||||
{
|
||||
FT_ASSERT( first == node );
|
||||
FT_ASSERT( prev == node );
|
||||
|
||||
*plist = NULL;
|
||||
}
|
||||
else if ( node == first )
|
||||
*plist = next;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_MruList_Init( FTC_MruList list,
|
||||
FTC_MruListClass clazz,
|
||||
FT_UInt max_nodes,
|
||||
FT_Pointer data,
|
||||
FT_Memory memory )
|
||||
{
|
||||
list->num_nodes = 0;
|
||||
list->max_nodes = max_nodes;
|
||||
list->nodes = NULL;
|
||||
list->clazz = *clazz;
|
||||
list->data = data;
|
||||
list->memory = memory;
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_MruList_Reset( FTC_MruList list )
|
||||
{
|
||||
while ( list->nodes )
|
||||
FTC_MruList_Remove( list, list->nodes );
|
||||
|
||||
FT_ASSERT( list->num_nodes == 0 );
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_MruList_Done( FTC_MruList list )
|
||||
{
|
||||
FTC_MruList_Reset( list );
|
||||
}
|
||||
|
||||
|
||||
#ifndef FTC_INLINE
|
||||
FT_LOCAL_DEF( FTC_MruNode )
|
||||
FTC_MruList_Find( FTC_MruList list,
|
||||
FT_Pointer key )
|
||||
{
|
||||
FTC_MruNode_CompareFunc compare = list->clazz.node_compare;
|
||||
FTC_MruNode first, node;
|
||||
|
||||
|
||||
first = list->nodes;
|
||||
node = NULL;
|
||||
|
||||
if ( first )
|
||||
{
|
||||
node = first;
|
||||
do
|
||||
{
|
||||
if ( compare( node, key ) )
|
||||
{
|
||||
if ( node != first )
|
||||
FTC_MruNode_Up( &list->nodes, node );
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
node = node->next;
|
||||
|
||||
} while ( node != first);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_MruList_New( FTC_MruList list,
|
||||
FT_Pointer key,
|
||||
FTC_MruNode *anode )
|
||||
{
|
||||
FT_Error error;
|
||||
FTC_MruNode node = NULL;
|
||||
FT_Memory memory = list->memory;
|
||||
|
||||
|
||||
if ( list->num_nodes >= list->max_nodes && list->max_nodes > 0 )
|
||||
{
|
||||
node = list->nodes->prev;
|
||||
|
||||
FT_ASSERT( node );
|
||||
|
||||
if ( list->clazz.node_reset )
|
||||
{
|
||||
FTC_MruNode_Up( &list->nodes, node );
|
||||
|
||||
error = list->clazz.node_reset( node, key, list->data );
|
||||
if ( !error )
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
FTC_MruNode_Remove( &list->nodes, node );
|
||||
list->num_nodes--;
|
||||
|
||||
if ( list->clazz.node_done )
|
||||
list->clazz.node_done( node, list->data );
|
||||
}
|
||||
else if ( FT_ALLOC( node, list->clazz.node_size ) )
|
||||
goto Exit;
|
||||
|
||||
error = list->clazz.node_init( node, key, list->data );
|
||||
if ( error )
|
||||
goto Fail;
|
||||
|
||||
FTC_MruNode_Prepend( &list->nodes, node );
|
||||
list->num_nodes++;
|
||||
|
||||
Exit:
|
||||
*anode = node;
|
||||
return error;
|
||||
|
||||
Fail:
|
||||
if ( list->clazz.node_done )
|
||||
list->clazz.node_done( node, list->data );
|
||||
|
||||
FT_FREE( node );
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
|
||||
#ifndef FTC_INLINE
|
||||
FT_LOCAL_DEF( FT_Error )
|
||||
FTC_MruList_Lookup( FTC_MruList list,
|
||||
FT_Pointer key,
|
||||
FTC_MruNode *anode )
|
||||
{
|
||||
FTC_MruNode node;
|
||||
|
||||
|
||||
node = FTC_MruList_Find( list, key );
|
||||
if ( node == NULL )
|
||||
return FTC_MruList_New( list, key, anode );
|
||||
|
||||
*anode = node;
|
||||
return 0;
|
||||
}
|
||||
#endif /* FTC_INLINE */
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_MruList_Remove( FTC_MruList list,
|
||||
FTC_MruNode node )
|
||||
{
|
||||
FTC_MruNode_Remove( &list->nodes, node );
|
||||
list->num_nodes--;
|
||||
|
||||
{
|
||||
FT_Memory memory = list->memory;
|
||||
|
||||
|
||||
if ( list->clazz.node_done )
|
||||
list->clazz.node_done( node, list->data );
|
||||
|
||||
FT_FREE( node );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FT_LOCAL_DEF( void )
|
||||
FTC_MruList_RemoveSelection( FTC_MruList list,
|
||||
FTC_MruNode_CompareFunc selection,
|
||||
FT_Pointer key )
|
||||
{
|
||||
FTC_MruNode first, node, next;
|
||||
|
||||
|
||||
first = list->nodes;
|
||||
while ( first && ( selection == NULL || selection( first, key ) ) )
|
||||
{
|
||||
FTC_MruList_Remove( list, first );
|
||||
first = list->nodes;
|
||||
}
|
||||
|
||||
if ( first )
|
||||
{
|
||||
node = first->next;
|
||||
while ( node != first )
|
||||
{
|
||||
next = node->next;
|
||||
|
||||
if ( selection( node, key ) )
|
||||
FTC_MruList_Remove( list, node );
|
||||
|
||||
node = next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* END */
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user