fries/GRRLIB
1
0
Fork 0
mirror of https://github.com/GRRLIB/GRRLIB.git synced 2024-11-25 16:22:20 +00:00
Code Issues Projects Releases Packages Wiki Activity

[CHG] FreeType updated to version 2.4.10

Browse source
This commit is contained in:
Crayon2000 2012-08-11 01:29:19 +00:00
parent c2771d7886
commit 828beb7cd2
28 changed files with 294 additions and 291 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
GRRLIB/lib/freetype/builds/exports.mk
View file

@ -51,7 +51,7 @@ ifneq ($(EXPORTS_LIST),)
APINAMES_EXE := $(subst /,$(SEP),$(OBJ_DIR)/apinames$(E_BUILD))
$(APINAMES_EXE): $(APINAMES_SRC)
$(CCexe) $(TE)$@ $<
$(CCexe) $(CCexe_CFLAGS) $(TE)$@ $< $(CCexe_LDFLAGS)
.PHONY: symbols_list

4
GRRLIB/lib/freetype/include/freetype/config/ftoption.h
View file

@ -4,7 +4,7 @@
/* */
/* User-selectable configuration macros (specification only). */
/* */
/* Copyright 1996-2011 by */
/* Copyright 1996-2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -669,7 +669,7 @@ FT_BEGIN_HEADER
/*************************************************************************/
/* */
/* T1_MAX_DICT_DEPTH is the maximal depth of nest dictionaries and */
/* T1_MAX_DICT_DEPTH is the maximum depth of nest dictionaries and */
/* arrays in the Type 1 stream (see t1load.c). A minimum of 4 is */
/* required. */
/* */

54
GRRLIB/lib/freetype/include/freetype/freetype.h
View file

