Chiebot-Mirror
/
freetype
mirror of https://github.com/freetype/freetype.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

* src/smooth/ftgrays.c: minor source cleanups and optimization

Browse Source
david-pic-changes
David Turner 19 years ago
parent 772e55d38e
commit c7bc9b7907
2 changed files with 59 additions and 42 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      ChangeLog
  2. 96
      src/smooth/ftgrays.c

5
ChangeLog
Unescape View File

@ -1,7 +1,10 @@
2006-09-05 David Turner <david@freetype.org>
* src/smooth/ftgrays.c: minor source cleanups and optimization
* src/smooth/ftgrays.c (gray_sweep): Avoid buffer overwrites
when to the end of a bitmap scanline. The fun never ends ;-)
when to drawing the end of a bitmap scanline. The fun never ends ;-)
2006-09-04 David Turner <david@freetype.org>

96
src/smooth/ftgrays.c
Unescape View File

@ -207,13 +207,6 @@
#define DOWNSCALE( x ) ( (x) << ( 6 - PIXEL_BITS ) )
#endif
/* Define this if you want to use a more compact storage scheme. This */
/* increases the number of cells available in the render pool but slows */
/* down the rendering a bit. It is useful if you have a really tiny */
/* render pool. */
#undef GRAYS_COMPACT
/*************************************************************************/
/* */
/* TYPE DEFINITIONS */
@ -264,18 +257,19 @@ typedef struct TCell_
typedef struct TRaster_
{
PCell cells;
int max_cells;
int num_cells;
TCoord ex, ey;
TPos min_ex, max_ex;
TPos min_ey, max_ey;
TPos count_ex, count_ey;
TArea area;
int cover;
int invalid;
TCoord ex, ey;
PCell cells;
int max_cells;
int num_cells;
TCoord cx, cy;
TPos x, y;
@ -382,13 +376,13 @@ typedef struct TCell_
/* Record the current cell in the table. */
/* */
static PCell
gray_find_cell( RAS_ARG_ TCoord x,
TCoord y )
gray_find_cell( RAS_ARG )
{
PCell *pcell, cell;
int x = ras.ex;
pcell = &ras.ycells[y];
pcell = &ras.ycells[ ras.ey ];
for (;;)
{
cell = *pcell;
@ -422,9 +416,7 @@ typedef struct TCell_
{
if ( !ras.invalid && (ras.area | ras.cover) )
{
TCoord x = (TCoord)( ras.ex - ras.min_ex );
TCoord y = (TCoord)( ras.ey - ras.min_ey );
PCell cell = gray_find_cell( RAS_VAR_ x, y );
PCell cell = gray_find_cell( RAS_VAR );
cell->area += ras.area;
cell->cover += ras.cover;
@ -440,9 +432,6 @@ typedef struct TCell_
gray_set_cell( RAS_ARG_ TCoord ex,
TCoord ey )
{
int invalid, record, clean;
/* Move the cell pointer to a new position. We set the `invalid' */
/* flag to indicate that the cell isn't part of those we're interested */
/* in during the render phase. This means that: */
@ -455,8 +444,10 @@ typedef struct TCell_
/* All cells that are on the left of the clipping region go to the */
/* min_ex - 1 horizontal position. */
if ( ex < ras.min_ex )
ex = (TCoord)(ras.min_ex - 1);
ey -= ras.min_ey;
ex -= ras.min_ex;
if ( ex < 0 )
ex = -1;
/* are we moving to a different cell ? */
if ( ex != ras.ex || ey != ras.ey )
@ -469,9 +460,10 @@ typedef struct TCell_
ras.cover = 0;
}
ras.invalid = ( ey < ras.min_ey || ey >= ras.max_ey || ex >= ras.max_ex );
ras.ex = ex;
ras.ey = ey;
ras.invalid = ( (unsigned)ey >= (unsigned)ras.count_ey ||
ex >= ras.count_ex );
}
@ -488,8 +480,8 @@ typedef struct TCell_
ras.area = 0;
ras.cover = 0;
ras.ex = ex;
ras.ey = ey;
ras.ex = ex - ras.min_ex;
ras.ey = ey - ras.min_ey;
ras.last_ey = SUBPIXELS( ey );
ras.invalid = 0;
@ -515,8 +507,8 @@ typedef struct TCell_
dx = x2 - x1;
ex1 = TRUNC( x1 ); /* if (ex1 >= ras.max_ex) ex1 = ras.max_ex-1; */
ex2 = TRUNC( x2 ); /* if (ex2 >= ras.max_ex) ex2 = ras.max_ex-1; */
ex1 = TRUNC( x1 );
ex2 = TRUNC( x2 );
fx1 = (TCoord)( x1 - SUBPIXELS( ex1 ) );
fx2 = (TCoord)( x2 - SUBPIXELS( ex2 ) );
@ -1113,16 +1105,31 @@ typedef struct TCell_
if ( coverage )
#if 1
FT_MEM_SET( p + spans->x, (unsigned char)coverage, spans->len );
#else /* 1 */
{
q = p + spans->x;
limit = q + spans->len;
for ( ; q < limit; q++ )
q[0] = (unsigned char)coverage;
/* for small-spans, it's faster to do it ourselves than
* calling memset. this is mainly due to the cost of the
* function call.
*/
if ( spans->len >= 8 )
FT_MEM_SET( p + spans->x, (unsigned char)coverage, spans->len );
else
{
unsigned char* q = p + spans->x;
switch ( spans->len )
{
case 7: *q++ = (unsigned char)coverage;
case 6: *q++ = (unsigned char)coverage;
case 5: *q++ = (unsigned char)coverage;
case 4: *q++ = (unsigned char)coverage;
case 3: *q++ = (unsigned char)coverage;
case 2: *q++ = (unsigned char)coverage;
case 1: *q = (unsigned char)coverage;
default:
;
}
}
}
#endif /* 1 */
}
}
@ -1223,7 +1230,9 @@ typedef struct TCell_
}
#if 1
#ifdef DEBUG_GRAYS
/* to be called while in the debugger */
gray_dump_cells( RAS_ARG )
{
int yindex;
@ -1239,7 +1248,9 @@ typedef struct TCell_
printf( "\n" );
}
}
#endif
#endif /* DEBUG_GRAYS */
static void
gray_sweep( RAS_ARG_ const FT_Bitmap* target )
@ -1281,7 +1292,7 @@ typedef struct TCell_
if ( cover != 0 )
gray_hline( RAS_VAR_ x, yindex, cover * ( ONE_PIXEL * 2 ),
(ras.max_ex - ras.min_ex) - x );
ras.count_ex - x );
}
if ( ras.render_span && ras.num_gray_spans > 0 )
@ -1597,6 +1608,9 @@ typedef struct TCell_
if ( ras.max_ex > clip->xMax ) ras.max_ex = clip->xMax;
if ( ras.max_ey > clip->yMax ) ras.max_ey = clip->yMax;
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 */
@ -1607,9 +1621,9 @@ typedef struct TCell_
int level = 0;
if ( ras.max_ex > 24 || ras.max_ey > 24 )
if ( ras.count_ex > 24 || ras.count_ey > 24 )
level++;
if ( ras.max_ex > 120 || ras.max_ey > 120 )
if ( ras.count_ex > 120 || ras.count_ey > 120 )
level++;
ras.conic_level <<= level;

Write Preview
Loading…
Cancel
Save