third_party/freetype/src/base/ftbbox.c - Issue 815103002: Update freetype to 2.5.4.

Unified Diff: third_party/freetype/src/base/ftbbox.c

Issue 815103002: Update freetype to 2.5.4. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master

Patch Set: Adjust GYP and GN Created 6 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: third_party/freetype/src/base/ftbbox.c

diff --git a/core/src/fxge/fx_freetype/fxft2.5.01/src/base/ftbbox.c b/third_party/freetype/src/base/ftbbox.c

similarity index 63%

rename from core/src/fxge/fx_freetype/fxft2.5.01/src/base/ftbbox.c

rename to third_party/freetype/src/base/ftbbox.c

index a5862c5b91c519e654f4b0ae7c439841a5c6bd6f..c775d5c8cf0f7133db97fd35ebda16373b41fb1d 100644

--- a/core/src/fxge/fx_freetype/fxft2.5.01/src/base/ftbbox.c

+++ b/third_party/freetype/src/base/ftbbox.c

@@ -4,7 +4,7 @@

/* */

/* FreeType bbox computation (body). */

/* */

/* David Turner, Robert Wilhelm, and Werner Lemberg. */

/* */

/* This file is part of the FreeType project, and may only be used */

@@ -24,14 +24,14 @@

/*************************************************************************/

-#include "../../include/ft2build.h"

-#include "../../include/freetype/internal/ftdebug.h"

+#include <ft2build.h>

+#include FT_INTERNAL_DEBUG_H

-#include "../../include/freetype/ftbbox.h"

-#include "../../include/freetype/ftimage.h"

-#include "../../include/freetype/ftoutln.h"

-#include "../../include/freetype/internal/ftcalc.h"

-#include "../../include/freetype/internal/ftobjs.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_

@@ -42,16 +42,35 @@

} TBBox_Rec;

+#define FT_UPDATE_BBOX(p, bbox) \

+ FT_BEGIN_STMNT \

+ if ( p->x < bbox.xMin ) \

+ bbox.xMin = p->x; \

+ if ( p->x > bbox.xMax ) \

+ bbox.xMax = p->x; \

+ if ( p->y < bbox.yMin ) \

+ bbox.yMin = p->y; \

+ if ( p->y > bbox.yMax ) \

+ bbox.yMax = p->y; \

+ FT_END_STMNT

+#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_Move_To */

/* */

/* <Description> */

- /* This function is used as a `move_to' and `line_to' emitter during */

+ /* This function is used as a `move_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. */

+ /* in `user->last'. We also update bbox in case contour starts with */

+ /* an implicit `on' point. */

/* */

/* <Input> */

/* to :: A pointer to the destination vector. */

@@ -66,17 +85,42 @@

BBox_Move_To( FT_Vector* to,

TBBox_Rec* user )

{

+ FT_UPDATE_BBOX( to, user->bbox );

user->last = *to;

return 0;

}

-#define CHECK_X( p, bbox ) \

- ( p->x < bbox.xMin || p->x > bbox.xMax )

+ /*************************************************************************/

+ /* */

+ /* <Function> */

+ /* BBox_Line_To */

+ /* */

+ /* <Description> */

+ /* This function is used as a `line_to' emitter during */

+ /* FT_Outline_Decompose(). It simply records the destination point */

+ /* in `user->last'; no further computations are necessary because */

+ /* bbox already contains both explicit ends of the line segment. */

+ /* */

+ /* <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_Line_To( FT_Vector* to,

+ TBBox_Rec* user )

+ {

+ user->last = *to;

-#define CHECK_Y( p, bbox ) \

- ( p->y < bbox.yMin || p->y > bbox.yMax )

+ return 0;

+ }

/*************************************************************************/

@@ -85,7 +129,7 @@

/* BBox_Conic_Check */

/* */

/* <Description> */

- /* Finds the extrema of a 1-dimensional conic Bezier curve and update */

+ /* Find 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. */

/* */

@@ -108,30 +152,19 @@

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;

+ /* This function is only called when a control off-point is outside */

+ /* the bbox that contains all on-points. It finds a local extremum */

+ /* within the segment, equal to (y1*y3 - y2*y2)/(y1 - 2*y2 + y3). */

+ /* Or, offsetting from y2, we get */

+ y1 -= y2;

+ y3 -= y2;

+ y2 += FT_MulDiv( y1, y3, y1 + y3 );

