ftgrays.c File Reference

#include <ft2build.h>
#include "ftgrays.h"
#include "ftsmerrs.h"
#include "ftspic.h"

Include dependency graph for ftgrays.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	TCell_
struct	TPixmap_
struct	gray_TWorker_
struct	gray_TRaster_

Macros
#define	FT_COMPONENT   trace_smooth
#define	Smooth_Err_Invalid_Mode   Smooth_Err_Cannot_Render_Glyph
#define	Smooth_Err_Memory_Overflow   Smooth_Err_Out_Of_Memory
#define	ErrRaster_Memory_Overflow   Smooth_Err_Out_Of_Memory
#define	FT_MEM_SET(d, s, c)   ft_memset( d, s, c )
#define	FT_MEM_ZERO(dest, count)   FT_MEM_SET( dest, 0, count )
#define	FT_ZERO(p)   FT_MEM_ZERO( p, sizeof ( *(p) ) )
#define	RAS_ARG   gray_PWorker worker
#define	RAS_ARG_   gray_PWorker worker,
#define	RAS_VAR   worker
#define	RAS_VAR_   worker,
#define	PIXEL_BITS   8
#define	ONE_PIXEL   ( 1 << PIXEL_BITS )
#define	TRUNC(x)   ( (TCoord)( (x) >> PIXEL_BITS ) )
#define	SUBPIXELS(x)   ( (TPos)(x) * ONE_PIXEL )
#define	FLOOR(x)   ( (x) & -ONE_PIXEL )
#define	CEILING(x)   ( ( (x) + ONE_PIXEL - 1 ) & -ONE_PIXEL )
#define	ROUND(x)   ( ( (x) + ONE_PIXEL / 2 ) & -ONE_PIXEL )
#define	UPSCALE(x)   ( (x) * ( ONE_PIXEL >> 6 ) )
#define	DOWNSCALE(x)   ( (x) >> ( PIXEL_BITS - 6 ) )
#define	FT_DIV_MOD(type, dividend, divisor, quotient, remainder)
#define	FT_UDIVPREP(c, b)
#define	FT_UDIV(a, b)
#define	FT_MAX_GRAY_POOL   ( 2048 / sizeof ( TCell ) )
#define	ras   (*worker)

Typedefs
typedef long	TPos
typedef int	TCoord
typedef int	TArea
typedef struct TCell_ *	PCell
typedef struct TCell_	TCell
typedef struct TPixmap_	TPixmap
typedef struct gray_TWorker_	gray_TWorker
typedef struct gray_TWorker_ *	gray_PWorker
typedef struct gray_TRaster_	gray_TRaster
typedef struct gray_TRaster_ *	gray_PRaster

Functions
static void	gray_record_cell (RAS_ARG)
static void	gray_set_cell (RAS_ARG_ TCoord ex, TCoord ey)
static void	gray_render_scanline (RAS_ARG_ TCoord ey, TPos x1, TCoord y1, TPos x2, TCoord y2)
static void	gray_render_line (RAS_ARG_ TPos to_x, TPos to_y)
static void	gray_split_conic (FT_Vector *base)
static void	gray_render_conic (RAS_ARG_ const FT_Vector *control, const FT_Vector *to)
static void	gray_split_cubic (FT_Vector *base)
static void	gray_render_cubic (RAS_ARG_ const FT_Vector *control1, const FT_Vector *control2, const FT_Vector *to)
static int	gray_move_to (const FT_Vector *to, gray_PWorker worker)
static int	gray_line_to (const FT_Vector *to, gray_PWorker worker)
static int	gray_conic_to (const FT_Vector *control, const FT_Vector *to, gray_PWorker worker)
static int	gray_cubic_to (const FT_Vector *control1, const FT_Vector *control2, const FT_Vector *to, gray_PWorker worker)
static void	gray_hline (RAS_ARG_ TCoord x, TCoord y, TArea coverage, TCoord acount)
static void	gray_sweep (RAS_ARG)
	FT_DEFINE_OUTLINE_FUNCS (func_interface,(FT_Outline_MoveTo_Func) gray_move_to,(FT_Outline_LineTo_Func) gray_line_to,(FT_Outline_ConicTo_Func) gray_conic_to,(FT_Outline_CubicTo_Func) gray_cubic_to, 0, 0) static int gray_convert_glyph_inner(RAS_ARG)
static int	gray_convert_glyph (RAS_ARG)
static int	gray_raster_render (FT_Raster raster, const FT_Raster_Params *params)
static int	gray_raster_new (FT_Memory memory, FT_Raster *araster)
static void	gray_raster_done (FT_Raster raster)
static void	gray_raster_reset (FT_Raster raster, unsigned char *pool_base, unsigned long pool_size)
static int	gray_raster_set_mode (FT_Raster raster, unsigned long mode, void *args)

Macro Definition Documentation

CEILING

#define CEILING

(

x

)