@ -16,6 +16,10 @@
/***************************************************************************/
#ifndef __FREETYPE_H__
#define __FREETYPE_H__
#ifndef FT_FREETYPE_H
#error "`ft2build.h' hasn't been included yet!"
#error "Please always use macros to include FreeType header files."
@ -25,10 +29,6 @@
#endif
#ifndef __FREETYPE_H__
#define __FREETYPE_H__
#include <ft2build.h>
#include FT_CONFIG_CONFIG_H
#include FT_ERRORS_H
@ -237,6 +237,10 @@ FT_BEGIN_HEADER
/* If not disabled with @FT_LOAD_NO_HINTING, the values represent */
/* dimensions of the hinted glyph (in case hinting is applicable). */
/* */
/* Stroking a glyph with an outside border does not increase */
/* `horiAdvance' or `vertAdvance'; you have to manually adjust these */
/* values to account for the added width and height. */
/* */
typedef struct FT_Glyph_Metrics_
{
FT_Pos width;
@ -844,8 +848,8 @@ FT_BEGIN_HEADER
/* expressed in font units (see */
/* `units_per_EM'). The box is large enough */
/* to contain any glyph from the font. Thus, */
/* `bbox.yMax' can be seen as the `maximal */
/* ascender', and `bbox.yMin' as the `minimal */
/* `bbox.yMax' can be seen as the `maximum */
/* ascender', and `bbox.yMin' as the `minimum */
/* descender'. Only relevant for scalable */
/* formats. */
/* */
@ -877,13 +881,13 @@ FT_BEGIN_HEADER
/* positive. Only relevant for scalable */
/* formats. */
/* */
/* max_advance_width :: The maximal advance width, in font units, */
/* max_advance_width :: The maximum advance width, in font units, */
/* for all glyphs in this face. This can be */
/* used to make word wrapping computations */
/* faster. Only relevant for scalable */
/* formats. */
/* */
/* max_advance_height :: The maximal advance height, in font units, */
/* max_advance_height :: The maximum advance height, in font units, */
/* for all glyphs in this face. This is only */
/* relevant for vertical layouts, and is set */
/* to `height' for fonts that do not provide */
@ -1338,7 +1342,7 @@ FT_BEGIN_HEADER
/* height :: The height in 26.6 fractional pixels. See */
/* @FT_FaceRec for the details. */
/* */
/* max_advance :: The maximal advance width in 26.6 fractional */
/* max_advance :: The maximum advance width in 26.6 fractional */
/* pixels. See @FT_FaceRec for the details. */
/* */
/* <Note> */
@ -2507,6 +2511,13 @@ FT_BEGIN_HEADER
* Besides deciding which hinter to use, you can also decide which
* hinting algorithm to use. See @FT_LOAD_TARGET_XXX for details.
*
* Note that the auto-hinter needs a valid Unicode cmap (either a native
* one or synthesized by FreeType) for producing correct results. If a
* font provides an incorrect mapping (for example, assigning the
* character code U+005A, LATIN CAPITAL LETTER Z, to a glyph depicting a
* mathematical integral sign), the auto-hinter might produce useless
* results.
*
*/
#define FT_LOAD_DEFAULT 0x0
#define FT_LOAD_NO_SCALE ( 1L << 0 )
@ -2580,7 +2591,8 @@ FT_BEGIN_HEADER
*
* If @FT_LOAD_RENDER is also set, the glyph is rendered in the
* corresponding mode (i.e., the mode which matches the used algorithm
* best) unless @FT_LOAD_MONOCHROME is set.
* best). An exeption is FT_LOAD_TARGET_MONO since it implies
* @FT_LOAD_MONOCHROME.
*
* You can use a hinting algorithm that doesn't correspond to the same
* rendering mode. As an example, it is possible to use the `light'
@ -2922,7 +2934,7 @@ FT_BEGIN_HEADER
/* */
/* glyph_index :: The glyph index. */
/* */
/* buffer_max :: The maximal number of bytes available in the */
/* buffer_max :: The maximum number of bytes available in the */
/* buffer. */
/* */
/* <Output> */
@ -3081,9 +3093,15 @@ FT_BEGIN_HEADER
/* <Note> */
/* If you use FreeType to manipulate the contents of font files */
/* directly, be aware that the glyph index returned by this function */
/* doesn't always correspond to the internal indices used within */
/* the file. This is done to ensure that value~0 always corresponds */
/* to the `missing glyph'. */
/* doesn't always correspond to the internal indices used within the */
/* file. This is done to ensure that value~0 always corresponds to */
/* the `missing glyph'. If the first glyph is not named `.notdef', */
/* then for Type~1 and Type~42 fonts, `.notdef' will be moved into */
/* the glyph ID~0 position, and whatever was there will be moved to */
/* the position `.notdef' had. For Type~1 fonts, if there is no */
/* `.notdef' glyph at all, then one will be created at index~0 and */
/* whatever was there will be moved to the last index -- Type~42 */
/* fonts are considered invalid under this condition. */
/* */
FT_EXPORT( FT_UInt )
FT_Get_Char_Index( FT_Face face,
@ -3614,7 +3632,7 @@ FT_BEGIN_HEADER
/* */
/* <Description> */
/* A very simple function used to perform the computation `(a*b)/c' */
/* with maximal accuracy (it uses a 64-bit intermediate integer */
/* with maximum accuracy (it uses a 64-bit intermediate integer */
/* whenever necessary). */
/* */
/* This function isn't necessarily as fast as some processor specific */
@ -3649,7 +3667,7 @@ FT_BEGIN_HEADER
/* */
/* <Description> */
/* A very simple function used to perform the computation */
/* `(a*b)/0x10000' with maximal accuracy. Most of the time this is */
/* `(a*b)/0x10000' with maximum accuracy. Most of the time this is */
/* used to multiply a given value by a 16.16 fixed float factor. */
/* */
/* <Input> */
@ -3694,7 +3712,7 @@ FT_BEGIN_HEADER
/* */
/* <Description> */
/* A very simple function used to perform the computation */
/* `(a*0x10000)/b' with maximal accuracy. Most of the time, this is */
/* `(a*0x10000)/b' with maximum accuracy. Most of the time, this is */
/* used to divide a given value by a 16.16 fixed float factor. */
/* */
/* <Input> */
@ -3834,7 +3852,7 @@ FT_BEGIN_HEADER
*/
#define FREETYPE_MAJOR 2
#define FREETYPE_MINOR 4
#define FREETYPE_PATCH 9
#define FREETYPE_PATCH 10
/*************************************************************************/

24
GRRLIB/lib/freetype/include/freetype/ftoutln.h
View file

@ -5,7 +5,7 @@
/* Support for the FT_Outline type used to store glyph shapes of */
/* most scalable font formats (specification). */
/* */
/* Copyright 1996-2003, 2005-2011 by */
/* Copyright 1996-2003, 2005-2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -59,6 +59,7 @@ FT_BEGIN_HEADER
/* FT_Outline_Translate */
/* FT_Outline_Transform */
/* FT_Outline_Embolden */
/* FT_Outline_EmboldenXY */
/* FT_Outline_Reverse */
/* FT_Outline_Check */
/* */
@ -124,9 +125,9 @@ FT_BEGIN_HEADER
/* outline will *not* necessarily be *freed*, when */
/* destroying the library, by @FT_Done_FreeType. */
/* */
/* numPoints :: The maximal number of points within the outline. */
/* numPoints :: The maximum number of points within the outline. */
/* */
/* numContours :: The maximal number of contours within the outline. */
/* numContours :: The maximum number of contours within the outline. */
/* */
/* <Output> */
/* anoutline :: A handle to the new outline. */
@ -350,6 +351,23 @@ FT_BEGIN_HEADER
FT_Pos strength );
/*************************************************************************/
/* */
/* <Function> */
/* FT_Outline_EmboldenXY */
/* */
/* <Description> */
/* Embolden an outline. The new outline will be `xstrength' pixels */
/* wider and `ystrength' pixels higher. Otherwise, it is similar to */
/* @FT_Outline_Embolden, which uses the same strength in both */
/* directions. */
/* */
FT_EXPORT( FT_Error )
FT_Outline_EmboldenXY( FT_Outline* outline,
FT_Pos xstrength,
FT_Pos ystrength );
/*************************************************************************/
/* */
/* <Function> */

12
GRRLIB/lib/freetype/include/freetype/ftstroke.h
View file