+ if ( y2 < *min )

+ *min = y2;

+ if ( y2 > *max )

+ *max = y2;

}

@@ -166,8 +199,8 @@

FT_Vector* to,

TBBox_Rec* user )

{

- /* we don't need to check `to' since it is always an `on' point, thus */

- /* within the bbox */

+ /* in case `to' is implicit and not included in bbox yet */

+ FT_UPDATE_BBOX( to, user->bbox );

if ( CHECK_X( control, user->bbox ) )

BBox_Conic_Check( user->last.x,

@@ -195,9 +228,9 @@

/* 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. */

+ /* Find the extrema of a 1-dimensional cubic Bezier curve and */

+ /* update a bounding range. This version uses iterative splitting */

+ /* because it is faster than the exact solution with square roots. */

/* */

/* <Input> */

/* p1 :: The start coordinate. */

@@ -213,28 +246,49 @@

/* */

/* 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 )

+ static FT_Pos

+ cubic_peak( FT_Pos q1,

+ FT_Pos q2,

+ FT_Pos q3,

+ FT_Pos q4 )

{

- FT_Pos q1, q2, q3, q4;

- q1 = p1;

- q2 = p2;

- q3 = p3;

- q4 = p4;

+ FT_Pos peak = 0;

+ FT_Int shift;

+ /* This function finds a peak of a cubic segment if it is above 0 */

+ /* using iterative bisection of the segment, or returns 0. */

+ /* The fixed-point arithmetic of bisection is inherently stable */

+ /* but may loose accuracy in the two lowest bits. To compensate, */

+ /* we upscale the segment if there is room. Large values may need */

+ /* to be downscaled to avoid overflows during bisection. */

+ /* It is called with either q2 or q3 positive, which is necessary */

+ /* for the peak to exist and avoids undefined FT_MSB. */

+ shift = 27 -

+ FT_MSB( FT_ABS( q1 ) | FT_ABS( q2 ) | FT_ABS( q3 ) | FT_ABS( q4 ) );

+ if ( shift > 0 )

+ {

+ /* upscaling too much just wastes time */

+ if ( shift > 2 )

+ shift = 2;

+ q1 <<= shift;

+ q2 <<= shift;

+ q3 <<= shift;

+ q4 <<= shift;

+ }

+ else

+ {

+ q1 >>= -shift;

+ q2 >>= -shift;

+ q3 >>= -shift;

+ q4 >>= -shift;

+ }

- /* for a conic segment to possibly reach new maximum */

- /* one of its off-points must be above the current value */

- while ( q2 > *max || q3 > *max )

+ /* for a peak to exist above 0, the cubic segment must have */

+ /* at least one of its control off-points above 0. */

+ while ( q2 > 0 || q3 > 0 )

{

/* determine which half contains the maximum and split */

if ( q1 + q2 > q3 + q4 ) /* first half */

@@ -260,232 +314,49 @@

q3 = q3 / 2;

}

- /* check if either end reached the maximum */

+ /* check whether either end reached the maximum */

if ( q1 == q2 && q1 >= q3 )

{

- *max = q1;

+ peak = q1;

break;

}

if ( q3 == q4 && q2 <= q4 )

{

- *max = q4;

- break;

- }

- q1 = p1;

- q2 = p2;

- q3 = p3;

- q4 = p4;

- /* for a conic segment to possibly reach new minimum */

- /* one of its off-points must be below the current value */

- while ( q2 < *min || q3 < *min )

- {

- /* determine which half contains the minimum and split */

- if ( q1 + q2 < q3 + q4 ) /* first half */

- {

- q4 = q4 + q3;

- q3 = q3 + q2;

- q2 = q2 + q1;

- q4 = q4 + q3;

- q3 = q3 + q2;

- q4 = ( q4 + q3 ) / 8;

- q3 = q3 / 4;

- q2 = q2 / 2;

- }

- else /* second half */

- {

- q1 = q1 + q2;

- q2 = q2 + q3;

- q3 = q3 + q4;

- q1 = q1 + q2;

- q2 = q2 + q3;

- q1 = ( q1 + q2 ) / 8;

- q2 = q2 / 4;

- q3 = q3 / 2;

- }

- /* check if either end reached the minimum */

- if ( q1 == q2 && q1 <= q3 )

- {

- *min = q1;

- break;

- }

- if ( q3 == q4 && q2 >= q4 )

- {

- *min = q4;

+ peak = q4;

break;

}

- }

-#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 ( shift > 0 )

+ peak >>= shift;

+ else

+ peak <<= -shift;

- if ( y < *min ) *min = y;

- if ( y > *max ) *max = y;

- }

+ return peak;

}