( ( (x) + ONE_PIXEL - 1 ) & -ONE_PIXEL )

Definition at line 341 of file ftgrays.c.

DOWNSCALE

#define DOWNSCALE

(

x

)

( (x) >> ( PIXEL_BITS - 6 ) )

Definition at line 346 of file ftgrays.c.

ErrRaster_Memory_Overflow

#define ErrRaster_Memory_Overflow   Smooth_Err_Out_Of_Memory

Definition at line 286 of file ftgrays.c.

FLOOR

#define FLOOR

(

x

)

( (x) & -ONE_PIXEL )

Definition at line 340 of file ftgrays.c.

FT_COMPONENT

#define FT_COMPONENT   trace_smooth

Definition at line 91 of file ftgrays.c.

FT_DIV_MOD

#define FT_DIV_MOD	(		type,
			dividend,
			divisor,
			quotient,
			remainder
	)

Value:

  FT_BEGIN_STMNT                                                   \
    (quotient)  = (type)( (dividend) / (divisor) );                \
    (remainder) = (type)( (dividend) % (divisor) );                \
    if ( (remainder) < 0 )                                         \
    {                                                              \
      (quotient)--;                                                \
      (remainder) += (type)(divisor);                              \
    }                                                              \
  FT_END_STMNT

Definition at line 357 of file ftgrays.c.

FT_MAX_GRAY_POOL

#define FT_MAX_GRAY_POOL   ( 2048 / sizeof ( TCell ) )

Definition at line 434 of file ftgrays.c.

FT_MEM_SET

#define FT_MEM_SET	(		d,
			s,
			c
	)		ft_memset( d, s, c )

Definition at line 293 of file ftgrays.c.

FT_MEM_ZERO

#define FT_MEM_ZERO	(		dest,
			count
	)		FT_MEM_SET( dest, 0, count )

Definition at line 297 of file ftgrays.c.

FT_UDIV

#define FT_UDIV	(		a,
			b
	)

