ftgrays.c File Reference

#include "ftgrays.h"
#include <freetype/internal/ftobjs.h>
#include <freetype/internal/ftdebug.h>
#include <freetype/internal/ftcalc.h>
#include <freetype/ftoutln.h>
#include "ftsmerrs.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   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	FRACT(x)   (TCoord)( (x) & ( ONE_PIXEL - 1 ) )
#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	FT_MAX_GRAY_SPANS   10
#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
	if (ft_setjmp(ras.jump_buffer)==0)
	FT_TRACE7 (("band [%d..%d]: to be bisected\n", ras.min_ey, ras.max_ey))
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)

Variables
int	continued
	else
return	error

Macro Definition Documentation

DOWNSCALE

#define DOWNSCALE

(

x

)

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

Definition at line 345 of file ftgrays.c.

ErrRaster_Memory_Overflow

#define ErrRaster_Memory_Overflow   Smooth_Err_Out_Of_Memory

Definition at line 293 of file ftgrays.c.

FRACT

#define FRACT

(

x

)

(TCoord)( (x) & ( ONE_PIXEL - 1 ) )

Definition at line 341 of file ftgrays.c.

FT_COMPONENT

#define FT_COMPONENT   smooth

Definition at line 99 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 356 of file ftgrays.c.

FT_MAX_GRAY_POOL

#define FT_MAX_GRAY_POOL   ( 2048 / sizeof ( TCell ) )

Definition at line 433 of file ftgrays.c.

FT_MAX_GRAY_SPANS

#define FT_MAX_GRAY_SPANS   10

Definition at line 437 of file ftgrays.c.

FT_MEM_SET

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

Definition at line 300 of file ftgrays.c.

FT_MEM_ZERO

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

Definition at line 304 of file ftgrays.c.

FT_UDIV

#define FT_UDIV	(		a,
			b
	)

Value:

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

Definition at line 392 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 389 of file ftgrays.c.

FT_ZERO

#define FT_ZERO

(

p

)

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

Definition at line 308 of file ftgrays.c.

ONE_PIXEL

#define ONE_PIXEL   ( 1 << PIXEL_BITS )

Definition at line 339 of file ftgrays.c.

PIXEL_BITS

#define PIXEL_BITS   8

Definition at line 337 of file ftgrays.c.

ras

#define ras   (*worker)

Definition at line 483 of file ftgrays.c.

RAS_ARG

#define RAS_ARG   gray_PWorker worker

Definition at line 320 of file ftgrays.c.

RAS_ARG_

#define RAS_ARG_   gray_PWorker worker,

Definition at line 321 of file ftgrays.c.

RAS_VAR

#define RAS_VAR   worker

Definition at line 323 of file ftgrays.c.

RAS_VAR_

#define RAS_VAR_   worker,

Definition at line 324 of file ftgrays.c.

Smooth_Err_Invalid_Mode

#define Smooth_Err_Invalid_Mode   Smooth_Err_Cannot_Render_Glyph

Definition at line 291 of file ftgrays.c.

Smooth_Err_Memory_Overflow

#define Smooth_Err_Memory_Overflow   Smooth_Err_Out_Of_Memory

Definition at line 292 of file ftgrays.c.

TRUNC

#define TRUNC

(

x

)

(TCoord)( (x) >> PIXEL_BITS )

Definition at line 340 of file ftgrays.c.

UPSCALE

#define UPSCALE

(

x

)

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

Definition at line 344 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 411 of file ftgrays.c.

TArea

typedef int TArea

Definition at line 408 of file ftgrays.c.

TCell

typedef struct TCell_ TCell

TCoord

typedef int TCoord

Definition at line 407 of file ftgrays.c.

TPixmap

typedef struct TPixmap_ TPixmap

TPos

typedef long TPos

Definition at line 406 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
	)

FT_TRACE7()

FT_TRACE7

(

("band [%d..%d]: to be bisected\n", ras.min_ey, ras.max_ey)

)

gray_conic_to()

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

static