static void

- BBox_Cubic_Check( FT_Pos y1,

- FT_Pos y2,

- FT_Pos y3,

- FT_Pos y4,

+ BBox_Cubic_Check( FT_Pos p1,

+ FT_Pos p2,

+ FT_Pos p3,

+ FT_Pos p4,

FT_Pos* min,

FT_Pos* max )

{

- /* always compare first and last points */

- if ( y1 < *min ) *min = y1;

- else if ( y1 > *max ) *max = y1;

+ /* This function is only called when a control off-point is outside */

+ /* the bbox that contains all on-points. So at least one of the */

+ /* conditions below holds and cubic_peak is called with at least one */

+ /* non-zero argument. */

- if ( y4 < *min ) *min = y4;

- else if ( y4 > *max ) *max = y4;

+ if ( p2 > *max || p3 > *max )

+ *max += cubic_peak( p1 - *max, p2 - *max, p3 - *max, p4 - *max );

- /* 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. */

- /* We already made sure that a, b, and c below cannot be all zero. */

- {

- 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;

- FT_Int shift;

- /* 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-point values to ensure */

- /* that their product is held in a `16.16' value including the sign. */

- /* Necessarily, we need to shift `a', `b', and `c' so that the most */

- /* significant bit of their absolute values is at position 22. */

- /* */

- /* This also means that we are using 23 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). */

- shift = FT_MSB( FT_ABS( a ) | FT_ABS( b ) | FT_ABS( c ) );

- if ( shift > 22 )

- {

- shift -= 22;

- /* this loses some bits of precision, but we use 23 of them */

- /* for the computation anyway */

- a >>= shift;

- b >>= shift;

- c >>= shift;

- }

- else

- {

- shift = 22 - shift;

- 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 );

- }

+ /* now flip the signs to update the minimum */

+ if ( p2 < *min || p3 < *min )

+ *min -= cubic_peak( *min - p1, *min - p2, *min - p3, *min - p4 );

}

-#endif

/*************************************************************************/

/* */

@@ -521,8 +392,9 @@

FT_Vector* to,

TBBox_Rec* user )

{

- /* we don't need to check `to' since it is always an `on' point, thus */

- /* within the bbox */

+ /* We don't need to check `to' since it is always an on-point, */

+ /* thus within the bbox. Only segments with an off-point outside */

+ /* the bbox can possibly reach new extreme values. */

if ( CHECK_X( control1, user->bbox ) ||

CHECK_X( control2, user->bbox ) )

@@ -549,7 +421,7 @@

FT_DEFINE_OUTLINE_FUNCS(bbox_interface,

(FT_Outline_MoveTo_Func) BBox_Move_To,

- (FT_Outline_LineTo_Func) BBox_Move_To,

+ (FT_Outline_LineTo_Func) BBox_Line_To,

(FT_Outline_ConicTo_Func)BBox_Conic_To,

(FT_Outline_CubicTo_Func)BBox_Cubic_To,

0, 0

@@ -561,8 +433,8 @@ FT_DEFINE_OUTLINE_FUNCS(bbox_interface,

FT_Outline_Get_BBox( FT_Outline* outline,

FT_BBox *abbox )

{

- FT_BBox cbox;

- FT_BBox bbox;

+ FT_BBox cbox = { 0x7FFFFFFF, 0x7FFFFFFF, -0x7FFFFFFF, -0x7FFFFFFF };

+ FT_BBox bbox = { 0x7FFFFFFF, 0x7FFFFFFF, -0x7FFFFFFF, -0x7FFFFFFF };

FT_Vector* vec;

FT_UShort n;

@@ -586,32 +458,13 @@ FT_DEFINE_OUTLINE_FUNCS(bbox_interface,

/* 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++ )

+ for ( n = 0; 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;

+ FT_UPDATE_BBOX( vec, cbox);

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;

- }

+ FT_UPDATE_BBOX( vec, bbox);

vec++;

}

« no previous file with comments | « third_party/freetype/src/base/ftbase.c ('k') | third_party/freetype/src/base/ftbdf.c » ('j') | no next file with comments »