Value:

  ( ( (unsigned long)( a ) * (unsigned long)( b ## _r ) ) >>   \
    ( sizeof( long ) * FT_CHAR_BIT - PIXEL_BITS ) )

Definition at line 393 of file ftgrays.c.

FT_UDIVPREP

#define FT_UDIVPREP	(		c,
			b
	)

Value:

  long  b ## _r = c ? (long)( FT_ULONG_MAX >> PIXEL_BITS ) / ( b ) \
                    : 0

Definition at line 390 of file ftgrays.c.

FT_ZERO

#define FT_ZERO

(

p

)

FT_MEM_ZERO( p, sizeof ( *(p) ) )

Definition at line 301 of file ftgrays.c.

ONE_PIXEL

#define ONE_PIXEL   ( 1 << PIXEL_BITS )

Definition at line 337 of file ftgrays.c.

PIXEL_BITS

#define PIXEL_BITS   8

Definition at line 330 of file ftgrays.c.

ras

#define ras   (*worker)

Definition at line 479 of file ftgrays.c.

RAS_ARG

#define RAS_ARG   gray_PWorker worker

Definition at line 313 of file ftgrays.c.

RAS_ARG_

#define RAS_ARG_   gray_PWorker worker,

Definition at line 314 of file ftgrays.c.

RAS_VAR

#define RAS_VAR   worker

Definition at line 316 of file ftgrays.c.

RAS_VAR_

#define RAS_VAR_   worker,

Definition at line 317 of file ftgrays.c.

ROUND

#define ROUND

(

x

)

( ( (x) + ONE_PIXEL / 2 ) & -ONE_PIXEL )

Definition at line 342 of file ftgrays.c.

Smooth_Err_Invalid_Mode

#define Smooth_Err_Invalid_Mode   Smooth_Err_Cannot_Render_Glyph

Definition at line 284 of file ftgrays.c.

Smooth_Err_Memory_Overflow

#define Smooth_Err_Memory_Overflow   Smooth_Err_Out_Of_Memory

Definition at line 285 of file ftgrays.c.

SUBPIXELS

#define SUBPIXELS

(

x

)

( (TPos)(x) * ONE_PIXEL )

Definition at line 339 of file ftgrays.c.

TRUNC

#define TRUNC

(

x

)

( (TCoord)( (x) >> PIXEL_BITS ) )

Definition at line 338 of file ftgrays.c.

UPSCALE

#define UPSCALE

(

x

)

( (x) * ( ONE_PIXEL >> 6 ) )

Definition at line 345 of file ftgrays.c.

Typedef Documentation

gray_PRaster

typedef struct gray_TRaster_ * gray_PRaster

gray_PWorker

typedef struct gray_TWorker_ * gray_PWorker

gray_TRaster

typedef struct gray_TRaster_ gray_TRaster

gray_TWorker

typedef struct gray_TWorker_ gray_TWorker

PCell

typedef struct TCell_* PCell

Definition at line 412 of file ftgrays.c.

TArea

typedef int TArea

Definition at line 409 of file ftgrays.c.

TCell

typedef struct TCell_ TCell

TCoord

typedef int TCoord

Definition at line 408 of file ftgrays.c.

TPixmap

typedef struct TPixmap_ TPixmap

TPos

typedef long TPos

Definition at line 407 of file ftgrays.c.

Function Documentation

FT_DEFINE_OUTLINE_FUNCS()

FT_DEFINE_OUTLINE_FUNCS	(	func_interface	,
		(FT_Outline_MoveTo_Func)	gray_move_to,
		(FT_Outline_LineTo_Func)	gray_line_to,
		(FT_Outline_ConicTo_Func)	gray_conic_to,
		(FT_Outline_CubicTo_Func)	gray_cubic_to,
		0	,
		0
	)

Definition at line 1691 of file ftgrays.c.

  {
 
    volatile int  error = 0;
 
#ifdef FT_CONFIG_OPTION_PIC
      FT_Outline_Funcs func_interface;
      Init_Class_func_interface(&func_interface);
#endif
 
    if ( ft_setjmp( ras.jump_buffer ) == 0 )
    {
      error = FT_Outline_Decompose( &ras.outline, &func_interface, &ras );
      if ( !ras.invalid )
        gray_record_cell( RAS_VAR );
 
      FT_TRACE7(( "band [%d..%d]: %d cell%s\n",
                  ras.min_ey,
                  ras.max_ey,
                  ras.num_cells,
                  ras.num_cells == 1 ? "" : "s" ));
    }
    else
    {
      error = FT_THROW( Memory_Overflow );
 
      FT_TRACE7(( "band [%d..%d]: to be bisected\n",
                  ras.min_ey, ras.max_ey ));
    }
 
    return error;
  }

gray_conic_to()

static int gray_conic_to ( const FT_Vector *  control, const FT_Vector *  to, gray_PWorker  worker  )

static

Definition at line 1213 of file ftgrays.c.

  {
    gray_render_conic( RAS_VAR_ control, to );
    return 0;
  }

gray_convert_glyph()

static int gray_convert_glyph ( RAS_ARG  )

static

Definition at line 1740 of file ftgrays.c.

  {
    const TCoord  yMin = ras.min_ey;
    const TCoord  yMax = ras.max_ey;
    const TCoord  xMin = ras.min_ex;
    const TCoord  xMax = ras.max_ex;
 
#ifdef __REACTOS__
    TCell *buffer;
#else
    TCell    buffer[FT_MAX_GRAY_POOL];
#endif
    size_t   height = (size_t)( yMax - yMin );
    size_t   n = FT_MAX_GRAY_POOL / 8;
    TCoord   y;
    TCoord   bands[32];  /* enough to accommodate bisections */
    TCoord*  band;
 
#ifdef __REACTOS__
    buffer = malloc(FT_MAX(FT_RENDER_POOL_SIZE, 2048));
    if (!buffer)
    {
      return 1;
    }
#endif
 
    /* set up vertical bands */
    if ( height > n )
    {
      /* two divisions rounded up */
      n       = ( height + n - 1 ) / n;
      height  = ( height + n - 1 ) / n;
    }
 
    /* memory management */
    n = ( height * sizeof ( PCell ) + sizeof ( TCell ) - 1 ) / sizeof ( TCell );
 
    ras.cells     = buffer + n;
    ras.max_cells = (FT_PtrDist)( FT_MAX_GRAY_POOL - n );
    ras.ycells    = (PCell*)buffer;
 
    for ( y = yMin; y < yMax; )
    {
      ras.min_ey = y;
      y         += height;
      ras.max_ey = FT_MIN( y, yMax );
 
      band    = bands;
      band[1] = xMin;
      band[0] = xMax;
 
      do
      {
        TCoord  width = band[0] - band[1];
        int     error;
 
 
        FT_MEM_ZERO( ras.ycells, height * sizeof ( PCell ) );
 
        ras.num_cells = 0;
        ras.invalid   = 1;
        ras.min_ex    = band[1];
        ras.max_ex    = band[0];
 
        error = gray_convert_glyph_inner( RAS_VAR );
 
        if ( !error )
        {
          gray_sweep( RAS_VAR );
          band--;
          continue;
        }
        else if ( error != ErrRaster_Memory_Overflow )
        {
#ifdef __REACTOS__
          free(buffer);
#endif
          return 1;
        }
 
        /* render pool overflow; we will reduce the render band by half */
        width >>= 1;
 
        /* this should never happen even with tiny rendering pool */
        if ( width == 0 )
        {
          FT_TRACE7(( "gray_convert_glyph: rotten glyph\n" ));
#ifdef __REACTOS__
          free(buffer);
#endif
          return 1;
        }
 
        band++;
        band[1]  = band[0];
        band[0] += width;
      } while ( band >= bands );
    }
 
#ifdef __REACTOS__
    free(buffer);
#endif
 
    return 0;
  }

Referenced by gray_raster_render().

gray_cubic_to()

static int gray_cubic_to ( const FT_Vector *  control1, const FT_Vector *  control2, const FT_Vector *  to, gray_PWorker  worker  )

static

Definition at line 1223 of file ftgrays.c.

  {
    gray_render_cubic( RAS_VAR_ control1, control2, to );
    return 0;
  }

gray_hline()

static void gray_hline ( RAS_ARG_ TCoord  x, TCoord  y, TArea  coverage, TCoord  acount  )

static

Definition at line 1234 of file ftgrays.c.

  {
    /* scale the coverage from 0..(ONE_PIXEL*ONE_PIXEL*2) to 0..256  */
    coverage >>= PIXEL_BITS * 2 + 1 - 8;
    if ( coverage < 0 )
      coverage = -coverage - 1;
 
    /* compute the line's coverage depending on the outline fill rule */
    if ( ras.outline.flags & FT_OUTLINE_EVEN_ODD_FILL )
    {
      coverage &= 511;
 
      if ( coverage >= 256 )
        coverage = 511 - coverage;
    }
    else
    {
      /* normal non-zero winding rule */
      if ( coverage >= 256 )
        coverage = 255;
    }
 
    if ( ras.render_span )  /* for FT_RASTER_FLAG_DIRECT only */
    {
      FT_Span  span;
 
 
      span.x        = (short)x;
      span.len      = (unsigned short)acount;
      span.coverage = (unsigned char)coverage;
 
      ras.render_span( y, 1, &span, ras.render_span_data );
    }
    else
    {
      unsigned char*  q = ras.target.origin - ras.target.pitch * y + x;
      unsigned char   c = (unsigned char)coverage;
 
 
      /* For small-spans it is faster to do it by ourselves than
       * calling `memset'.  This is mainly due to the cost of the
       * function call.
       */
      switch ( acount )
      {
      case 7: *q++ = c;
      case 6: *q++ = c;
      case 5: *q++ = c;
      case 4: *q++ = c;
      case 3: *q++ = c;
      case 2: *q++ = c;
      case 1: *q   = c;
      case 0: break;
      default:
        FT_MEM_SET( q, c, acount );
      }
    }
  }

Referenced by gray_sweep().

gray_line_to()

static int gray_line_to ( const FT_Vector *  to, gray_PWorker  worker  )

static

Definition at line 1204 of file ftgrays.c.

  {
    gray_render_line( RAS_VAR_ UPSCALE( to->x ), UPSCALE( to->y ) );
    return 0;
  }

gray_move_to()

static int gray_move_to ( const FT_Vector *  to, gray_PWorker  worker  )

static

Definition at line 1185 of file ftgrays.c.

  {
    TPos  x, y;
 
 
    /* start to a new position */
    x = UPSCALE( to->x );
    y = UPSCALE( to->y );
 
    gray_set_cell( RAS_VAR_ TRUNC( x ), TRUNC( y ) );
 
    ras.x = x;
    ras.y = y;
    return 0;
  }

gray_raster_done()

static void gray_raster_done ( FT_Raster  raster )

static

Definition at line 2011 of file ftgrays.c.

  {
    FT_Memory  memory = (FT_Memory)((gray_PRaster)raster)->memory;
 
 
    FT_FREE( raster );
  }

gray_raster_new()

static int gray_raster_new ( FT_Memory  memory, FT_Raster *  araster  )

static

Definition at line 1992 of file ftgrays.c.

  {
    FT_Error      error;
    gray_PRaster  raster = NULL;
 
 
    *araster = 0;
    if ( !FT_ALLOC( raster, sizeof ( gray_TRaster ) ) )
    {
      raster->memory = memory;
      *araster       = (FT_Raster)raster;
    }
 
    return error;
  }

gray_raster_render()

static int gray_raster_render ( FT_Raster  raster, const FT_Raster_Params *  params  )

static

Definition at line 1848 of file ftgrays.c.

  {
    const FT_Outline*  outline    = (const FT_Outline*)params->source;
    const FT_Bitmap*   target_map = params->target;
    FT_BBox            cbox, clip;
 
#ifndef FT_STATIC_RASTER
    gray_TWorker  worker[1];
#endif
 
 
    if ( !raster )
      return FT_THROW( Invalid_Argument );
 
    /* this version does not support monochrome rendering */
    if ( !( params->flags & FT_RASTER_FLAG_AA ) )
      return FT_THROW( Invalid_Mode );
 
    if ( !outline )
      return FT_THROW( Invalid_Outline );
 
    /* return immediately if the outline is empty */
    if ( outline->n_points == 0 || outline->n_contours <= 0 )
      return 0;
 
    if ( !outline->contours || !outline->points )
      return FT_THROW( Invalid_Outline );
 
    if ( outline->n_points !=
           outline->contours[outline->n_contours - 1] + 1 )
      return FT_THROW( Invalid_Outline );
 
    ras.outline = *outline;
 
    if ( params->flags & FT_RASTER_FLAG_DIRECT )
    {
      if ( !params->gray_spans )
        return 0;
 
      ras.render_span      = (FT_Raster_Span_Func)params->gray_spans;
      ras.render_span_data = params->user;
    }
    else
    {
      /* if direct mode is not set, we must have a target bitmap */
      if ( !target_map )
        return FT_THROW( Invalid_Argument );
 
      /* nothing to do */
      if ( !target_map->width || !target_map->rows )
        return 0;
 
      if ( !target_map->buffer )
        return FT_THROW( Invalid_Argument );
 
      if ( target_map->pitch < 0 )
        ras.target.origin = target_map->buffer;
      else
        ras.target.origin = target_map->buffer
              + ( target_map->rows - 1 ) * (unsigned int)target_map->pitch;
 
      ras.target.pitch = target_map->pitch;
 
      ras.render_span      = (FT_Raster_Span_Func)NULL;
      ras.render_span_data = NULL;
    }
 
    FT_Outline_Get_CBox( outline, &cbox );
 
    /* reject too large outline coordinates */
    if ( cbox.xMin < -0x1000000L || cbox.xMax > 0x1000000L ||
         cbox.yMin < -0x1000000L || cbox.yMax > 0x1000000L )
      return FT_THROW( Invalid_Outline );
 
    /* truncate the bounding box to integer pixels */
    cbox.xMin = cbox.xMin >> 6;
    cbox.yMin = cbox.yMin >> 6;
    cbox.xMax = ( cbox.xMax + 63 ) >> 6;
    cbox.yMax = ( cbox.yMax + 63 ) >> 6;
 
    /* compute clipping box */
    if ( !( params->flags & FT_RASTER_FLAG_DIRECT ) )
    {
      /* compute clip box from target pixmap */
      clip.xMin = 0;
      clip.yMin = 0;
      clip.xMax = (FT_Pos)target_map->width;
      clip.yMax = (FT_Pos)target_map->rows;
    }
    else if ( params->flags & FT_RASTER_FLAG_CLIP )
      clip = params->clip_box;
    else
    {
      clip.xMin = -32768L;
      clip.yMin = -32768L;
      clip.xMax =  32767L;
      clip.yMax =  32767L;
    }
 
    /* clip to target bitmap, exit if nothing to do */
    ras.min_ex = FT_MAX( cbox.xMin, clip.xMin );
    ras.min_ey = FT_MAX( cbox.yMin, clip.yMin );
    ras.max_ex = FT_MIN( cbox.xMax, clip.xMax );
    ras.max_ey = FT_MIN( cbox.yMax, clip.yMax );
 
    if ( ras.max_ex <= ras.min_ex || ras.max_ey <= ras.min_ey )
      return 0;
 
    return gray_convert_glyph( RAS_VAR );
  }

gray_raster_reset()

static void gray_raster_reset ( FT_Raster  raster, unsigned char *  pool_base, unsigned long  pool_size  )

static

Definition at line 2023 of file ftgrays.c.

  {
    FT_UNUSED( raster );
    FT_UNUSED( pool_base );
    FT_UNUSED( pool_size );
  }

gray_raster_set_mode()

static int gray_raster_set_mode ( FT_Raster  raster, unsigned long  mode, void *  args  )

static

Definition at line 2034 of file ftgrays.c.

  {
    FT_UNUSED( raster );
    FT_UNUSED( mode );
    FT_UNUSED( args );
 
 
    return 0; /* nothing to do */
  }

gray_record_cell()

static void gray_record_cell ( RAS_ARG  )

static

Definition at line 524 of file ftgrays.c.

  {
    PCell  *pcell, cell;
    TCoord  x = ras.ex;
 
 
    pcell = &ras.ycells[ras.ey - ras.min_ey];
    for (;;)
    {
      cell = *pcell;
      if ( !cell || cell->x > x )
        break;
 
      if ( cell->x == x )
        goto Found;
 
      pcell = &cell->next;
    }
 
    if ( ras.num_cells >= ras.max_cells )
      ft_longjmp( ras.jump_buffer, 1 );
 
    /* insert new cell */
    cell        = ras.cells + ras.num_cells++;
    cell->x     = x;
    cell->area  = ras.area;
    cell->cover = ras.cover;
 
    cell->next  = *pcell;
    *pcell      = cell;
 
    return;
 
  Found:
    /* update old cell */
    cell->area  += ras.area;
    cell->cover += ras.cover;
  }

Referenced by FT_DEFINE_OUTLINE_FUNCS(), and gray_set_cell().

gray_render_conic()

static void gray_render_conic ( RAS_ARG_ const FT_Vector *  control, const FT_Vector *  to  )

static

Definition at line 998 of file ftgrays.c.

  {
    FT_Vector   bez_stack[16 * 2 + 1];  /* enough to accommodate bisections */
    FT_Vector*  arc = bez_stack;
    TPos        dx, dy;
    int         draw, split;
 
 
    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;
 
    /* short-cut the arc that crosses the current band */
    if ( ( TRUNC( arc[0].y ) >= ras.max_ey &&
           TRUNC( arc[1].y ) >= ras.max_ey &&
           TRUNC( arc[2].y ) >= ras.max_ey ) ||
         ( TRUNC( arc[0].y ) <  ras.min_ey &&
           TRUNC( arc[1].y ) <  ras.min_ey &&
           TRUNC( arc[2].y ) <  ras.min_ey ) )
    {
      ras.x = arc[0].x;
      ras.y = arc[0].y;
      return;
    }
 
    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;
 
    /* We can calculate the number of necessary bisections because  */
    /* each bisection predictably reduces deviation exactly 4-fold. */
    /* Even 32-bit deviation would vanish after 16 bisections.      */
    draw = 1;
    while ( dx > ONE_PIXEL / 4 )
    {
      dx   >>= 2;
      draw <<= 1;
    }
 
    /* We use decrement counter to count the total number of segments */
    /* to draw starting from 2^level. Before each draw we split as    */
    /* many times as there are trailing zeros in the counter.         */
    do
    {
      split = 1;
      while ( ( draw & split ) == 0 )
      {
        gray_split_conic( arc );
        arc += 2;
        split <<= 1;
      }
 
      gray_render_line( RAS_VAR_ arc[0].x, arc[0].y );
      arc -= 2;
 
    } while ( --draw );
  }

Referenced by gray_conic_to().

gray_render_cubic()

static void gray_render_cubic ( RAS_ARG_ const FT_Vector *  control1, const FT_Vector *  control2, const FT_Vector *  to  )

static

Definition at line 1091 of file ftgrays.c.

  {
    FT_Vector   bez_stack[16 * 3 + 1];  /* enough to accommodate bisections */
    FT_Vector*  arc = bez_stack;
    TPos        dx, dy, dx_, dy_;
    TPos        dx1, dy1, dx2, dy2;
    TPos        L, s, s_limit;
 
 
    arc[0].x = UPSCALE( to->x );
    arc[0].y = UPSCALE( to->y );
    arc[1].x = UPSCALE( control2->x );
    arc[1].y = UPSCALE( control2->y );
    arc[2].x = UPSCALE( control1->x );
    arc[2].y = UPSCALE( control1->y );
    arc[3].x = ras.x;
    arc[3].y = ras.y;
 
    /* short-cut the arc that crosses the current band */
    if ( ( TRUNC( arc[0].y ) >= ras.max_ey &&
           TRUNC( arc[1].y ) >= ras.max_ey &&
           TRUNC( arc[2].y ) >= ras.max_ey &&
           TRUNC( arc[3].y ) >= ras.max_ey ) ||
         ( TRUNC( arc[0].y ) <  ras.min_ey &&
           TRUNC( arc[1].y ) <  ras.min_ey &&
           TRUNC( arc[2].y ) <  ras.min_ey &&
           TRUNC( arc[3].y ) <  ras.min_ey ) )
    {
      ras.x = arc[0].x;
      ras.y = arc[0].y;
      return;
    }
 
    for (;;)
    {
      /* 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 */
 
      /* dx and dy are x and y components of the P0-P3 chord vector. */
      dx = dx_ = arc[3].x - arc[0].x;
      dy = dy_ = arc[3].y - arc[0].y;
 
      L = FT_HYPOT( dx_, dy_ );
 
      /* 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( SUB_LONG( MUL_LONG( dy, dx1 ), MUL_LONG( 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( SUB_LONG( MUL_LONG( dy, dx2 ), MUL_LONG( dx, dy2 ) ) );
 
      if ( s > s_limit )
        goto Split;
 
      /* Split super curvy segments where the off points are so far
         from the chord that the angles P0-P1-P3 or P0-P2-P3 become
         acute as detected by appropriate dot products. */
      if ( dx1 * ( dx1 - dx ) + dy1 * ( dy1 - dy ) > 0 ||
           dx2 * ( dx2 - dx ) + dy2 * ( dy2 - dy ) > 0 )
        goto Split;
 
      gray_render_line( RAS_VAR_ arc[0].x, arc[0].y );
 
      if ( arc == bez_stack )
        return;
 
      arc -= 3;
      continue;
 
    Split:
      gray_split_cubic( arc );
      arc += 3;
    }
  }

Referenced by gray_cubic_to().

gray_render_line()

static void gray_render_line ( RAS_ARG_ TPos  to_x, TPos  to_y  )

static

Definition at line 704 of file ftgrays.c.

  {
    TCoord  ey1, ey2, fy1, fy2, first, delta, mod;
    TPos    p, dx, dy, x, x2;
    int     incr;
 
 
    ey1 = TRUNC( ras.y );
    ey2 = TRUNC( to_y );     /* if (ey2 >= ras.max_ey) ey2 = ras.max_ey-1; */
 
    /* perform vertical clipping */
    if ( ( ey1 >= ras.max_ey && ey2 >= ras.max_ey ) ||
         ( ey1 <  ras.min_ey && ey2 <  ras.min_ey ) )
      goto End;
 
    fy1 = (TCoord)( ras.y - SUBPIXELS( ey1 ) );
    fy2 = (TCoord)( to_y - SUBPIXELS( ey2 ) );
 
    /* everything is on a single scanline */
    if ( ey1 == ey2 )
    {
      gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, to_x, fy2 );
      goto End;
    }
 
    dx = to_x - ras.x;
    dy = to_y - ras.y;
 
    /* vertical line - avoid calling gray_render_scanline */
    if ( dx == 0 )
    {
      TCoord  ex     = TRUNC( ras.x );
      TCoord  two_fx = (TCoord)( ( ras.x - SUBPIXELS( ex ) ) << 1 );
      TArea   area;
 
 
      if ( dy > 0)
      {
        first = ONE_PIXEL;
        incr  = 1;
      }
      else
      {
        first = 0;
        incr  = -1;
      }
 
      delta      = first - fy1;
      ras.area  += (TArea)two_fx * delta;
      ras.cover += delta;
      ey1       += incr;
 
      gray_set_cell( RAS_VAR_ ex, ey1 );
 
      delta = first + first - ONE_PIXEL;
      area  = (TArea)two_fx * delta;
      while ( ey1 != ey2 )
      {
        ras.area  += area;
        ras.cover += delta;
        ey1       += incr;
 
        gray_set_cell( RAS_VAR_ ex, ey1 );
      }
 
      delta      = fy2 - ONE_PIXEL + first;
      ras.area  += (TArea)two_fx * delta;
      ras.cover += delta;
 
      goto End;
    }
 
    /* ok, we have to render several scanlines */
    if ( dy > 0)
    {
      p     = ( ONE_PIXEL - fy1 ) * dx;
      first = ONE_PIXEL;
      incr  = 1;
    }
    else
    {
      p     = fy1 * dx;
      first = 0;
      incr  = -1;
      dy    = -dy;
    }
 
    FT_DIV_MOD( TCoord, p, dy, delta, mod );
 
    x = ras.x + delta;
    gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, first );
 
    ey1 += incr;
    gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
 
    if ( ey1 != ey2 )
    {
      TCoord  lift, rem;
 
 
      p    = ONE_PIXEL * dx;
      FT_DIV_MOD( TCoord, p, dy, lift, rem );
 
      do
      {
        delta = lift;
        mod  += rem;
        if ( mod >= (TCoord)dy )
        {
          mod -= (TCoord)dy;
          delta++;
        }
 
        x2 = x + delta;
        gray_render_scanline( RAS_VAR_ ey1,
                                       x, ONE_PIXEL - first,
                                       x2, first );
        x = x2;
 
        ey1 += incr;
        gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
      } while ( ey1 != ey2 );
    }
 
    gray_render_scanline( RAS_VAR_ ey1,
                                   x, ONE_PIXEL - first,
                                   to_x, fy2 );
 
  End:
    ras.x       = to_x;
    ras.y       = to_y;
  }

