From 2177eb8fad173f2b0fe04f188c4d6dadaa8f4441 Mon Sep 17 00:00:00 2001 From: marha Date: Sun, 16 Jan 2011 17:43:39 +0000 Subject: freetype 2.4.4 --- freetype/src/smooth/ftgrays.c | 295 +++++++++++++++++++---------------------- freetype/src/smooth/ftsmooth.c | 24 +++- 2 files changed, 154 insertions(+), 165 deletions(-) (limited to 'freetype/src/smooth') diff --git a/freetype/src/smooth/ftgrays.c b/freetype/src/smooth/ftgrays.c index 0b941433e..a85e16086 100644 --- a/freetype/src/smooth/ftgrays.c +++ b/freetype/src/smooth/ftgrays.c @@ -187,7 +187,7 @@ typedef ptrdiff_t FT_PtrDist; shift_, \ delta_ \ }; - + #define FT_DEFINE_RASTER_FUNCS( class_, glyph_format_, \ raster_new_, raster_reset_, \ raster_set_mode_, raster_render_, \ @@ -354,8 +354,6 @@ typedef ptrdiff_t FT_PtrDist; int band_size; int band_shoot; - int conic_level; - int cubic_level; ft_jmp_buf jump_buffer; @@ -879,53 +877,35 @@ typedef ptrdiff_t FT_PtrDist; FT_Vector* arc; - dx = DOWNSCALE( ras.x ) + to->x - ( control->x << 1 ); - if ( dx < 0 ) - dx = -dx; - dy = DOWNSCALE( ras.y ) + to->y - ( control->y << 1 ); - if ( dy < 0 ) - dy = -dy; + arc = ras.bez_stack; + arc[0].x = UPSCALE( to->x ); + arc[0].y = UPSCALE( to->y ); + arc[1].x = UPSCALE( control->x ); + arc[1].y = UPSCALE( control->y ); + arc[2].x = ras.x; + arc[2].y = ras.y; + + dx = FT_ABS( arc[2].x + arc[0].x - 2 * arc[1].x ); + dy = FT_ABS( arc[2].y + arc[0].y - 2 * arc[1].y ); if ( dx < dy ) dx = dy; - level = 1; - dx = dx / ras.conic_level; - while ( dx > 0 ) + if ( dx <= ONE_PIXEL / 4 ) { - dx >>= 2; - level++; + gray_render_line( RAS_VAR_ arc[0].x, arc[0].y ); + return; } - /* a shortcut to speed things up */ - if ( level <= 1 ) + level = 0; + while ( dx > ONE_PIXEL / 4 ) { - /* we compute the mid-point directly in order to avoid */ - /* calling gray_split_conic() */ - TPos to_x, to_y, mid_x, mid_y; - - - to_x = UPSCALE( to->x ); - to_y = UPSCALE( to->y ); - mid_x = ( ras.x + to_x + 2 * UPSCALE( control->x ) ) / 4; - mid_y = ( ras.y + to_y + 2 * UPSCALE( control->y ) ) / 4; - - gray_render_line( RAS_VAR_ mid_x, mid_y ); - gray_render_line( RAS_VAR_ to_x, to_y ); - - return; + dx >>= 2; + level++; } - arc = ras.bez_stack; levels = ras.lev_stack; - top = 0; levels[0] = level; - - arc[0].x = UPSCALE( to->x ); - arc[0].y = UPSCALE( to->y ); - arc[1].x = UPSCALE( control->x ); - arc[1].y = UPSCALE( control->y ); - arc[2].x = ras.x; - arc[2].y = ras.y; + top = 0; while ( top >= 0 ) { @@ -957,21 +937,9 @@ typedef ptrdiff_t FT_PtrDist; } Draw: - { - TPos to_x, to_y, mid_x, mid_y; - - - to_x = arc[0].x; - to_y = arc[0].y; - mid_x = ( ras.x + to_x + 2 * arc[1].x ) / 4; - mid_y = ( ras.y + to_y + 2 * arc[1].y ) / 4; - - gray_render_line( RAS_VAR_ mid_x, mid_y ); - gray_render_line( RAS_VAR_ to_x, to_y ); - - top--; - arc -= 2; - } + gray_render_line( RAS_VAR_ arc[0].x, arc[0].y ); + top--; + arc -= 2; } return; @@ -1011,55 +979,8 @@ typedef ptrdiff_t FT_PtrDist; const FT_Vector* control2, const FT_Vector* to ) { - int top, level; - int* levels; FT_Vector* arc; - int mid_x = ( DOWNSCALE( ras.x ) + to->x + - 3 * (control1->x + control2->x ) ) / 8; - int mid_y = ( DOWNSCALE( ras.y ) + to->y + - 3 * (control1->y + control2->y ) ) / 8; - TPos dx = DOWNSCALE( ras.x ) + to->x - ( mid_x << 1 ); - TPos dy = DOWNSCALE( ras.y ) + to->y - ( mid_y << 1 ); - - - if ( dx < 0 ) - dx = -dx; - if ( dy < 0 ) - dy = -dy; - if ( dx < dy ) - dx = dy; - - level = 1; - dx /= ras.cubic_level; - while ( dx > 0 ) - { - dx >>= 2; - level++; - } - - if ( level <= 1 ) - { - TPos to_x, to_y; - - to_x = UPSCALE( to->x ); - to_y = UPSCALE( to->y ); - - /* Recalculation of midpoint is needed only if */ - /* UPSCALE and DOWNSCALE have any effect. */ - -#if ( PIXEL_BITS != 6 ) - mid_x = ( ras.x + to_x + - 3 * UPSCALE( control1->x + control2->x ) ) / 8; - mid_y = ( ras.y + to_y + - 3 * UPSCALE( control1->y + control2->y ) ) / 8; -#endif - - gray_render_line( RAS_VAR_ mid_x, mid_y ); - gray_render_line( RAS_VAR_ to_x, to_y ); - - return; - } arc = ras.bez_stack; arc[0].x = UPSCALE( to->x ); @@ -1071,58 +992,127 @@ typedef ptrdiff_t FT_PtrDist; arc[3].x = ras.x; arc[3].y = ras.y; - levels = ras.lev_stack; - top = 0; - levels[0] = level; - - while ( top >= 0 ) + for (;;) { - level = levels[top]; - if ( level > 1 ) - { - /* check that the arc crosses the current band */ - TPos min, max, y; + /* Check that the arc crosses the current band. */ + TPos min, max, y; - min = max = arc[0].y; - y = arc[1].y; - if ( y < min ) min = y; - if ( y > max ) max = y; - y = arc[2].y; - if ( y < min ) min = y; - if ( y > max ) max = y; - y = arc[3].y; - if ( y < min ) min = y; - if ( y > max ) max = y; - if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < 0 ) - goto Draw; - gray_split_cubic( arc ); - arc += 3; - top ++; - levels[top] = levels[top - 1] = level - 1; - continue; - } + min = max = arc[0].y; - Draw: - { - TPos to_x, to_y; + y = arc[1].y; + if ( y < min ) + min = y; + if ( y > max ) + max = y; + y = arc[2].y; + if ( y < min ) + min = y; + if ( y > max ) + max = y; - to_x = arc[0].x; - to_y = arc[0].y; - mid_x = ( ras.x + to_x + 3 * ( arc[1].x + arc[2].x ) ) / 8; - mid_y = ( ras.y + to_y + 3 * ( arc[1].y + arc[2].y ) ) / 8; + y = arc[3].y; + if ( y < min ) + min = y; + if ( y > max ) + max = y; - gray_render_line( RAS_VAR_ mid_x, mid_y ); - gray_render_line( RAS_VAR_ to_x, to_y ); - top --; - arc -= 3; + if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < ras.min_ey ) + goto Draw; + + /* Decide whether to split or draw. See `Rapid Termination */ + /* Evaluation for Recursive Subdivision of Bezier Curves' by Thomas */ + /* F. Hain, at */ + /* http://www.cis.southalabama.edu/~hain/general/Publications/Bezier/Camera-ready%20CISST02%202.pdf */ + + { + TPos dx, dy, dx_, dy_; + TPos dx1, dy1, dx2, dy2; + TPos L, s, s_limit; + + + /* dx and dy are x and y components of the P0-P3 chord vector. */ + dx = arc[3].x - arc[0].x; + dy = arc[3].y - arc[0].y; + + /* L is an (under)estimate of the Euclidean distance P0-P3. */ + /* */ + /* If dx >= dy, then r = sqrt(dx^2 + dy^2) can be overestimated */ + /* with least maximum error by */ + /* */ + /* r_upperbound = dx + (sqrt(2) - 1) * dy , */ + /* */ + /* where sqrt(2) - 1 can be (over)estimated by 107/256, giving an */ + /* error of no more than 8.4%. */ + /* */ + /* Similarly, some elementary calculus shows that r can be */ + /* underestimated with least maximum error by */ + /* */ + /* r_lowerbound = sqrt(2 + sqrt(2)) / 2 * dx */ + /* + sqrt(2 - sqrt(2)) / 2 * dy . */ + /* */ + /* 236/256 and 97/256 are (under)estimates of the two algebraic */ + /* numbers, giving an error of no more than 8.1%. */ + + dx_ = FT_ABS( dx ); + dy_ = FT_ABS( dy ); + + /* This is the same as */ + /* */ + /* L = ( 236 * FT_MAX( dx_, dy_ ) */ + /* + 97 * FT_MIN( dx_, dy_ ) ) >> 8; */ + L = ( dx_ > dy_ ? 236 * dx_ + 97 * dy_ + : 97 * dx_ + 236 * dy_ ) >> 8; + + /* Avoid possible arithmetic overflow below by splitting. */ + if ( L > 32767 ) + goto Split; + + /* Max deviation may be as much as (s/L) * 3/4 (if Hain's v = 1). */ + s_limit = L * (TPos)( ONE_PIXEL / 6 ); + + /* s is L * the perpendicular distance from P1 to the line P0-P3. */ + dx1 = arc[1].x - arc[0].x; + dy1 = arc[1].y - arc[0].y; + s = FT_ABS( dy * dx1 - dx * dy1 ); + + if ( s > s_limit ) + goto Split; + + /* s is L * the perpendicular distance from P2 to the line P0-P3. */ + dx2 = arc[2].x - arc[0].x; + dy2 = arc[2].y - arc[0].y; + s = FT_ABS( dy * dx2 - dx * dy2 ); + + if ( s > s_limit ) + goto Split; + + /* If P1 or P2 is outside P0-P3, split the curve. */ + if ( dy * dy1 + dx * dx1 < 0 || + dy * dy2 + dx * dx2 < 0 || + dy * (arc[3].y - arc[1].y) + dx * (arc[3].x - arc[1].x) < 0 || + dy * (arc[3].y - arc[2].y) + dx * (arc[3].x - arc[2].x) < 0 ) + goto Split; + + /* No reason to split. */ + goto Draw; } - } - return; - } + Split: + gray_split_cubic( arc ); + arc += 3; + continue; + Draw: + gray_render_line( RAS_VAR_ arc[0].x, arc[0].y ); + + if ( arc == ras.bez_stack ) + return; + + arc -= 3; + } + } static int @@ -1760,25 +1750,6 @@ typedef ptrdiff_t FT_PtrDist; ras.count_ex = ras.max_ex - ras.min_ex; ras.count_ey = ras.max_ey - ras.min_ey; - /* simple heuristic used to speed up the bezier decomposition -- see */ - /* the code in gray_render_conic() and gray_render_cubic() for more */ - /* details */ - ras.conic_level = 32; - ras.cubic_level = 16; - - { - int level = 0; - - - if ( ras.count_ex > 24 || ras.count_ey > 24 ) - level++; - if ( ras.count_ex > 120 || ras.count_ey > 120 ) - level++; - - ras.conic_level <<= level; - ras.cubic_level <<= level; - } - /* set up vertical bands */ num_bands = (int)( ( ras.max_ey - ras.min_ey ) / ras.band_size ); if ( num_bands == 0 ) diff --git a/freetype/src/smooth/ftsmooth.c b/freetype/src/smooth/ftsmooth.c index 7d16b94a1..eb12f1802 100644 --- a/freetype/src/smooth/ftsmooth.c +++ b/freetype/src/smooth/ftsmooth.c @@ -140,8 +140,26 @@ cbox.xMax = FT_PIX_CEIL( cbox.xMax ); cbox.yMax = FT_PIX_CEIL( cbox.yMax ); - width = (FT_UInt)( ( cbox.xMax - cbox.xMin ) >> 6 ); - height = (FT_UInt)( ( cbox.yMax - cbox.yMin ) >> 6 ); + if ( cbox.xMin < 0 && cbox.xMax > FT_INT_MAX + cbox.xMin ) + { + FT_ERROR(( "ft_smooth_render_generic: glyph too large:" + " xMin = %d, xMax = %d\n", + cbox.xMin >> 6, cbox.xMax >> 6 )); + return Smooth_Err_Raster_Overflow; + } + else + width = (FT_UInt)( ( cbox.xMax - cbox.xMin ) >> 6 ); + + if ( cbox.yMin < 0 && cbox.yMax > FT_INT_MAX + cbox.yMin ) + { + FT_ERROR(( "ft_smooth_render_generic: glyph too large:" + " yMin = %d, yMax = %d\n", + cbox.yMin >> 6, cbox.yMax >> 6 )); + return Smooth_Err_Raster_Overflow; + } + else + height = (FT_UInt)( ( cbox.yMax - cbox.yMin ) >> 6 ); + bitmap = &slot->bitmap; memory = render->root.memory; @@ -202,7 +220,7 @@ /* but we care realistic cases only. Always pitch <= width. */ if ( width > 0x7FFFU || height > 0x7FFFU ) { - FT_ERROR(( "ft_smooth_render_generic: glyph too large: %d x %d\n", + FT_ERROR(( "ft_smooth_render_generic: glyph too large: %u x %u\n", width, height )); return Smooth_Err_Raster_Overflow; } -- cgit v1.2.3