@ -4,7 +4,7 @@
/* */
/* FreeType path stroker (specification). */
/* */
/* Copyright 2002-2006, 2008, 2009, 2011 by */
/* Copyright 2002-2006, 2008, 2009, 2011-2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -682,6 +682,11 @@ FT_BEGIN_HEADER
*
* @note:
* The source glyph is untouched in case of error.
*
* Adding stroke may yield a significantly wider and taller glyph
* depending on how large of a radius was used to stroke the glyph. You
* may need to manually adjust horizontal and vertical advance amounts
* to account for this added size.
*/
FT_EXPORT( FT_Error )
FT_Glyph_Stroke( FT_Glyph *pglyph,
@ -719,6 +724,11 @@ FT_BEGIN_HEADER
*
* @note:
* The source glyph is untouched in case of error.
*
* Adding stroke may yield a significantly wider and taller glyph
* depending on how large of a radius was used to stroke the glyph. You
* may need to manually adjust horizontal and vertical advance amounts
* to account for this added size.
*/
FT_EXPORT( FT_Error )
FT_Glyph_StrokeBorder( FT_Glyph *pglyph,

7
GRRLIB/lib/freetype/include/freetype/ftsynth.h
View file

@ -5,7 +5,7 @@
/* FreeType synthesizing code for emboldening and slanting */
/* (specification). */
/* */
/* Copyright 2000-2001, 2003, 2006, 2008 by */
/* Copyright 2000-2001, 2003, 2006, 2008, 2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -61,8 +61,9 @@ FT_BEGIN_HEADER
/* taste). This function is actually a convenience function, providing */
/* a wrapper for @FT_Outline_Embolden and @FT_Bitmap_Embolden. */
/* */
/* For emboldened outlines the metrics are estimates only; if you need */
/* precise values you should call @FT_Outline_Get_CBox. */
/* For emboldened outlines the height, width, and advance metrics are */
/* increased by the strength of the emboldening. You can also call */
/* @FT_Outline_Get_CBox to get precise values. */
FT_EXPORT( void )
FT_GlyphSlot_Embolden( FT_GlyphSlot slot );

4
GRRLIB/lib/freetype/include/freetype/internal/ftcalc.h
View file

@ -4,7 +4,7 @@
/* */
/* Arithmetic computations (specification). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009 by */
/* Copyright 1996-2006, 2008, 2009, 2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -87,7 +87,7 @@ FT_BEGIN_HEADER
/* */
/* <Description> */
/* A very simple function used to perform the computation `(a*b)/c' */
/* (without rounding) with maximal accuracy (it uses a 64-bit */
/* (without rounding) with maximum accuracy (it uses a 64-bit */
/* intermediate integer whenever necessary). */
/* */
/* This function isn't necessarily as fast as some processor specific */

4
GRRLIB/lib/freetype/include/freetype/internal/ftobjs.h
View file

@ -270,13 +270,13 @@ FT_BEGIN_HEADER
/* */
/* <Fields> */
/* max_points :: */
/* The maximal number of points used to store the vectorial outline */
/* The maximum number of points used to store the vectorial outline */
/* of any glyph in this face. If this value cannot be known in */
/* advance, or if the face isn't scalable, this should be set to 0. */
/* Only relevant for scalable formats. */
/* */
/* max_contours :: */
/* The maximal number of contours used to store the vectorial */
/* The maximum number of contours used to store the vectorial */
/* outline of any glyph in this face. If this value cannot be */
/* known in advance, or if the face isn't scalable, this should be */
/* set to 0. Only relevant for scalable formats. */

6
GRRLIB/lib/freetype/include/freetype/internal/psaux.h
View file

@ -5,7 +5,7 @@
/* Auxiliary functions and data structures related to PostScript fonts */
/* (specification). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2004, 2006, 2008, 2009 by */
/* Copyright 1996-2004, 2006, 2008, 2009, 2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -225,7 +225,7 @@ FT_BEGIN_HEADER
T1_Field_ParseFunc reader;
FT_UInt offset; /* offset of field in object */
FT_Byte size; /* size of field in bytes */
FT_UInt array_max; /* maximal number of elements for */
FT_UInt array_max; /* maximum number of elements for */
/* array */
FT_UInt count_offset; /* offset of element count for */
/* arrays; must not be zero if in */
@ -531,7 +531,7 @@ FT_BEGIN_HEADER
/* */
/* max_points :: maximum points in builder outline */
/* */
/* max_contours :: Maximal number of contours in builder outline. */
/* max_contours :: Maximum number of contours in builder outline. */
/* */
/* pos_x :: The horizontal translation (if composite glyph). */
/* */

4
GRRLIB/lib/freetype/include/freetype/internal/tttypes.h
View file

@ -5,7 +5,7 @@
/* Basic SFNT/TrueType type definitions and interface (specification */
/* only). */
/* */
/* Copyright 1996-2001, 2002, 2004, 2005, 2006, 2007, 2008 by */
/* Copyright 1996-2002, 2004-2008, 2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -1443,7 +1443,7 @@ FT_BEGIN_HEADER
/* <Fields> */
/* memory :: A handle to the memory manager. */
/* */
/* max_points :: The maximal size in points of the zone. */
/* max_points :: The maximum size in points of the zone. */
/* */
/* max_contours :: Max size in links contours of the zone. */
/* */

3
GRRLIB/lib/freetype/include/freetype/tttables.h
View file

@ -702,7 +702,8 @@ FT_BEGIN_HEADER
* FreeType error code. 0~means success.
*
* @note:
* SFNT tables with length zero are treated as missing.
* While parsing fonts, FreeType handles SFNT tables with length zero as
* missing.
*
*/
FT_EXPORT( FT_Error )

3
GRRLIB/lib/freetype/src/autofit/aflatin.c
View file

@ -4,7 +4,7 @@
/* */
/* Auto-fitter hinting routines for latin script (body). */
/* */
/* Copyright 2003-2011 by */
/* Copyright 2003-2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -705,6 +705,7 @@
{
metrics->root.scaler.render_mode = scaler->render_mode;
metrics->root.scaler.face = scaler->face;
metrics->root.scaler.flags = scaler->flags;
af_latin_metrics_scale_dim( metrics, scaler, AF_DIMENSION_HORZ );
af_latin_metrics_scale_dim( metrics, scaler, AF_DIMENSION_VERT );

3
GRRLIB/lib/freetype/src/autofit/aflatin2.c
View file

@ -4,7 +4,7 @@
/* */
/* Auto-fitter hinting routines for latin script (body). */
/* */
/* Copyright 2003-2011 by */
/* Copyright 2003-2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -658,6 +658,7 @@
{
metrics->root.scaler.render_mode = scaler->render_mode;
metrics->root.scaler.face = scaler->face;
metrics->root.scaler.flags = scaler->flags;
af_latin2_metrics_scale_dim( metrics, scaler, AF_DIMENSION_HORZ );
af_latin2_metrics_scale_dim( metrics, scaler, AF_DIMENSION_VERT );

8
GRRLIB/lib/freetype/src/autofit/afloader.c
View file

@ -104,9 +104,11 @@
AF_GlyphHints hints = &loader->hints;
FT_GlyphSlot slot = face->glyph;
FT_Slot_Internal internal = slot->internal;
FT_Int32 flags;
error = FT_Load_Glyph( face, glyph_index, load_flags );
flags = load_flags | FT_LOAD_LINEAR_DESIGN;
error = FT_Load_Glyph( face, glyph_index, flags );
if ( error )
goto Exit;
@ -124,10 +126,6 @@
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:

224
GRRLIB/lib/freetype/src/base/ftoutln.c
View file

@ -881,10 +881,20 @@
FT_EXPORT_DEF( FT_Error )
FT_Outline_Embolden( FT_Outline* outline,
FT_Pos strength )
{
return FT_Outline_EmboldenXY( outline, strength, strength );
}
/* documentation is in ftoutln.h */
FT_EXPORT_DEF( FT_Error )
FT_Outline_EmboldenXY( FT_Outline* outline,
FT_Pos xstrength,
FT_Pos ystrength )
{
FT_Vector* points;
FT_Vector v_prev, v_first, v_next, v_cur;
FT_Angle rotate, angle_in, angle_out;
FT_Int c, n, first;
FT_Int orientation;
@ -892,8 +902,9 @@
if ( !outline )
return FT_Err_Invalid_Argument;
strength /= 2;
if ( strength == 0 )
xstrength /= 2;
ystrength /= 2;
if ( xstrength == 0 && ystrength == 0 )
return FT_Err_Ok;
orientation = FT_Outline_Get_Orientation( outline );
@ -905,62 +916,63 @@
return FT_Err_Ok;
}
if ( orientation == FT_ORIENTATION_TRUETYPE )
rotate = -FT_ANGLE_PI2;
else
rotate = FT_ANGLE_PI2;
points = outline->points;
first = 0;
for ( c = 0; c < outline->n_contours; c++ )
{
int last = outline->contours[c];
FT_Vector in, out, shift;
FT_Fixed l_in, l_out, d;
int last = outline->contours[c];
v_first = points[first];
v_prev = points[last];
v_cur = v_first;
/* compute the incoming vector and its length */
in.x = v_cur.x - v_prev.x;
in.y = v_cur.y - v_prev.y;
l_in = FT_Vector_Length( &in );
for ( n = first; n <= last; n++ )
{
FT_Vector in, out;
FT_Angle angle_diff;
FT_Pos d;
FT_Fixed scale;
if ( n < last )
v_next = points[n + 1];
else
v_next = v_first;
/* compute the in and out vectors */
in.x = v_cur.x - v_prev.x;
in.y = v_cur.y - v_prev.y;
/* compute the outgoing vector and its length */
out.x = v_next.x - v_cur.x;
out.y = v_next.y - v_cur.y;
l_out = FT_Vector_Length( &out );
angle_in = FT_Atan2( in.x, in.y );
angle_out = FT_Atan2( out.x, out.y );
angle_diff = FT_Angle_Diff( angle_in, angle_out );
scale = FT_Cos( angle_diff / 2 );
d = l_in * l_out + in.x * out.x + in.y * out.y;
if ( scale < 0x4000L && scale > -0x4000L )
in.x = in.y = 0;
else
/* shift only if turn is less then ~160 degrees */
if ( 16 * d > l_in * l_out )
{
d = FT_DivFix( strength, scale );
/* shift components are rotated */
shift.x = FT_DivFix( l_out * in.y + l_in * out.y, d );
shift.y = FT_DivFix( l_out * in.x + l_in * out.x, d );
FT_Vector_From_Polar( &in, d, angle_in + angle_diff / 2 - rotate );
if ( orientation == FT_ORIENTATION_TRUETYPE )
shift.x = -shift.x;
else
shift.y = -shift.y;
shift.x = FT_MulFix( xstrength, shift.x );
shift.y = FT_MulFix( ystrength, shift.y );
}
else
shift.x = shift.y = 0;
outline->points[n].x = v_cur.x + strength + in.x;
outline->points[n].y = v_cur.y + strength + in.y;
outline->points[n].x = v_cur.x + xstrength + shift.x;
outline->points[n].y = v_cur.y + ystrength + shift.y;
v_prev = v_cur;
v_cur = v_next;
in = out;
l_in = l_out;
v_cur = v_next;
}
first = last + 1;
@ -975,23 +987,10 @@
FT_EXPORT_DEF( FT_Orientation )
FT_Outline_Get_Orientation( FT_Outline* outline )
{
FT_Pos xmin = 32768L;
FT_Pos xmin_ymin = 32768L;
FT_Pos xmin_ymax = -32768L;
FT_Vector* xmin_first = NULL;
FT_Vector* xmin_last = NULL;
short* contour;
FT_Vector* first;
FT_Vector* last;
FT_Vector* prev;
FT_Vector* point;
int i;
FT_Pos ray_y[3];
FT_Orientation result[3] =
{ FT_ORIENTATION_NONE, FT_ORIENTATION_NONE, FT_ORIENTATION_NONE };
FT_Vector* points;
FT_Vector v_prev, v_cur;
FT_Int c, n, first;
FT_Pos area = 0;
if ( !outline || outline->n_points <= 0 )
@ -1002,127 +1001,32 @@
/* cubic or quadratic curves, this test deals with the polygon */
/* only which is spanned up by the control points. */
first = outline->points;
for ( contour = outline->contours;
contour < outline->contours + outline->n_contours;
contour++, first = last + 1 )
points = outline->points;
first = 0;
for ( c = 0; c < outline->n_contours; c++ )
{
FT_Pos contour_xmin = 32768L;
FT_Pos contour_xmax = -32768L;
FT_Pos contour_ymin = 32768L;
FT_Pos contour_ymax = -32768L;
FT_Int last = outline->contours[c];
last = outline->points + *contour;
v_prev = points[last];
/* skip degenerate contours */
if ( last < first + 2 )
continue;
for ( point = first; point <= last; ++point )
for ( n = first; n <= last; n++ )
{
if ( point->x < contour_xmin )
contour_xmin = point->x;
if ( point->x > contour_xmax )
contour_xmax = point->x;
if ( point->y < contour_ymin )
contour_ymin = point->y;
if ( point->y > contour_ymax )
contour_ymax = point->y;
v_cur = points[n];
area += ( v_cur.y - v_prev.y ) * ( v_cur.x + v_prev.x );
v_prev = v_cur;
}
if ( contour_xmin < xmin &&
contour_xmin != contour_xmax &&
contour_ymin != contour_ymax )
{
xmin = contour_xmin;
xmin_ymin = contour_ymin;
xmin_ymax = contour_ymax;
xmin_first = first;
xmin_last = last;
}
first = last + 1;
}
if ( xmin == 32768L )
if ( area > 0 )
return FT_ORIENTATION_POSTSCRIPT;
else if ( area < 0 )
return FT_ORIENTATION_TRUETYPE;
ray_y[0] = ( xmin_ymin * 3 + xmin_ymax ) >> 2;
ray_y[1] = ( xmin_ymin + xmin_ymax ) >> 1;
ray_y[2] = ( xmin_ymin + xmin_ymax * 3 ) >> 2;
for ( i = 0; i < 3; i++ )
{
FT_Pos left_x;
FT_Pos right_x;
FT_Vector* left1;
FT_Vector* left2;
FT_Vector* right1;
FT_Vector* right2;
RedoRay:
left_x = 32768L;
right_x = -32768L;
left1 = left2 = right1 = right2 = NULL;
prev = xmin_last;
for ( point = xmin_first; point <= xmin_last; prev = point, ++point )
{
FT_Pos tmp_x;
if ( point->y == ray_y[i] || prev->y == ray_y[i] )
{
ray_y[i]++;
goto RedoRay;
}
if ( ( point->y < ray_y[i] && prev->y < ray_y[i] ) ||
( point->y > ray_y[i] && prev->y > ray_y[i] ) )
continue;
tmp_x = FT_MulDiv( point->x - prev->x,
ray_y[i] - prev->y,
point->y - prev->y ) + prev->x;
if ( tmp_x < left_x )
{
left_x = tmp_x;
left1 = prev;
left2 = point;
}
if ( tmp_x > right_x )
{
right_x = tmp_x;
right1 = prev;
right2 = point;
}
}
if ( left1 && right1 )
{
if ( left1->y < left2->y && right1->y > right2->y )
result[i] = FT_ORIENTATION_TRUETYPE;
else if ( left1->y > left2->y && right1->y < right2->y )
result[i] = FT_ORIENTATION_POSTSCRIPT;
else
result[i] = FT_ORIENTATION_NONE;
}
}
if ( result[0] != FT_ORIENTATION_NONE &&
( result[0] == result[1] || result[0] == result[2] ) )
return result[0];
if ( result[1] != FT_ORIENTATION_NONE && result[1] == result[2] )
return result[1];
return FT_ORIENTATION_TRUETYPE;
else
return FT_ORIENTATION_NONE;
}

23
GRRLIB/lib/freetype/src/base/ftsynth.c
View file

@ -4,7 +4,7 @@
/* */
/* FreeType synthesizing code for emboldening and slanting (body). */
/* */
/* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2010 by */
/* Copyright 2000-2006, 2010, 2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -33,6 +33,7 @@
#undef FT_COMPONENT
#define FT_COMPONENT trace_synth
/*************************************************************************/
/*************************************************************************/
/**** ****/
@ -72,7 +73,7 @@
/*************************************************************************/
/*************************************************************************/
/**** ****/
/**** EXPERIMENTAL EMBOLDENING/OUTLINING SUPPORT ****/
/**** EXPERIMENTAL EMBOLDENING SUPPORT ****/
/**** ****/
/*************************************************************************/
/*************************************************************************/
@ -101,12 +102,7 @@
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;
(void)FT_Outline_EmboldenXY( &slot->outline, xstr, ystr );
}
else /* slot->format == FT_GLYPH_FORMAT_BITMAP */
{
@ -143,13 +139,10 @@
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;
slot->metrics.width += xstr;
slot->metrics.height += ystr;
slot->metrics.horiAdvance += xstr;
slot->metrics.vertAdvance += ystr;
/* XXX: 16-bit overflow case must be excluded before here */
if ( slot->format == FT_GLYPH_FORMAT_BITMAP )

14
GRRLIB/lib/freetype/src/bdf/bdflib.c
View file

@ -569,6 +569,7 @@
list->field[1] = (char*)empty;
list->field[2] = (char*)empty;
list->field[3] = (char*)empty;
list->field[4] = (char*)empty;
}
/* If the line is empty, then simply return. */
@ -841,9 +842,6 @@
};
#define isdigok( m, d ) (m[(d) >> 3] & ( 1 << ( (d) & 7 ) ) )
/* Routine to convert an ASCII string into an unsigned long integer. */
static unsigned long
_bdf_atoul( char* s,
@ -881,7 +879,7 @@
s += 2;
}
for ( v = 0; isdigok( dmap, *s ); s++ )
for ( v = 0; sbitset( dmap, *s ); s++ )
v = v * base + a2i[(int)*s];
if ( end != 0 )
@ -936,7 +934,7 @@
s += 2;
}
for ( v = 0; isdigok( dmap, *s ); s++ )
for ( v = 0; sbitset( dmap, *s ); s++ )
v = v * base + a2i[(int)*s];
if ( end != 0 )
@ -991,7 +989,7 @@
s += 2;
}
for ( v = 0; isdigok( dmap, *s ); s++ )
for ( v = 0; sbitset( dmap, *s ); s++ )
v = (short)( v * base + a2i[(int)*s] );
if ( end != 0 )
@ -1746,7 +1744,7 @@
for ( i = 0; i < nibbles; i++ )
{
c = line[i];
if ( !isdigok( hdigits, c ) )
if ( !sbitset( hdigits, c ) )
break;
*bp = (FT_Byte)( ( *bp << 4 ) + a2i[c] );
if ( i + 1 < nibbles && ( i & 1 ) )
@ -1770,7 +1768,7 @@
/* If any line has extra columns, indicate they have been removed. */
if ( i == nibbles &&
isdigok( hdigits, line[nibbles] ) &&
sbitset( hdigits, line[nibbles] ) &&
!( p->flags & _BDF_GLYPH_WIDTH_CHECK ) )
{
FT_TRACE2(( "_bdf_parse_glyphs: " ACMSG14, glyph->encoding ));

5
GRRLIB/lib/freetype/src/pshinter/pshalgo.c
View file

@ -4,8 +4,7 @@
/* */
/* PostScript hinting algorithm (body). */
/* */
/* Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 */
/* by */
/* Copyright 2001-2010, 2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
@ -563,7 +562,7 @@
else if ( len > 0 )
{
/* This is a very small stem; we simply align it to the
* pixel grid, trying to find the minimal displacement.
* pixel grid, trying to find the minimum displacement.
*
* left = pos
* right = pos + len

21
GRRLIB/lib/freetype/src/raster/ftmisc.h
View file

@ -115,6 +115,27 @@
return ( s > 0 ) ? d : -d;
}
static 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 /* __FTMISC_H__ */

11
GRRLIB/lib/freetype/src/raster/ftraster.c
View file

@ -60,7 +60,7 @@
#include <ft2build.h>
#include "ftraster.h"
#include FT_INTERNAL_CALC_H /* for FT_MulDiv only */
#include FT_INTERNAL_CALC_H /* for FT_MulDiv and FT_MulDiv_No_Round */
#include "rastpic.h"
@ -255,7 +255,8 @@
/* On the other hand, SMulDiv means `Slow MulDiv', and is used typically */
/* for clipping computations. It simply uses the FT_MulDiv() function */
/* defined in `ftcalc.h'. */
#define SMulDiv FT_MulDiv
#define SMulDiv FT_MulDiv
#define SMulDiv_No_Round FT_MulDiv_No_Round
/* The rasterizer is a very general purpose component; please leave */
/* the following redefinitions there (you never know your target */
@ -1150,14 +1151,14 @@
if ( Dx > 0 )
{
Ix = SMulDiv( ras.precision, Dx, Dy);
Ix = SMulDiv_No_Round( ras.precision, Dx, Dy );
Rx = ( ras.precision * Dx ) % Dy;
Dx = 1;
}
else
{
Ix = SMulDiv( ras.precision, -Dx, Dy) * -1;
Rx = ( ras.precision * -Dx ) % Dy;
Ix = -SMulDiv_No_Round( ras.precision, -Dx, Dy );
Rx = ( ras.precision * -Dx ) % Dy;
Dx = -1;
}

14
GRRLIB/lib/freetype/src/sfnt/sfobjs.c
View file

@ -4,7 +4,7 @@
/* */
/* SFNT object management (base). */
/* */
/* Copyright 1996-2008, 2010-2011 by */
/* Copyright 1996-2008, 2010-2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -64,13 +64,17 @@
for ( n = 0; n < len; n++ )
{
code = FT_NEXT_USHORT( read );
if ( code == 0 )
break;
if ( code < 32 || code > 127 )
code = '?';
string[n] = (char)code;
}
string[len] = 0;
string[n] = 0;
return string;
}
@ -95,13 +99,17 @@
for ( n = 0; n < len; n++ )
{
code = *read++;
if ( code == 0 )
break;
if ( code < 32 || code > 127 )
code = '?';
string[n] = (char)code;
}
string[len] = 0;
string[n] = 0;
return string;
}

15
GRRLIB/lib/freetype/src/sfnt/ttload.c
View file

@ -5,8 +5,7 @@
/* Load the basic TrueType tables, i.e., tables that can be either in */
/* TTF or OTF fonts (body). */
/* */
/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */
/* 2010 by */
/* Copyright 1996-2010, 2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -624,7 +623,7 @@
FT_Error error;
TT_MaxProfile* maxProfile = &face->max_profile;
const FT_Frame_Field maxp_fields[] =
static const FT_Frame_Field maxp_fields[] =
{
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_MaxProfile
@ -635,7 +634,7 @@
FT_FRAME_END
};
const FT_Frame_Field maxp_fields_extra[] =
static const FT_Frame_Field maxp_fields_extra[] =
{
FT_FRAME_START( 26 ),
FT_FRAME_USHORT( maxPoints ),
@ -721,7 +720,7 @@
/*************************************************************************/
/* */
/* <Function> */
/* tt_face_load_names */
/* tt_face_load_name */
/* */
/* <Description> */
/* Loads the name records. */
@ -952,7 +951,7 @@
FT_Error error;
TT_OS2* os2;
const FT_Frame_Field os2_fields[] =
static const FT_Frame_Field os2_fields[] =
{
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_OS2
@ -1004,7 +1003,7 @@
FT_FRAME_END
};
const FT_Frame_Field os2_fields_extra[] =
static const FT_Frame_Field os2_fields_extra[] =
{
FT_FRAME_START( 8 ),
FT_FRAME_ULONG( ulCodePageRange1 ),
@ -1012,7 +1011,7 @@
FT_FRAME_END
};
const FT_Frame_Field os2_fields_extra2[] =
static const FT_Frame_Field os2_fields_extra2[] =
{
FT_FRAME_START( 10 ),
FT_FRAME_SHORT ( sxHeight ),

4
GRRLIB/lib/freetype/src/sfnt/ttmtx.c
View file

@ -4,7 +4,7 @@
/* */
/* Load the metrics tables common to TTF and OTF fonts (body). */
/* */
/* Copyright 2006-2009, 2011 by */
/* Copyright 2006-2009, 2011-2012 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
@ -260,7 +260,7 @@
FT_Error error;
TT_HoriHeader* header;
const FT_Frame_Field metrics_header_fields[] =
static const FT_Frame_Field metrics_header_fields[] =
{
#undef FT_STRUCTURE
#define FT_STRUCTURE TT_HoriHeader

2
GRRLIB/lib/freetype/src/smooth/ftgrays.c
View file

@ -312,7 +312,7 @@ typedef ptrdiff_t FT_PtrDist;
#endif /* PIXEL_BITS >= 8 */
/* maximal number of gray spans in a call to the span callback */
/* maximum number of gray spans in a call to the span callback */
#define FT_MAX_GRAY_SPANS 32

9
GRRLIB/lib/freetype/src/truetype/ttgload.c
View file

@ -1983,13 +1983,11 @@
FT_UInt glyph_index,
FT_Int32 load_flags )
{
TT_Face face;
FT_Error error;
TT_LoaderRec loader;
face = (TT_Face)glyph->face;
error = TT_Err_Ok;
error = TT_Err_Ok;
#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
@ -2003,10 +2001,7 @@
error = load_sbit_image( size, glyph, glyph_index, load_flags );
if ( !error )
{
FT_Face root = &face->root;
if ( FT_IS_SCALABLE( root ) )
if ( FT_IS_SCALABLE( glyph->face ) )
{
/* for the bbox we need the header only */
(void)tt_loader_init( &loader, size, glyph, load_flags, TRUE );

19
GRRLIB/lib/freetype/src/truetype/ttinterp.c
View file

@ -52,7 +52,7 @@
/* */
/* In order to detect infinite loops in the code, we set up a counter */
/* within the run loop. A single stroke of interpretation is now */
/* limited to a maximal number of opcodes defined below. */
/* limited to a maximum number of opcodes defined below. */
/* */
#define MAX_RUNNABLE_OPCODES 1000000L
@ -1463,7 +1463,7 @@
#else
/* compute (a*b)/2^14 with maximal accuracy and rounding */
/* compute (a*b)/2^14 with maximum accuracy and rounding */
static FT_Int32
TT_MulFix14( FT_Int32 a,
FT_Int b )
@ -1493,7 +1493,7 @@
#endif
/* compute (ax*bx+ay*by)/2^14 with maximal accuracy and rounding */
/* compute (ax*bx+ay*by)/2^14 with maximum accuracy and rounding */
static FT_Int32
TT_DotFix14( FT_Int32 ax,
FT_Int32 ay,
@ -3110,14 +3110,9 @@
CUR.GS.single_width_cutin = (FT_F26Dot6)args[0];
/* XXX: UNDOCUMENTED! or bug in the Windows engine? */
/* */
/* It seems that the value that is read here is */
/* expressed in 16.16 format rather than in font */
/* units. */
/* */
#define DO_SSW \
CUR.GS.single_width_value = (FT_F26Dot6)( args[0] >> 10 );
#define DO_SSW \
CUR.GS.single_width_value = TT_MULFIX( args[0], \
CUR.tt_metrics.scale );
#define DO_FLIPON \
@ -5772,7 +5767,7 @@
/* */
/* UNDOCUMENTED: According to Greg Hitchcock, there is one (virtual) */
/* contour in the twilight zone, namely contour number */
/* zero. */
/* zero which includes all points of it. */
/* */
static void
Ins_SHC( INS_ARG )

22
GRRLIB/lib/freetype/src/truetype/ttobjs.c
View file

@ -244,7 +244,7 @@
tt_check_trickyness_sfnt_ids( TT_Face face )
{
#define TRICK_SFNT_IDS_PER_FACE 3
#define TRICK_SFNT_IDS_NUM_FACES 13
#define TRICK_SFNT_IDS_NUM_FACES 17
static const tt_sfnt_id_rec sfnt_id[TRICK_SFNT_IDS_NUM_FACES]
[TRICK_SFNT_IDS_PER_FACE] = {
@ -317,6 +317,26 @@
{ 0x00000000, 0x00000000 }, /* cvt */
{ 0x0d3de9cb, 0x00000141 }, /* fpgm */
{ 0xd4127766, 0x00002280 } /* prep */
},
{ /* NEC FA-Gothic, 1996 */
{ 0x00000000, 0x00000000 }, /* cvt */
{ 0x4a692698, 0x000001f0 }, /* fpgm */
{ 0x340d4346, 0x00001fca } /* prep */
},
{ /* NEC FA-Minchou, 1996 */
{ 0x00000000, 0x00000000 }, /* cvt */
{ 0xcd34c604, 0x00000166 }, /* fpgm */
{ 0x6cf31046, 0x000022b0 } /* prep */
},
{ /* NEC FA-RoundGothicB, 1996 */
{ 0x00000000, 0x00000000 }, /* cvt */
{ 0x5da75315, 0x0000019d }, /* fpgm */
{ 0x40745a5f, 0x000022e0 } /* prep */
},
{ /* NEC FA-RoundGothicM, 1996 */
{ 0x00000000, 0x00000000 }, /* cvt */
{ 0xf055fc48, 0x000001c2 }, /* fpgm */
{ 0x3900ded3, 0x00001e18 } /* prep */
}
};

64
GRRLIB/lib/freetype/src/type1/t1load.c
View file

@ -71,6 +71,13 @@
#include "t1errors.h"
#ifdef FT_CONFIG_OPTION_INCREMENTAL
#define IS_INCREMENTAL ( face->root.internal->incremental_interface != 0 )
#else
#define IS_INCREMENTAL 0
#endif
/*************************************************************************/
/* */
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
@ -1004,13 +1011,24 @@
max_objects = 0;
}
if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
field->type == T1_FIELD_TYPE_FIXED_ARRAY )
error = T1_Load_Field_Table( &loader->parser, field,
objects, max_objects, 0 );
if ( *objects )
{
if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
field->type == T1_FIELD_TYPE_FIXED_ARRAY )
error = T1_Load_Field_Table( &loader->parser, field,
objects, max_objects, 0 );
else
error = T1_Load_Field( &loader->parser, field,
objects, max_objects, 0 );
}
else
error = T1_Load_Field( &loader->parser, field,
objects, max_objects, 0 );
{
FT_TRACE1(( "t1_load_keyword: ignoring keyword `%s'"
" which is not valid at this point\n"
" (probably due to missing keywords)\n",
field->ident ));
error = T1_Err_Ok;
}
Exit:
return error;
@ -1030,7 +1048,8 @@
static int
read_binary_data( T1_Parser parser,
FT_Long* size,
FT_Byte** base )
FT_Byte** base,
FT_Bool incremental )
{
FT_Byte* cur;
FT_Byte* limit = parser->root.limit;
@ -1065,8 +1084,12 @@
}
}
FT_ERROR(( "read_binary_data: invalid size field\n" ));
parser->root.error = T1_Err_Invalid_File_Format;
if( !incremental )
{
FT_ERROR(( "read_binary_data: invalid size field\n" ));
parser->root.error = T1_Err_Invalid_File_Format;
}
return 0;
}
@ -1387,16 +1410,17 @@
FT_Byte* base;
/* If the next token isn't `dup' we are done. */
if ( parser->root.cursor + 4 < parser->root.limit &&
ft_strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 )
/* If we are out of data, or if the next token isn't `dup', */
/* we are done. */
if ( parser->root.cursor + 4 >= parser->root.limit ||
ft_strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 )
break;
T1_Skip_PS_Token( parser ); /* `dup' */
idx = T1_ToInt( parser );
if ( !read_binary_data( parser, &size, &base ) )
if ( !read_binary_data( parser, &size, &base, IS_INCREMENTAL ) )
return;
/* The binary string is followed by one token, e.g. `NP' */
@ -1582,7 +1606,7 @@
cur++; /* skip `/' */
len = parser->root.cursor - cur;
if ( !read_binary_data( parser, &size, &base ) )
if ( !read_binary_data( parser, &size, &base, IS_INCREMENTAL ) )
return;
/* for some non-standard fonts like `Optima' which provides */
@ -1871,7 +1895,7 @@
parser->root.cursor = start_binary;
if ( !read_binary_data( parser, &s, &b ) )
if ( !read_binary_data( parser, &s, &b, IS_INCREMENTAL ) )
return T1_Err_Invalid_File_Format;
have_integer = 0;
}
@ -1884,7 +1908,7 @@
parser->root.cursor = start_binary;
if ( !read_binary_data( parser, &s, &b ) )
if ( !read_binary_data( parser, &s, &b, IS_INCREMENTAL ) )
return T1_Err_Invalid_File_Format;
have_integer = 0;
}
@ -1957,8 +1981,8 @@
if ( !( dict & keyword->dict ) )
{
FT_TRACE1(( "parse_dict: found %s but ignoring it "
"since it is in the wrong dictionary\n",
FT_TRACE1(( "parse_dict: found `%s' but ignoring it"
" since it is in the wrong dictionary\n",
keyword->ident ));
break;
}
@ -2160,9 +2184,7 @@
type1->subrs_len = loader.subrs.lengths;
}
#ifdef FT_CONFIG_OPTION_INCREMENTAL
if ( !face->root.internal->incremental_interface )
#endif
if ( !IS_INCREMENTAL )
if ( !loader.charstrings.init )
{
FT_ERROR(( "T1_Open_Face: no `/CharStrings' array in face\n" ));