Referenced by gray_line_to(), gray_render_conic(), and gray_render_cubic().

gray_render_scanline()

static void gray_render_scanline ( RAS_ARG_ TCoord  ey, TPos  x1, TCoord  y1, TPos  x2, TCoord  y2  )

static

Definition at line 606 of file ftgrays.c.

  {
    TCoord  ex1, ex2, fx1, fx2, first, dy, delta, mod;
    TPos    p, dx;
    int     incr;
 
 
    ex1 = TRUNC( x1 );
    ex2 = TRUNC( x2 );
 
    /* trivial case.  Happens often */
    if ( y1 == y2 )
    {
      gray_set_cell( RAS_VAR_ ex2, ey );
      return;
    }
 
    fx1   = (TCoord)( x1 - SUBPIXELS( ex1 ) );
    fx2   = (TCoord)( x2 - SUBPIXELS( ex2 ) );
 
    /* everything is located in a single cell.  That is easy! */
    /*                                                        */
    if ( ex1 == ex2 )
      goto End;
 
    /* ok, we'll have to render a run of adjacent cells on the same */
    /* scanline...                                                  */
    /*                                                              */
    dx = x2 - x1;
    dy = y2 - y1;
 
    if ( dx > 0 )
    {
      p     = ( ONE_PIXEL - fx1 ) * dy;
      first = ONE_PIXEL;
      incr  = 1;
    }
    else
    {
      p     = fx1 * dy;
      first = 0;
      incr  = -1;
      dx    = -dx;
    }
 
    FT_DIV_MOD( TCoord, p, dx, delta, mod );
 
    ras.area  += (TArea)( ( fx1 + first ) * delta );
    ras.cover += delta;
    y1        += delta;
    ex1       += incr;
    gray_set_cell( RAS_VAR_ ex1, ey );
 
    if ( ex1 != ex2 )
    {
      TCoord  lift, rem;
 
 
      p = ONE_PIXEL * dy;
      FT_DIV_MOD( TCoord, p, dx, lift, rem );
 
      do
      {
        delta = lift;
        mod  += rem;
        if ( mod >= (TCoord)dx )
        {
          mod -= (TCoord)dx;
          delta++;
        }
 
        ras.area  += (TArea)( ONE_PIXEL * delta );
        ras.cover += delta;
        y1        += delta;
        ex1       += incr;
        gray_set_cell( RAS_VAR_ ex1, ey );
      } while ( ex1 != ex2 );
    }
 
    fx1 = ONE_PIXEL - first;
 
  End:
    dy = y2 - y1;
 
    ras.area  += (TArea)( ( fx1 + fx2 ) * dy );
    ras.cover += dy;
  }