Definition at line 1189 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 1672 of file ftgrays.c.

  {
    const TCoord  yMin = ras.min_ey;
    const TCoord  yMax = ras.max_ey;
 
#ifdef __REACTOS__
    TCell   *buffer = malloc(FT_MAX_GRAY_POOL * sizeof(TCell));
    if (!buffer)
      return 1;
    {
#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;
 
    int  continued = 0;
 
 
    /* 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] = ras.min_ey;
      band[0] = ras.max_ey;
 
      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_ey    = band[1];
        ras.max_ey    = band[0];
 
        error     = gray_convert_glyph_inner( RAS_VAR, continued );
        continued = 1;
 
        if ( !error )
        {
          gray_sweep( RAS_VAR );
          band--;
          continue;
        }
        else if ( error != ErrRaster_Memory_Overflow )
#ifdef __REACTOS__
        {
          free(buffer);
          return 1;
        }
#else
          return 1;
#endif
 
        /* 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 1199 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 1210 of file ftgrays.c.

  {
    /* scale the coverage from 0..(ONE_PIXEL*ONE_PIXEL*2) to 0..256  */
    coverage >>= PIXEL_BITS * 2 + 1 - 8;
 
    /* 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  /* default non-zero winding rule */
    {
      if ( coverage < 0 )
        coverage = ~coverage;  /* the same as -coverage - 1 */
 
      if ( coverage >= 256 )
        coverage = 255;
    }
 
    if ( ras.num_spans >= 0 )  /* for FT_RASTER_FLAG_DIRECT only */
    {
      FT_Span*  span = ras.spans + ras.num_spans++;
 
 
      span->x        = (short)x;
      span->len      = (unsigned short)acount;
      span->coverage = (unsigned char)coverage;
 
      if ( ras.num_spans == FT_MAX_GRAY_SPANS )
      {
        /* flush the span buffer and reset the count */
        ras.render_span( y, ras.num_spans, ras.spans, ras.render_span_data );
        ras.num_spans = 0;
      }
    }
    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;
        /* fall through */
      case 6:
        *q++ = c;
        /* fall through */
      case 5:
        *q++ = c;
        /* fall through */
      case 4:
        *q++ = c;
        /* fall through */
      case 3:
        *q++ = c;
        /* fall through */
      case 2:
        *q++ = c;
        /* fall through */
      case 1:
        *q = c;
        /* fall through */
      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 1180 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 1161 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 1969 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 1950 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 1779 of file ftgrays.c.

  {
    const FT_Outline*  outline    = (const FT_Outline*)params->source;
    const FT_Bitmap*   target_map = params->target;
 
#ifndef FT_STATIC_RASTER
#ifdef __REACTOS__
    gray_TWorker *worker;
#else
    gray_TWorker  worker[1];
#endif
#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 );
 
#if !defined(FT_STATIC_RASTER) && defined(__REACTOS__)
    worker = malloc(sizeof(*worker));
    if (!worker)
      return FT_THROW(Out_Of_Memory);
#endif /* !defined(FT_STATIC_RASTER) && defined(__REACTOS__) */
 
    ras.outline = *outline;
 
    if ( params->flags & FT_RASTER_FLAG_DIRECT )
    {
      if ( !params->gray_spans )
#if !defined(FT_STATIC_RASTER) && defined(__REACTOS__)
      {
        free(worker);
        return 0;
      }
#else
        return 0;
#endif
 
      ras.render_span      = (FT_Raster_Span_Func)params->gray_spans;
      ras.render_span_data = params->user;
      ras.num_spans        = 0;
 
      ras.min_ex = params->clip_box.xMin;
      ras.min_ey = params->clip_box.yMin;
      ras.max_ex = params->clip_box.xMax;
      ras.max_ey = params->clip_box.yMax;
    }
    else
    {
      /* if direct mode is not set, we must have a target bitmap */
      if ( !target_map )
#if !defined(FT_STATIC_RASTER) && defined(__REACTOS__)
      {
        free(worker);
        return FT_THROW( Invalid_Argument );
      }
#else
        return FT_THROW( Invalid_Argument );
#endif
 
      /* nothing to do */
      if ( !target_map->width || !target_map->rows )
#if !defined(FT_STATIC_RASTER) && defined(__REACTOS__)
      {
        free(worker);
        return 0;
      }
#else
        return 0;
#endif
 
      if ( !target_map->buffer )
#if !defined(FT_STATIC_RASTER) && defined(__REACTOS__)
      {
        free(worker);
        return FT_THROW( Invalid_Argument );
      }
#else
        return FT_THROW( Invalid_Argument );
#endif
 
      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;
      ras.num_spans        = -1;  /* invalid */
 
      ras.min_ex = 0;
      ras.min_ey = 0;
      ras.max_ex = (FT_Pos)target_map->width;
      ras.max_ey = (FT_Pos)target_map->rows;
    }
 
    /* exit if nothing to do */
    if ( ras.max_ex <= ras.min_ex || ras.max_ey <= ras.min_ey )
#if !defined(FT_STATIC_RASTER) && defined(__REACTOS__)
    {
      free(worker);
      return 0;
    }
#else
      return 0;
#endif
 
#if !defined(FT_STATIC_RASTER) && defined(__REACTOS__)
    {
      FT_Error error = gray_convert_glyph( RAS_VAR );
      free(worker);
      return error;
    }
#else
    return gray_convert_glyph( RAS_VAR );
#endif
  }

gray_raster_reset()

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

static

Definition at line 1981 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 1992 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 528 of file ftgrays.c.

  {
    PCell  *pcell, cell;
    TCoord  x = ras.ex;
 
 
    pcell = &ras.ycells[ras.ey - ras.min_ey];
    while ( ( cell = *pcell ) )
    {
      if ( 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 gray_set_cell(), and if().

gray_render_conic()

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

static

Definition at line 1006 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 = draw & ( -draw );  /* isolate the rightmost 1-bit */
      while ( ( split >>= 1 ) )
      {
        gray_split_conic( arc );
        arc += 2;
      }
 
      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 1102 of file ftgrays.c.

  {
    FT_Vector   bez_stack[16 * 3 + 1];  /* enough to accommodate bisections */
    FT_Vector*  arc = bez_stack;
 
 
    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 (;;)
    {
      /* with each split, control points quickly converge towards  */
      /* chord trisection points and the vanishing distances below */
      /* indicate when the segment is flat enough to draw          */
      if ( FT_ABS( 2 * arc[0].x - 3 * arc[1].x + arc[3].x ) > ONE_PIXEL / 2 ||
           FT_ABS( 2 * arc[0].y - 3 * arc[1].y + arc[3].y ) > ONE_PIXEL / 2 ||
           FT_ABS( arc[0].x - 3 * arc[2].x + 2 * arc[3].x ) > ONE_PIXEL / 2 ||
           FT_ABS( arc[0].y - 3 * arc[2].y + 2 * arc[3].y ) > ONE_PIXEL / 2 )
        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 707 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 = FRACT( ras.y );
    fy2 = FRACT( to_y );
 
    /* 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 = FRACT( ras.x ) << 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;
    }
 
    /* the fractional part of x-delta is mod/dy. It is essential to */
    /* keep track of its accumulation for accurate rendering.       */
    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   = FRACT( x1 );
    fx2   = FRACT( x2 );
 
    /* 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;
    }
 
    /* the fractional part of y-delta is mod/dx. It is essential to */
    /* keep track of its accumulation for accurate rendering.       */
    /* XXX: y-delta and x-delta below should be related.            */
    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 572 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.                 */
 
    /* 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    = FT_MAX( ex, ras.min_ex - 1 );
    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 984 of file ftgrays.c.

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

Referenced by gray_render_conic().

gray_split_cubic()

static void gray_split_cubic ( FT_Vector *  base )

static

Definition at line 1070 of file ftgrays.c.

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

Referenced by gray_render_cubic().

gray_sweep()

static void gray_sweep ( RAS_ARG  )

static

Definition at line 1294 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 );
 
      if ( ras.num_spans > 0 )  /* for FT_RASTER_FLAG_DIRECT only */
      {
        /* flush the span buffer and reset the count */
        ras.render_span( y, ras.num_spans, ras.spans, ras.render_span_data );
        ras.num_spans = 0;
      }
    }
  }

Referenced by gray_convert_glyph().

if()

if

(

ft_setjmp(ras.jump_buffer)

= = 0

)

Definition at line 1642 of file ftgrays.c.

    {
      if ( continued )
        FT_Trace_Disable();
      error = FT_Outline_Decompose( &ras.outline, &func_interface, &ras );
      if ( continued )
        FT_Trace_Enable();
 
      if ( !ras.invalid )
        gray_record_cell( RAS_VAR );
 
      FT_TRACE7(( "band [%d..%d]: %ld cell%s\n",
                  ras.min_ey,
                  ras.max_ey,
                  ras.num_cells,
                  ras.num_cells == 1 ? "" : "s" ));
    }

Variable Documentation

continued

int continued

Initial value:

{
    int  error

Definition at line 1637 of file ftgrays.c.

Referenced by gray_convert_glyph(), and if().

else

else

Initial value:

{
      error = FT_THROW( Memory_Overflow )

Definition at line 1659 of file ftgrays.c.

error

return error

Definition at line 1667 of file ftgrays.c.

Referenced by gray_convert_glyph(), gray_raster_new(), gray_raster_render(), and if().