Referenced by gray_render_line().

gray_set_cell()

static void gray_set_cell ( RAS_ARG_ TCoord  ex, TCoord  ey  )

static

Definition at line 569 of file ftgrays.c.

  {
    /* 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:                       */
    /*                                                                     */
    /* . the new vertical position must be within min_ey..max_ey-1.        */
    /* . the new horizontal position must be strictly less than max_ex     */
    /*                                                                     */
    /* Note that if a cell is to the left of the clipping region, it is    */
    /* actually set to the (min_ex-1) horizontal position.                 */
 
    if ( ex < ras.min_ex )
      ex = ras.min_ex - 1;
 
    /* record the current one if it is valid and substantial */
    if ( !ras.invalid && ( ras.area || ras.cover ) )
      gray_record_cell( RAS_VAR );
 
    ras.area  = 0;
    ras.cover = 0;
    ras.ex    = ex;
    ras.ey    = ey;
 
    ras.invalid = ( ey >= ras.max_ey || ey < ras.min_ey ||
                    ex >= ras.max_ex );
  }

Referenced by gray_move_to(), gray_render_line(), and gray_render_scanline().

gray_split_conic()

static void gray_split_conic ( FT_Vector *  base )

static

Definition at line 978 of file ftgrays.c.

  {
    TPos  a, b;
 
 
    base[4].x = base[2].x;
    b = base[1].x;
    a = base[3].x = ( base[2].x + b ) / 2;
    b = base[1].x = ( base[0].x + b ) / 2;
    base[2].x = ( a + b ) / 2;
 
    base[4].y = base[2].y;
    b = base[1].y;
    a = base[3].y = ( base[2].y + b ) / 2;
    b = base[1].y = ( base[0].y + b ) / 2;
    base[2].y = ( a + b ) / 2;
  }

Referenced by gray_render_conic().

gray_split_cubic()

static void gray_split_cubic ( FT_Vector *  base )

static

Definition at line 1063 of file ftgrays.c.

  {
    TPos  a, b, c, d;
 
 
    base[6].x = base[3].x;
    c = base[1].x;
    d = base[2].x;
    base[1].x = a = ( base[0].x + c ) / 2;
    base[5].x = b = ( base[3].x + d ) / 2;
    c = ( c + d ) / 2;
    base[2].x = a = ( a + c ) / 2;
    base[4].x = b = ( b + c ) / 2;
    base[3].x = ( a + b ) / 2;
 
    base[6].y = base[3].y;
    c = base[1].y;
    d = base[2].y;
    base[1].y = a = ( base[0].y + c ) / 2;
    base[5].y = b = ( base[3].y + d ) / 2;
    c = ( c + d ) / 2;
    base[2].y = a = ( a + c ) / 2;
    base[4].y = b = ( b + c ) / 2;
    base[3].y = ( a + b ) / 2;
  }

Referenced by gray_render_cubic().

gray_sweep()

static void gray_sweep ( RAS_ARG  )

static

Definition at line 1298 of file ftgrays.c.

  {
    int  y;
 
 
    for ( y = ras.min_ey; y < ras.max_ey; y++ )
    {
      PCell   cell  = ras.ycells[y - ras.min_ey];
      TCoord  x     = ras.min_ex;
      TArea   cover = 0;
      TArea   area;
 
 
      for ( ; cell != NULL; cell = cell->next )
      {
        if ( cover != 0 && cell->x > x )
          gray_hline( RAS_VAR_ x, y, cover, cell->x - x );
 
        cover += (TArea)cell->cover * ( ONE_PIXEL * 2 );
        area   = cover - cell->area;
 
        if ( area != 0 && cell->x >= ras.min_ex )
          gray_hline( RAS_VAR_ cell->x, y, area, 1 );
 
        x = cell->x + 1;
      }
 
      if ( cover != 0 )
        gray_hline( RAS_VAR_ x, y, cover, ras.max_ex - x );
    }
  }

Referenced by gray_convert_glyph().