source: trunk/poppler/freetype2/src/smooth/ftgrays.c @ 251

Last change on this file since 251 was 251, checked in by Eugene Romanenko, 13 years ago

PDF plugin: freetype library updated to version 2.3.5

File size: 55.6 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  ftgrays.c                                                              */
4/*                                                                         */
5/*    A new `perfect' anti-aliasing renderer (body).                       */
6/*                                                                         */
7/*  Copyright 2000-2001, 2002, 2003, 2005, 2006, 2007 by                   */
8/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9/*                                                                         */
10/*  This file is part of the FreeType project, and may only be used,       */
11/*  modified, and distributed under the terms of the FreeType project      */
12/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
13/*  this file you indicate that you have read the license and              */
14/*  understand and accept it fully.                                        */
15/*                                                                         */
16/***************************************************************************/
17
18  /*************************************************************************/
19  /*                                                                       */
20  /* This file can be compiled without the rest of the FreeType engine, by */
21  /* defining the _STANDALONE_ macro when compiling it.  You also need to  */
22  /* put the files `ftgrays.h' and `ftimage.h' into the current            */
23  /* compilation directory.  Typically, you could do something like        */
24  /*                                                                       */
25  /* - copy `src/smooth/ftgrays.c' (this file) to your current directory   */
26  /*                                                                       */
27  /* - copy `include/freetype/ftimage.h' and `src/smooth/ftgrays.h' to the */
28  /*   same directory                                                      */
29  /*                                                                       */
30  /* - compile `ftgrays' with the _STANDALONE_ macro defined, as in        */
31  /*                                                                       */
32  /*     cc -c -D_STANDALONE_ ftgrays.c                                    */
33  /*                                                                       */
34  /* The renderer can be initialized with a call to                        */
35  /* `ft_gray_raster.raster_new'; an anti-aliased bitmap can be generated  */
36  /* with a call to `ft_gray_raster.raster_render'.                        */
37  /*                                                                       */
38  /* See the comments and documentation in the file `ftimage.h' for more   */
39  /* details on how the raster works.                                      */
40  /*                                                                       */
41  /*************************************************************************/
42
43  /*************************************************************************/
44  /*                                                                       */
45  /* This is a new anti-aliasing scan-converter for FreeType 2.  The       */
46  /* algorithm used here is _very_ different from the one in the standard  */
47  /* `ftraster' module.  Actually, `ftgrays' computes the _exact_          */
48  /* coverage of the outline on each pixel cell.                           */
49  /*                                                                       */
50  /* It is based on ideas that I initially found in Raph Levien's          */
51  /* excellent LibArt graphics library (see http://www.levien.com/libart   */
52  /* for more information, though the web pages do not tell anything       */
53  /* about the renderer; you'll have to dive into the source code to       */
54  /* understand how it works).                                             */
55  /*                                                                       */
56  /* Note, however, that this is a _very_ different implementation         */
57  /* compared to Raph's.  Coverage information is stored in a very         */
58  /* different way, and I don't use sorted vector paths.  Also, it doesn't */
59  /* use floating point values.                                            */
60  /*                                                                       */
61  /* This renderer has the following advantages:                           */
62  /*                                                                       */
63  /* - It doesn't need an intermediate bitmap.  Instead, one can supply a  */
64  /*   callback function that will be called by the renderer to draw gray  */
65  /*   spans on any target surface.  You can thus do direct composition on */
66  /*   any kind of bitmap, provided that you give the renderer the right   */
67  /*   callback.                                                           */
68  /*                                                                       */
69  /* - A perfect anti-aliaser, i.e., it computes the _exact_ coverage on   */
70  /*   each pixel cell.                                                    */
71  /*                                                                       */
72  /* - It performs a single pass on the outline (the `standard' FT2        */
73  /*   renderer makes two passes).                                         */
74  /*                                                                       */
75  /* - It can easily be modified to render to _any_ number of gray levels  */
76  /*   cheaply.                                                            */
77  /*                                                                       */
78  /* - For small (< 20) pixel sizes, it is faster than the standard        */
79  /*   renderer.                                                           */
80  /*                                                                       */
81  /*************************************************************************/
82
83
84  /*************************************************************************/
85  /*                                                                       */
86  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
87  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
88  /* messages during execution.                                            */
89  /*                                                                       */
90#undef  FT_COMPONENT
91#define FT_COMPONENT  trace_smooth
92
93
94
95
96#ifdef _STANDALONE_
97
98#include <string.h>             /* for ft_memcpy() */
99#include <setjmp.h>
100#include <limits.h>
101#define FT_UINT_MAX  UINT_MAX
102
103#define ft_memset   memset
104
105#define ft_setjmp   setjmp
106#define ft_longjmp  longjmp
107#define ft_jmp_buf  jmp_buf
108
109
110#define ErrRaster_Invalid_Mode      -2
111#define ErrRaster_Invalid_Outline   -1
112#define ErrRaster_Invalid_Argument  -3
113#define ErrRaster_Memory_Overflow   -4
114
115#define FT_BEGIN_HEADER
116#define FT_END_HEADER
117
118#include "ftimage.h"
119#include "ftgrays.h"
120
121  /* This macro is used to indicate that a function parameter is unused. */
122  /* Its purpose is simply to reduce compiler warnings.  Note also that  */
123  /* simply defining it as `(void)x' doesn't avoid warnings with certain */
124  /* ANSI compilers (e.g. LCC).                                          */
125#define FT_UNUSED( x )  (x) = (x)
126
127  /* Disable the tracing mechanism for simplicity -- developers can      */
128  /* activate it easily by redefining these two macros.                  */
129#ifndef FT_ERROR
130#define FT_ERROR( x )  do ; while ( 0 )     /* nothing */
131#endif
132
133#ifndef FT_TRACE
134#define FT_TRACE( x )  do ; while ( 0 )     /* nothing */
135#endif
136
137#else /* !_STANDALONE_ */
138
139#include <ft2build.h>
140#include "ftgrays.h"
141#include FT_INTERNAL_OBJECTS_H
142#include FT_INTERNAL_DEBUG_H
143#include FT_OUTLINE_H
144
145#include "ftsmerrs.h"
146
147#define ErrRaster_Invalid_Mode      Smooth_Err_Cannot_Render_Glyph
148#define ErrRaster_Invalid_Outline   Smooth_Err_Invalid_Outline
149#define ErrRaster_Memory_Overflow   Smooth_Err_Out_Of_Memory
150#define ErrRaster_Invalid_Argument  Smooth_Err_Bad_Argument
151
152#endif /* !_STANDALONE_ */
153
154
155#ifndef FT_MEM_SET
156#define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
157#endif
158
159#ifndef FT_MEM_ZERO
160#define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
161#endif
162
163  /* define this to dump debugging information */
164#define xxxDEBUG_GRAYS
165
166
167  /* as usual, for the speed hungry :-) */
168
169#ifndef FT_STATIC_RASTER
170
171
172#define RAS_ARG   PWorker  worker
173#define RAS_ARG_  PWorker  worker,
174
175#define RAS_VAR   worker
176#define RAS_VAR_  worker,
177
178#define ras       (*worker)
179
180
181#else /* FT_STATIC_RASTER */
182
183
184#define RAS_ARG   /* empty */
185#define RAS_ARG_  /* empty */
186#define RAS_VAR   /* empty */
187#define RAS_VAR_  /* empty */
188
189  static TWorker  ras;
190
191
192#endif /* FT_STATIC_RASTER */
193
194
195  /* must be at least 6 bits! */
196#define PIXEL_BITS  8
197
198#define ONE_PIXEL       ( 1L << PIXEL_BITS )
199#define PIXEL_MASK      ( -1L << PIXEL_BITS )
200#define TRUNC( x )      ( (TCoord)( (x) >> PIXEL_BITS ) )
201#define SUBPIXELS( x )  ( (TPos)(x) << PIXEL_BITS )
202#define FLOOR( x )      ( (x) & -ONE_PIXEL )
203#define CEILING( x )    ( ( (x) + ONE_PIXEL - 1 ) & -ONE_PIXEL )
204#define ROUND( x )      ( ( (x) + ONE_PIXEL / 2 ) & -ONE_PIXEL )
205
206#if PIXEL_BITS >= 6
207#define UPSCALE( x )    ( (x) << ( PIXEL_BITS - 6 ) )
208#define DOWNSCALE( x )  ( (x) >> ( PIXEL_BITS - 6 ) )
209#else
210#define UPSCALE( x )    ( (x) >> ( 6 - PIXEL_BITS ) )
211#define DOWNSCALE( x )  ( (x) << ( 6 - PIXEL_BITS ) )
212#endif
213
214
215  /*************************************************************************/
216  /*                                                                       */
217  /*   TYPE DEFINITIONS                                                    */
218  /*                                                                       */
219
220  /* don't change the following types to FT_Int or FT_Pos, since we might */
221  /* need to define them to "float" or "double" when experimenting with   */
222  /* new algorithms                                                       */
223
224  typedef int   TCoord;   /* integer scanline/pixel coordinate */
225  typedef long  TPos;     /* sub-pixel coordinate              */
226
227  /* determine the type used to store cell areas.  This normally takes at */
228  /* least PIXEL_BITS*2 + 1 bits.  On 16-bit systems, we need to use      */
229  /* `long' instead of `int', otherwise bad things happen                 */
230
231#if PIXEL_BITS <= 7
232
233  typedef int  TArea;
234
235#else /* PIXEL_BITS >= 8 */
236
237  /* approximately determine the size of integers using an ANSI-C header */
238#if FT_UINT_MAX == 0xFFFFU
239  typedef long  TArea;
240#else
241  typedef int   TArea;
242#endif
243
244#endif /* PIXEL_BITS >= 8 */
245
246
247  /* maximal number of gray spans in a call to the span callback */
248#define FT_MAX_GRAY_SPANS  32
249
250
251  typedef struct TCell_*  PCell;
252
253  typedef struct  TCell_
254  {
255    int    x;
256    int    cover;
257    TArea  area;
258    PCell  next;
259
260  } TCell;
261
262
263  typedef struct  TWorker_
264  {
265    TCoord  ex, ey;
266    TPos    min_ex, max_ex;
267    TPos    min_ey, max_ey;
268    TPos    count_ex, count_ey;
269
270    TArea   area;
271    int     cover;
272    int     invalid;
273
274    PCell   cells;
275    int     max_cells;
276    int     num_cells;
277
278    TCoord  cx, cy;
279    TPos    x,  y;
280
281    TPos    last_ey;
282
283    FT_Vector   bez_stack[32 * 3 + 1];
284    int         lev_stack[32];
285
286    FT_Outline  outline;
287    FT_Bitmap   target;
288    FT_BBox     clip_box;
289
290    FT_Span     gray_spans[FT_MAX_GRAY_SPANS];
291    int         num_gray_spans;
292
293    FT_Raster_Span_Func  render_span;
294    void*                render_span_data;
295    int                  span_y;
296
297    int  band_size;
298    int  band_shoot;
299    int  conic_level;
300    int  cubic_level;
301
302    ft_jmp_buf  jump_buffer;
303
304    void*       buffer;
305    long        buffer_size;
306
307    PCell*     ycells;
308    int        ycount;
309
310  } TWorker, *PWorker;
311
312
313  typedef struct TRaster_
314  {
315    void*    buffer;
316    long     buffer_size;
317    int      band_size;
318    void*    memory;
319    PWorker  worker;
320
321  } TRaster, *PRaster;
322
323
324
325  /*************************************************************************/
326  /*                                                                       */
327  /* Initialize the cells table.                                           */
328  /*                                                                       */
329  static void
330  gray_init_cells( RAS_ARG_ void*  buffer,
331                   long            byte_size )
332  {
333    ras.buffer      = buffer;
334    ras.buffer_size = byte_size;
335
336    ras.ycells      = (PCell*) buffer;
337    ras.cells       = NULL;
338    ras.max_cells   = 0;
339    ras.num_cells   = 0;
340    ras.area        = 0;
341    ras.cover       = 0;
342    ras.invalid     = 1;
343  }
344
345
346  /*************************************************************************/
347  /*                                                                       */
348  /* Compute the outline bounding box.                                     */
349  /*                                                                       */
350  static void
351  gray_compute_cbox( RAS_ARG )
352  {
353    FT_Outline*  outline = &ras.outline;
354    FT_Vector*   vec     = outline->points;
355    FT_Vector*   limit   = vec + outline->n_points;
356
357
358    if ( outline->n_points <= 0 )
359    {
360      ras.min_ex = ras.max_ex = 0;
361      ras.min_ey = ras.max_ey = 0;
362      return;
363    }
364
365    ras.min_ex = ras.max_ex = vec->x;
366    ras.min_ey = ras.max_ey = vec->y;
367
368    vec++;
369
370    for ( ; vec < limit; vec++ )
371    {
372      TPos  x = vec->x;
373      TPos  y = vec->y;
374
375
376      if ( x < ras.min_ex ) ras.min_ex = x;
377      if ( x > ras.max_ex ) ras.max_ex = x;
378      if ( y < ras.min_ey ) ras.min_ey = y;
379      if ( y > ras.max_ey ) ras.max_ey = y;
380    }
381
382    /* truncate the bounding box to integer pixels */
383    ras.min_ex = ras.min_ex >> 6;
384    ras.min_ey = ras.min_ey >> 6;
385    ras.max_ex = ( ras.max_ex + 63 ) >> 6;
386    ras.max_ey = ( ras.max_ey + 63 ) >> 6;
387  }
388
389
390  /*************************************************************************/
391  /*                                                                       */
392  /* Record the current cell in the table.                                 */
393  /*                                                                       */
394  static PCell
395  gray_find_cell( RAS_ARG )
396  {
397    PCell  *pcell, cell;
398    int     x = ras.ex;
399
400
401    if ( x > ras.max_ex )
402      x = ras.max_ex;
403
404    pcell = &ras.ycells[ras.ey];
405    for (;;)
406    {
407      cell = *pcell;
408      if ( cell == NULL || cell->x > x )
409        break;
410
411      if ( cell->x == x )
412        goto Exit;
413
414      pcell = &cell->next;
415    }
416
417    if ( ras.num_cells >= ras.max_cells )
418      ft_longjmp( ras.jump_buffer, 1 );
419
420    cell        = ras.cells + ras.num_cells++;
421    cell->x     = x;
422    cell->area  = 0;
423    cell->cover = 0;
424
425    cell->next  = *pcell;
426    *pcell      = cell;
427
428  Exit:
429    return cell;
430  }
431
432
433  static void
434  gray_record_cell( RAS_ARG )
435  {
436    if ( !ras.invalid && ( ras.area | ras.cover ) )
437    {
438      PCell  cell = gray_find_cell( RAS_VAR );
439
440
441      cell->area  += ras.area;
442      cell->cover += ras.cover;
443    }
444  }
445
446
447  /*************************************************************************/
448  /*                                                                       */
449  /* Set the current cell to a new position.                               */
450  /*                                                                       */
451  static void
452  gray_set_cell( RAS_ARG_ TCoord  ex,
453                          TCoord  ey )
454  {
455    /* Move the cell pointer to a new position.  We set the `invalid'      */
456    /* flag to indicate that the cell isn't part of those we're interested */
457    /* in during the render phase.  This means that:                       */
458    /*                                                                     */
459    /* . the new vertical position must be within min_ey..max_ey-1.        */
460    /* . the new horizontal position must be strictly less than max_ex     */
461    /*                                                                     */
462    /* Note that if a cell is to the left of the clipping region, it is    */
463    /* actually set to the (min_ex-1) horizontal position.                 */
464
465    /* All cells that are on the left of the clipping region go to the */
466    /* min_ex - 1 horizontal position.                                 */
467    ey -= ras.min_ey;
468
469    if ( ex > ras.max_ex )
470      ex = ras.max_ex;
471
472    ex -= ras.min_ex;
473    if ( ex < 0 )
474      ex = -1;
475
476    /* are we moving to a different cell ? */
477    if ( ex != ras.ex || ey != ras.ey )
478    {
479      /* record the current one if it is valid */
480      if ( !ras.invalid )
481        gray_record_cell( RAS_VAR );
482
483      ras.area  = 0;
484      ras.cover = 0;
485    }
486
487    ras.ex      = ex;
488    ras.ey      = ey;
489    ras.invalid = ( (unsigned)ey >= (unsigned)ras.count_ey ||
490                              ex >= ras.count_ex           );
491  }
492
493
494  /*************************************************************************/
495  /*                                                                       */
496  /* Start a new contour at a given cell.                                  */
497  /*                                                                       */
498  static void
499  gray_start_cell( RAS_ARG_ TCoord  ex,
500                            TCoord  ey )
501  {
502    if ( ex > ras.max_ex )
503      ex = (TCoord)( ras.max_ex );
504
505    if ( ex < ras.min_ex )
506      ex = (TCoord)( ras.min_ex - 1 );
507
508    ras.area    = 0;
509    ras.cover   = 0;
510    ras.ex      = ex - ras.min_ex;
511    ras.ey      = ey - ras.min_ey;
512    ras.last_ey = SUBPIXELS( ey );
513    ras.invalid = 0;
514
515    gray_set_cell( RAS_VAR_ ex, ey );
516  }
517
518
519  /*************************************************************************/
520  /*                                                                       */
521  /* Render a scanline as one or more cells.                               */
522  /*                                                                       */
523  static void
524  gray_render_scanline( RAS_ARG_ TCoord  ey,
525                                 TPos    x1,
526                                 TCoord  y1,
527                                 TPos    x2,
528                                 TCoord  y2 )
529  {
530    TCoord  ex1, ex2, fx1, fx2, delta;
531    long    p, first, dx;
532    int     incr, lift, mod, rem;
533
534
535    dx = x2 - x1;
536
537    ex1 = TRUNC( x1 );
538    ex2 = TRUNC( x2 );
539    fx1 = (TCoord)( x1 - SUBPIXELS( ex1 ) );
540    fx2 = (TCoord)( x2 - SUBPIXELS( ex2 ) );
541
542    /* trivial case.  Happens often */
543    if ( y1 == y2 )
544    {
545      gray_set_cell( RAS_VAR_ ex2, ey );
546      return;
547    }
548
549    /* everything is located in a single cell.  That is easy! */
550    /*                                                        */
551    if ( ex1 == ex2 )
552    {
553      delta      = y2 - y1;
554      ras.area  += (TArea)( fx1 + fx2 ) * delta;
555      ras.cover += delta;
556      return;
557    }
558
559    /* ok, we'll have to render a run of adjacent cells on the same */
560    /* scanline...                                                  */
561    /*                                                              */
562    p     = ( ONE_PIXEL - fx1 ) * ( y2 - y1 );
563    first = ONE_PIXEL;
564    incr  = 1;
565
566    if ( dx < 0 )
567    {
568      p     = fx1 * ( y2 - y1 );
569      first = 0;
570      incr  = -1;
571      dx    = -dx;
572    }
573
574    delta = (TCoord)( p / dx );
575    mod   = (TCoord)( p % dx );
576    if ( mod < 0 )
577    {
578      delta--;
579      mod += (TCoord)dx;
580    }
581
582    ras.area  += (TArea)( fx1 + first ) * delta;
583    ras.cover += delta;
584
585    ex1 += incr;
586    gray_set_cell( RAS_VAR_ ex1, ey );
587    y1  += delta;
588
589    if ( ex1 != ex2 )
590    {
591      p    = ONE_PIXEL * ( y2 - y1 + delta );
592      lift = (TCoord)( p / dx );
593      rem  = (TCoord)( p % dx );
594      if ( rem < 0 )
595      {
596        lift--;
597        rem += (TCoord)dx;
598      }
599
600      mod -= (int)dx;
601
602      while ( ex1 != ex2 )
603      {
604        delta = lift;
605        mod  += rem;
606        if ( mod >= 0 )
607        {
608          mod -= (TCoord)dx;
609          delta++;
610        }
611
612        ras.area  += (TArea)ONE_PIXEL * delta;
613        ras.cover += delta;
614        y1        += delta;
615        ex1       += incr;
616        gray_set_cell( RAS_VAR_ ex1, ey );
617      }
618    }
619
620    delta      = y2 - y1;
621    ras.area  += (TArea)( fx2 + ONE_PIXEL - first ) * delta;
622    ras.cover += delta;
623  }
624
625
626  /*************************************************************************/
627  /*                                                                       */
628  /* Render a given line as a series of scanlines.                         */
629  /*                                                                       */
630  static void
631  gray_render_line( RAS_ARG_ TPos  to_x,
632                             TPos  to_y )
633  {
634    TCoord  ey1, ey2, fy1, fy2;
635    TPos    dx, dy, x, x2;
636    long    p, first;
637    int     delta, rem, mod, lift, incr;
638
639
640    ey1 = TRUNC( ras.last_ey );
641    ey2 = TRUNC( to_y );     /* if (ey2 >= ras.max_ey) ey2 = ras.max_ey-1; */
642    fy1 = (TCoord)( ras.y - ras.last_ey );
643    fy2 = (TCoord)( to_y - SUBPIXELS( ey2 ) );
644
645    dx = to_x - ras.x;
646    dy = to_y - ras.y;
647
648    /* XXX: we should do something about the trivial case where dx == 0, */
649    /*      as it happens very often!                                    */
650
651    /* perform vertical clipping */
652    {
653      TCoord  min, max;
654
655
656      min = ey1;
657      max = ey2;
658      if ( ey1 > ey2 )
659      {
660        min = ey2;
661        max = ey1;
662      }
663      if ( min >= ras.max_ey || max < ras.min_ey )
664        goto End;
665    }
666
667    /* everything is on a single scanline */
668    if ( ey1 == ey2 )
669    {
670      gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, to_x, fy2 );
671      goto End;
672    }
673
674    /* vertical line - avoid calling gray_render_scanline */
675    incr = 1;
676
677    if ( dx == 0 )
678    {
679      TCoord  ex     = TRUNC( ras.x );
680      TCoord  two_fx = (TCoord)( ( ras.x - SUBPIXELS( ex ) ) << 1 );
681      TPos    area;
682
683
684      first = ONE_PIXEL;
685      if ( dy < 0 )
686      {
687        first = 0;
688        incr  = -1;
689      }
690
691      delta      = (int)( first - fy1 );
692      ras.area  += (TArea)two_fx * delta;
693      ras.cover += delta;
694      ey1       += incr;
695
696      gray_set_cell( &ras, ex, ey1 );
697
698      delta = (int)( first + first - ONE_PIXEL );
699      area  = (TArea)two_fx * delta;
700      while ( ey1 != ey2 )
701      {
702        ras.area  += area;
703        ras.cover += delta;
704        ey1       += incr;
705
706        gray_set_cell( &ras, ex, ey1 );
707      }
708
709      delta      = (int)( fy2 - ONE_PIXEL + first );
710      ras.area  += (TArea)two_fx * delta;
711      ras.cover += delta;
712
713      goto End;
714    }
715
716    /* ok, we have to render several scanlines */
717    p     = ( ONE_PIXEL - fy1 ) * dx;
718    first = ONE_PIXEL;
719    incr  = 1;
720
721    if ( dy < 0 )
722    {
723      p     = fy1 * dx;
724      first = 0;
725      incr  = -1;
726      dy    = -dy;
727    }
728
729    delta = (int)( p / dy );
730    mod   = (int)( p % dy );
731    if ( mod < 0 )
732    {
733      delta--;
734      mod += (TCoord)dy;
735    }
736
737    x = ras.x + delta;
738    gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, (TCoord)first );
739
740    ey1 += incr;
741    gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
742
743    if ( ey1 != ey2 )
744    {
745      p     = ONE_PIXEL * dx;
746      lift  = (int)( p / dy );
747      rem   = (int)( p % dy );
748      if ( rem < 0 )
749      {
750        lift--;
751        rem += (int)dy;
752      }
753      mod -= (int)dy;
754
755      while ( ey1 != ey2 )
756      {
757        delta = lift;
758        mod  += rem;
759        if ( mod >= 0 )
760        {
761          mod -= (int)dy;
762          delta++;
763        }
764
765        x2 = x + delta;
766        gray_render_scanline( RAS_VAR_ ey1, x,
767                                       (TCoord)( ONE_PIXEL - first ), x2,
768                                       (TCoord)first );
769        x = x2;
770
771        ey1 += incr;
772        gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
773      }
774    }
775
776    gray_render_scanline( RAS_VAR_ ey1, x,
777                                   (TCoord)( ONE_PIXEL - first ), to_x,
778                                   fy2 );
779
780  End:
781    ras.x       = to_x;
782    ras.y       = to_y;
783    ras.last_ey = SUBPIXELS( ey2 );
784  }
785
786
787  static void
788  gray_split_conic( FT_Vector*  base )
789  {
790    TPos  a, b;
791
792
793    base[4].x = base[2].x;
794    b = base[1].x;
795    a = base[3].x = ( base[2].x + b ) / 2;
796    b = base[1].x = ( base[0].x + b ) / 2;
797    base[2].x = ( a + b ) / 2;
798
799    base[4].y = base[2].y;
800    b = base[1].y;
801    a = base[3].y = ( base[2].y + b ) / 2;
802    b = base[1].y = ( base[0].y + b ) / 2;
803    base[2].y = ( a + b ) / 2;
804  }
805
806
807  static void
808  gray_render_conic( RAS_ARG_ const FT_Vector*  control,
809                              const FT_Vector*  to )
810  {
811    TPos        dx, dy;
812    int         top, level;
813    int*        levels;
814    FT_Vector*  arc;
815
816
817    dx = DOWNSCALE( ras.x ) + to->x - ( control->x << 1 );
818    if ( dx < 0 )
819      dx = -dx;
820    dy = DOWNSCALE( ras.y ) + to->y - ( control->y << 1 );
821    if ( dy < 0 )
822      dy = -dy;
823    if ( dx < dy )
824      dx = dy;
825
826    level = 1;
827    dx = dx / ras.conic_level;
828    while ( dx > 0 )
829    {
830      dx >>= 2;
831      level++;
832    }
833
834    /* a shortcut to speed things up */
835    if ( level <= 1 )
836    {
837      /* we compute the mid-point directly in order to avoid */
838      /* calling gray_split_conic()                          */
839      TPos  to_x, to_y, mid_x, mid_y;
840
841
842      to_x  = UPSCALE( to->x );
843      to_y  = UPSCALE( to->y );
844      mid_x = ( ras.x + to_x + 2 * UPSCALE( control->x ) ) / 4;
845      mid_y = ( ras.y + to_y + 2 * UPSCALE( control->y ) ) / 4;
846
847      gray_render_line( RAS_VAR_ mid_x, mid_y );
848      gray_render_line( RAS_VAR_ to_x, to_y );
849
850      return;
851    }
852
853    arc       = ras.bez_stack;
854    levels    = ras.lev_stack;
855    top       = 0;
856    levels[0] = level;
857
858    arc[0].x = UPSCALE( to->x );
859    arc[0].y = UPSCALE( to->y );
860    arc[1].x = UPSCALE( control->x );
861    arc[1].y = UPSCALE( control->y );
862    arc[2].x = ras.x;
863    arc[2].y = ras.y;
864
865    while ( top >= 0 )
866    {
867      level = levels[top];
868      if ( level > 1 )
869      {
870        /* check that the arc crosses the current band */
871        TPos  min, max, y;
872
873
874        min = max = arc[0].y;
875
876        y = arc[1].y;
877        if ( y < min ) min = y;
878        if ( y > max ) max = y;
879
880        y = arc[2].y;
881        if ( y < min ) min = y;
882        if ( y > max ) max = y;
883
884        if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < ras.min_ey )
885          goto Draw;
886
887        gray_split_conic( arc );
888        arc += 2;
889        top++;
890        levels[top] = levels[top - 1] = level - 1;
891        continue;
892      }
893
894    Draw:
895      {
896        TPos  to_x, to_y, mid_x, mid_y;
897
898
899        to_x  = arc[0].x;
900        to_y  = arc[0].y;
901        mid_x = ( ras.x + to_x + 2 * arc[1].x ) / 4;
902        mid_y = ( ras.y + to_y + 2 * arc[1].y ) / 4;
903
904        gray_render_line( RAS_VAR_ mid_x, mid_y );
905        gray_render_line( RAS_VAR_ to_x, to_y );
906
907        top--;
908        arc -= 2;
909      }
910    }
911
912    return;
913  }
914
915
916  static void
917  gray_split_cubic( FT_Vector*  base )
918  {
919    TPos  a, b, c, d;
920
921
922    base[6].x = base[3].x;
923    c = base[1].x;
924    d = base[2].x;
925    base[1].x = a = ( base[0].x + c ) / 2;
926    base[5].x = b = ( base[3].x + d ) / 2;
927    c = ( c + d ) / 2;
928    base[2].x = a = ( a + c ) / 2;
929    base[4].x = b = ( b + c ) / 2;
930    base[3].x = ( a + b ) / 2;
931
932    base[6].y = base[3].y;
933    c = base[1].y;
934    d = base[2].y;
935    base[1].y = a = ( base[0].y + c ) / 2;
936    base[5].y = b = ( base[3].y + d ) / 2;
937    c = ( c + d ) / 2;
938    base[2].y = a = ( a + c ) / 2;
939    base[4].y = b = ( b + c ) / 2;
940    base[3].y = ( a + b ) / 2;
941  }
942
943
944  static void
945  gray_render_cubic( RAS_ARG_ const FT_Vector*  control1,
946                              const FT_Vector*  control2,
947                              const FT_Vector*  to )
948  {
949    TPos        dx, dy, da, db;
950    int         top, level;
951    int*        levels;
952    FT_Vector*  arc;
953
954
955    dx = DOWNSCALE( ras.x ) + to->x - ( control1->x << 1 );
956    if ( dx < 0 )
957      dx = -dx;
958    dy = DOWNSCALE( ras.y ) + to->y - ( control1->y << 1 );
959    if ( dy < 0 )
960      dy = -dy;
961    if ( dx < dy )
962      dx = dy;
963    da = dx;
964
965    dx = DOWNSCALE( ras.x ) + to->x - 3 * ( control1->x + control2->x );
966    if ( dx < 0 )
967      dx = -dx;
968    dy = DOWNSCALE( ras.y ) + to->y - 3 * ( control1->x + control2->y );
969    if ( dy < 0 )
970      dy = -dy;
971    if ( dx < dy )
972      dx = dy;
973    db = dx;
974
975    level = 1;
976    da    = da / ras.cubic_level;
977    db    = db / ras.conic_level;
978    while ( da > 0 || db > 0 )
979    {
980      da >>= 2;
981      db >>= 3;
982      level++;
983    }
984
985    if ( level <= 1 )
986    {
987      TPos   to_x, to_y, mid_x, mid_y;
988
989
990      to_x  = UPSCALE( to->x );
991      to_y  = UPSCALE( to->y );
992      mid_x = ( ras.x + to_x +
993                3 * UPSCALE( control1->x + control2->x ) ) / 8;
994      mid_y = ( ras.y + to_y +
995                3 * UPSCALE( control1->y + control2->y ) ) / 8;
996
997      gray_render_line( RAS_VAR_ mid_x, mid_y );
998      gray_render_line( RAS_VAR_ to_x, to_y );
999      return;
1000    }
1001
1002    arc      = ras.bez_stack;
1003    arc[0].x = UPSCALE( to->x );
1004    arc[0].y = UPSCALE( to->y );
1005    arc[1].x = UPSCALE( control2->x );
1006    arc[1].y = UPSCALE( control2->y );
1007    arc[2].x = UPSCALE( control1->x );
1008    arc[2].y = UPSCALE( control1->y );
1009    arc[3].x = ras.x;
1010    arc[3].y = ras.y;
1011
1012    levels    = ras.lev_stack;
1013    top       = 0;
1014    levels[0] = level;
1015
1016    while ( top >= 0 )
1017    {
1018      level = levels[top];
1019      if ( level > 1 )
1020      {
1021        /* check that the arc crosses the current band */
1022        TPos  min, max, y;
1023
1024
1025        min = max = arc[0].y;
1026        y = arc[1].y;
1027        if ( y < min ) min = y;
1028        if ( y > max ) max = y;
1029        y = arc[2].y;
1030        if ( y < min ) min = y;
1031        if ( y > max ) max = y;
1032        y = arc[3].y;
1033        if ( y < min ) min = y;
1034        if ( y > max ) max = y;
1035        if ( TRUNC( min ) >= ras.max_ey || TRUNC( max ) < 0 )
1036          goto Draw;
1037        gray_split_cubic( arc );
1038        arc += 3;
1039        top ++;
1040        levels[top] = levels[top - 1] = level - 1;
1041        continue;
1042      }
1043
1044    Draw:
1045      {
1046        TPos  to_x, to_y, mid_x, mid_y;
1047
1048
1049        to_x  = arc[0].x;
1050        to_y  = arc[0].y;
1051        mid_x = ( ras.x + to_x + 3 * ( arc[1].x + arc[2].x ) ) / 8;
1052        mid_y = ( ras.y + to_y + 3 * ( arc[1].y + arc[2].y ) ) / 8;
1053
1054        gray_render_line( RAS_VAR_ mid_x, mid_y );
1055        gray_render_line( RAS_VAR_ to_x, to_y );
1056        top --;
1057        arc -= 3;
1058      }
1059    }
1060
1061    return;
1062  }
1063
1064
1065
1066  static int
1067  gray_move_to( const FT_Vector*  to,
1068                PWorker           worker )
1069  {
1070    TPos  x, y;
1071
1072
1073    /* record current cell, if any */
1074    gray_record_cell( worker );
1075
1076    /* start to a new position */
1077    x = UPSCALE( to->x );
1078    y = UPSCALE( to->y );
1079
1080    gray_start_cell( worker, TRUNC( x ), TRUNC( y ) );
1081
1082    worker->x = x;
1083    worker->y = y;
1084    return 0;
1085  }
1086
1087
1088  static int
1089  gray_line_to( const FT_Vector*  to,
1090                PWorker           worker )
1091  {
1092    gray_render_line( worker, UPSCALE( to->x ), UPSCALE( to->y ) );
1093    return 0;
1094  }
1095
1096
1097  static int
1098  gray_conic_to( const FT_Vector*  control,
1099                 const FT_Vector*  to,
1100                 PWorker           worker )
1101  {
1102    gray_render_conic( worker, control, to );
1103    return 0;
1104  }
1105
1106
1107  static int
1108  gray_cubic_to( const FT_Vector*  control1,
1109                 const FT_Vector*  control2,
1110                 const FT_Vector*  to,
1111                 PWorker           worker )
1112  {
1113    gray_render_cubic( worker, control1, control2, to );
1114    return 0;
1115  }
1116
1117
1118  static void
1119  gray_render_span( int             y,
1120                    int             count,
1121                    const FT_Span*  spans,
1122                    PWorker         worker )
1123  {
1124    unsigned char*  p;
1125    FT_Bitmap*      map = &worker->target;
1126
1127
1128    /* first of all, compute the scanline offset */
1129    p = (unsigned char*)map->buffer - y * map->pitch;
1130    if ( map->pitch >= 0 )
1131      p += ( map->rows - 1 ) * map->pitch;
1132
1133    for ( ; count > 0; count--, spans++ )
1134    {
1135      unsigned char  coverage = spans->coverage;
1136
1137
1138      if ( coverage )
1139      {
1140        /* For small-spans it is faster to do it by ourselves than
1141         * calling `memset'.  This is mainly due to the cost of the
1142         * function call.
1143         */
1144        if ( spans->len >= 8 )
1145          FT_MEM_SET( p + spans->x, (unsigned char)coverage, spans->len );
1146        else
1147        {
1148          unsigned char*  q = p + spans->x;
1149
1150
1151          switch ( spans->len )
1152          {
1153          case 7: *q++ = (unsigned char)coverage;
1154          case 6: *q++ = (unsigned char)coverage;
1155          case 5: *q++ = (unsigned char)coverage;
1156          case 4: *q++ = (unsigned char)coverage;
1157          case 3: *q++ = (unsigned char)coverage;
1158          case 2: *q++ = (unsigned char)coverage;
1159          case 1: *q   = (unsigned char)coverage;
1160          default:
1161            ;
1162          }
1163        }
1164      }
1165    }
1166  }
1167
1168
1169  static void
1170  gray_hline( RAS_ARG_ TCoord  x,
1171                       TCoord  y,
1172                       TPos    area,
1173                       int     acount )
1174  {
1175    FT_Span*  span;
1176    int       count;
1177    int       coverage;
1178
1179
1180    /* compute the coverage line's coverage, depending on the    */
1181    /* outline fill rule                                         */
1182    /*                                                           */
1183    /* the coverage percentage is area/(PIXEL_BITS*PIXEL_BITS*2) */
1184    /*                                                           */
1185    coverage = (int)( area >> ( PIXEL_BITS * 2 + 1 - 8 ) );
1186                                                    /* use range 0..256 */
1187    if ( coverage < 0 )
1188      coverage = -coverage;
1189
1190    if ( ras.outline.flags & FT_OUTLINE_EVEN_ODD_FILL )
1191    {
1192      coverage &= 511;
1193
1194      if ( coverage > 256 )
1195        coverage = 512 - coverage;
1196      else if ( coverage == 256 )
1197        coverage = 255;
1198    }
1199    else
1200    {
1201      /* normal non-zero winding rule */
1202      if ( coverage >= 256 )
1203        coverage = 255;
1204    }
1205
1206    y += (TCoord)ras.min_ey;
1207    x += (TCoord)ras.min_ex;
1208
1209    /* FT_Span.x is a 16-bit short, so limit our coordinates appropriately */
1210    if ( x >= 32768 )
1211      x = 32767;
1212
1213    if ( coverage )
1214    {
1215      /* see whether we can add this span to the current list */
1216      count = ras.num_gray_spans;
1217      span  = ras.gray_spans + count - 1;
1218      if ( count > 0                          &&
1219           ras.span_y == y                    &&
1220           (int)span->x + span->len == (int)x &&
1221           span->coverage == coverage         )
1222      {
1223        span->len = (unsigned short)( span->len + acount );
1224        return;
1225      }
1226
1227      if ( ras.span_y != y || count >= FT_MAX_GRAY_SPANS )
1228      {
1229        if ( ras.render_span && count > 0 )
1230          ras.render_span( ras.span_y, count, ras.gray_spans,
1231                           ras.render_span_data );
1232        /* ras.render_span( span->y, ras.gray_spans, count ); */
1233
1234#ifdef DEBUG_GRAYS
1235
1236        if ( ras.span_y >= 0 )
1237        {
1238          int  n;
1239
1240
1241          fprintf( stderr, "y=%3d ", ras.span_y );
1242          span = ras.gray_spans;
1243          for ( n = 0; n < count; n++, span++ )
1244            fprintf( stderr, "[%d..%d]:%02x ",
1245                     span->x, span->x + span->len - 1, span->coverage );
1246          fprintf( stderr, "\n" );
1247        }
1248
1249#endif /* DEBUG_GRAYS */
1250
1251        ras.num_gray_spans = 0;
1252        ras.span_y         = y;
1253
1254        count = 0;
1255        span  = ras.gray_spans;
1256      }
1257      else
1258        span++;
1259
1260      /* add a gray span to the current list */
1261      span->x        = (short)x;
1262      span->len      = (unsigned short)acount;
1263      span->coverage = (unsigned char)coverage;
1264
1265      ras.num_gray_spans++;
1266    }
1267  }
1268
1269
1270#ifdef DEBUG_GRAYS
1271
1272  /* to be called while in the debugger */
1273  gray_dump_cells( RAS_ARG )
1274  {
1275    int  yindex;
1276
1277
1278    for ( yindex = 0; yindex < ras.ycount; yindex++ )
1279    {
1280      PCell  cell;
1281
1282
1283      printf( "%3d:", yindex );
1284
1285      for ( cell = ras.ycells[yindex]; cell != NULL; cell = cell->next )
1286        printf( " (%3d, c:%4d, a:%6d)", cell->x, cell->cover, cell->area );
1287      printf( "\n" );
1288    }
1289  }
1290
1291#endif /* DEBUG_GRAYS */
1292
1293
1294  static void
1295  gray_sweep( RAS_ARG_ const FT_Bitmap*  target )
1296  {
1297    int  yindex;
1298
1299    FT_UNUSED( target );
1300
1301
1302    if ( ras.num_cells == 0 )
1303      return;
1304
1305    ras.num_gray_spans = 0;
1306
1307    for ( yindex = 0; yindex < ras.ycount; yindex++ )
1308    {
1309      PCell   cell  = ras.ycells[yindex];
1310      TCoord  cover = 0;
1311      TCoord  x     = 0;
1312
1313
1314      for ( ; cell != NULL; cell = cell->next )
1315      {
1316        TArea  area;
1317
1318
1319        if ( cell->x > x && cover != 0 )
1320          gray_hline( RAS_VAR_ x, yindex, cover * ( ONE_PIXEL * 2 ),
1321                      cell->x - x );
1322
1323        cover += cell->cover;
1324        area   = cover * ( ONE_PIXEL * 2 ) - cell->area;
1325
1326        if ( area != 0 && cell->x >= 0 )
1327          gray_hline( RAS_VAR_ cell->x, yindex, area, 1 );
1328
1329        x = cell->x + 1;
1330      }
1331
1332      if ( cover != 0 )
1333        gray_hline( RAS_VAR_ x, yindex, cover * ( ONE_PIXEL * 2 ),
1334                    ras.count_ex - x );
1335    }
1336
1337    if ( ras.render_span && ras.num_gray_spans > 0 )
1338      ras.render_span( ras.span_y, ras.num_gray_spans,
1339                       ras.gray_spans, ras.render_span_data );
1340  }
1341
1342
1343#ifdef _STANDALONE_
1344
1345  /*************************************************************************/
1346  /*                                                                       */
1347  /*  The following function should only compile in stand_alone mode,      */
1348  /*  i.e., when building this component without the rest of FreeType.     */
1349  /*                                                                       */
1350  /*************************************************************************/
1351
1352  /*************************************************************************/
1353  /*                                                                       */
1354  /* <Function>                                                            */
1355  /*    FT_Outline_Decompose                                               */
1356  /*                                                                       */
1357  /* <Description>                                                         */
1358  /*    Walks over an outline's structure to decompose it into individual  */
1359  /*    segments and Bezier arcs.  This function is also able to emit      */
1360  /*    `move to' and `close to' operations to indicate the start and end  */
1361  /*    of new contours in the outline.                                    */
1362  /*                                                                       */
1363  /* <Input>                                                               */
1364  /*    outline        :: A pointer to the source target.                  */
1365  /*                                                                       */
1366  /*    func_interface :: A table of `emitters', i.e,. function pointers   */
1367  /*                      called during decomposition to indicate path     */
1368  /*                      operations.                                      */
1369  /*                                                                       */
1370  /*    user           :: A typeless pointer which is passed to each       */
1371  /*                      emitter during the decomposition.  It can be     */
1372  /*                      used to store the state during the               */
1373  /*                      decomposition.                                   */
1374  /*                                                                       */
1375  /* <Return>                                                              */
1376  /*    Error code.  0 means success.                                      */
1377  /*                                                                       */
1378  static
1379  int  FT_Outline_Decompose( const FT_Outline*        outline,
1380                             const FT_Outline_Funcs*  func_interface,
1381                             void*                    user )
1382  {
1383#undef SCALED
1384#if 0
1385#define SCALED( x )  ( ( (x) << shift ) - delta )
1386#else
1387#define SCALED( x )  (x)
1388#endif
1389
1390    FT_Vector   v_last;
1391    FT_Vector   v_control;
1392    FT_Vector   v_start;
1393
1394    FT_Vector*  point;
1395    FT_Vector*  limit;
1396    char*       tags;
1397
1398    int   n;         /* index of contour in outline     */
1399    int   first;     /* index of first point in contour */
1400    int   error;
1401    char  tag;       /* current point's state           */
1402
1403#if 0
1404    int   shift = func_interface->shift;
1405    TPos  delta = func_interface->delta;
1406#endif
1407
1408
1409    first = 0;
1410
1411    for ( n = 0; n < outline->n_contours; n++ )
1412    {
1413      int  last;  /* index of last point in contour */
1414
1415
1416      last  = outline->contours[n];
1417      limit = outline->points + last;
1418
1419      v_start = outline->points[first];
1420      v_last  = outline->points[last];
1421
1422      v_start.x = SCALED( v_start.x );
1423      v_start.y = SCALED( v_start.y );
1424
1425      v_last.= SCALED( v_last.x );
1426      v_last.= SCALED( v_last.y );
1427
1428      v_control = v_start;
1429
1430      point = outline->points + first;
1431      tags  = outline->tags  + first;
1432      tag   = FT_CURVE_TAG( tags[0] );
1433
1434      /* A contour cannot start with a cubic control point! */
1435      if ( tag == FT_CURVE_TAG_CUBIC )
1436        goto Invalid_Outline;
1437
1438      /* check first point to determine origin */
1439      if ( tag == FT_CURVE_TAG_CONIC )
1440      {
1441        /* first point is conic control.  Yes, this happens. */
1442        if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON )
1443        {
1444          /* start at last point if it is on the curve */
1445          v_start = v_last;
1446          limit--;
1447        }
1448        else
1449        {
1450          /* if both first and last points are conic,         */
1451          /* start at their middle and record its position    */
1452          /* for closure                                      */
1453          v_start.x = ( v_start.x + v_last.x ) / 2;
1454          v_start.y = ( v_start.y + v_last.y ) / 2;
1455
1456          v_last = v_start;
1457        }
1458        point--;
1459        tags--;
1460      }
1461
1462      error = func_interface->move_to( &v_start, user );
1463      if ( error )
1464        goto Exit;
1465
1466      while ( point < limit )
1467      {
1468        point++;
1469        tags++;
1470
1471        tag = FT_CURVE_TAG( tags[0] );
1472        switch ( tag )
1473        {
1474        case FT_CURVE_TAG_ON:  /* emit a single line_to */
1475          {
1476            FT_Vector  vec;
1477
1478
1479            vec.x = SCALED( point->x );
1480            vec.y = SCALED( point->y );
1481
1482            error = func_interface->line_to( &vec, user );
1483            if ( error )
1484              goto Exit;
1485            continue;
1486          }
1487
1488        case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
1489          {
1490            v_control.x = SCALED( point->x );
1491            v_control.y = SCALED( point->y );
1492
1493          Do_Conic:
1494            if ( point < limit )
1495            {
1496              FT_Vector  vec;
1497              FT_Vector  v_middle;
1498
1499
1500              point++;
1501              tags++;
1502              tag = FT_CURVE_TAG( tags[0] );
1503
1504              vec.x = SCALED( point->x );
1505              vec.y = SCALED( point->y );
1506
1507              if ( tag == FT_CURVE_TAG_ON )
1508              {
1509                error = func_interface->conic_to( &v_control, &vec,
1510                                                  user );
1511                if ( error )
1512                  goto Exit;
1513                continue;
1514              }
1515
1516              if ( tag != FT_CURVE_TAG_CONIC )
1517                goto Invalid_Outline;
1518
1519              v_middle.x = ( v_control.x + vec.x ) / 2;
1520              v_middle.y = ( v_control.y + vec.y ) / 2;
1521
1522              error = func_interface->conic_to( &v_control, &v_middle,
1523                                                user );
1524              if ( error )
1525                goto Exit;
1526
1527              v_control = vec;
1528              goto Do_Conic;
1529            }
1530
1531            error = func_interface->conic_to( &v_control, &v_start,
1532                                              user );
1533            goto Close;
1534          }
1535
1536        default:  /* FT_CURVE_TAG_CUBIC */
1537          {
1538            FT_Vector  vec1, vec2;
1539
1540
1541            if ( point + 1 > limit                             ||
1542                 FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
1543              goto Invalid_Outline;
1544
1545            point += 2;
1546            tags  += 2;
1547
1548            vec1.x = SCALED( point[-2].x );
1549            vec1.y = SCALED( point[-2].y );
1550
1551            vec2.x = SCALED( point[-1].x );
1552            vec2.y = SCALED( point[-1].y );
1553
1554            if ( point <= limit )
1555            {
1556              FT_Vector  vec;
1557
1558
1559              vec.x = SCALED( point->x );
1560              vec.y = SCALED( point->y );
1561
1562              error = func_interface->cubic_to( &vec1, &vec2, &vec, user );
1563              if ( error )
1564                goto Exit;
1565              continue;
1566            }
1567
1568            error = func_interface->cubic_to( &vec1, &vec2, &v_start, user );
1569            goto Close;
1570          }
1571        }
1572      }
1573
1574      /* close the contour with a line segment */
1575      error = func_interface->line_to( &v_start, user );
1576
1577   Close:
1578      if ( error )
1579        goto Exit;
1580
1581      first = last + 1;
1582    }
1583
1584    return 0;
1585
1586  Exit:
1587    return error;
1588
1589  Invalid_Outline:
1590    return ErrRaster_Invalid_Outline;
1591  }
1592
1593#endif /* _STANDALONE_ */
1594
1595
1596  typedef struct  TBand_
1597  {
1598    TPos  min, max;
1599
1600  } TBand;
1601
1602
1603  static int
1604  gray_convert_glyph_inner( RAS_ARG )
1605  {
1606    static
1607    const FT_Outline_Funcs  func_interface =
1608    {
1609      (FT_Outline_MoveTo_Func) gray_move_to,
1610      (FT_Outline_LineTo_Func) gray_line_to,
1611      (FT_Outline_ConicTo_Func)gray_conic_to,
1612      (FT_Outline_CubicTo_Func)gray_cubic_to,
1613      0,
1614      0
1615    };
1616
1617    volatile int  error = 0;
1618
1619
1620    if ( ft_setjmp( ras.jump_buffer ) == 0 )
1621    {
1622      error = FT_Outline_Decompose( &ras.outline, &func_interface, &ras );
1623      gray_record_cell( RAS_VAR );
1624    }
1625    else
1626      error = ErrRaster_Memory_Overflow;
1627
1628    return error;
1629  }
1630
1631
1632  static int
1633  gray_convert_glyph( RAS_ARG )
1634  {
1635    TBand            bands[40];
1636    TBand* volatile  band;
1637    int volatile     n, num_bands;
1638    TPos volatile    min, max, max_y;
1639    FT_BBox*         clip;
1640
1641
1642    /* Set up state in the raster object */
1643    gray_compute_cbox( RAS_VAR );
1644
1645    /* clip to target bitmap, exit if nothing to do */
1646    clip = &ras.clip_box;
1647
1648    if ( ras.max_ex <= clip->xMin || ras.min_ex >= clip->xMax ||
1649         ras.max_ey <= clip->yMin || ras.min_ey >= clip->yMax )
1650      return 0;
1651
1652    if ( ras.min_ex < clip->xMin ) ras.min_ex = clip->xMin;
1653    if ( ras.min_ey < clip->yMin ) ras.min_ey = clip->yMin;
1654
1655    if ( ras.max_ex > clip->xMax ) ras.max_ex = clip->xMax;
1656    if ( ras.max_ey > clip->yMax ) ras.max_ey = clip->yMax;
1657
1658    ras.count_ex = ras.max_ex - ras.min_ex;
1659    ras.count_ey = ras.max_ey - ras.min_ey;
1660
1661    /* simple heuristic used to speed up the bezier decomposition -- see */
1662    /* the code in gray_render_conic() and gray_render_cubic() for more  */
1663    /* details                                                           */
1664    ras.conic_level = 32;
1665    ras.cubic_level = 16;
1666
1667    {
1668      int level = 0;
1669
1670
1671      if ( ras.count_ex > 24 || ras.count_ey > 24 )
1672        level++;
1673      if ( ras.count_ex > 120 || ras.count_ey > 120 )
1674        level++;
1675
1676      ras.conic_level <<= level;
1677      ras.cubic_level <<= level;
1678    }
1679
1680    /* set up vertical bands */
1681    num_bands = (int)( ( ras.max_ey - ras.min_ey ) / ras.band_size );
1682    if ( num_bands == 0 )
1683      num_bands = 1;
1684    if ( num_bands >= 39 )
1685      num_bands = 39;
1686
1687    ras.band_shoot = 0;
1688
1689    min   = ras.min_ey;
1690    max_y = ras.max_ey;
1691
1692    for ( n = 0; n < num_bands; n++, min = max )
1693    {
1694      max = min + ras.band_size;
1695      if ( n == num_bands - 1 || max > max_y )
1696        max = max_y;
1697
1698      bands[0].min = min;
1699      bands[0].max = max;
1700      band         = bands;
1701
1702      while ( band >= bands )
1703      {
1704        TPos  bottom, top, middle;
1705        int   error;
1706
1707        {
1708          PCell  cells_max;
1709          int    yindex;
1710          long   cell_start, cell_end, cell_mod;
1711
1712
1713          ras.ycells = (PCell*)ras.buffer;
1714          ras.ycount = band->max - band->min;
1715
1716          cell_start = sizeof ( PCell ) * ras.ycount;
1717          cell_mod   = cell_start % sizeof ( TCell );
1718          if ( cell_mod > 0 )
1719            cell_start += sizeof ( TCell ) - cell_mod;
1720
1721          cell_end  = ras.buffer_size;
1722          cell_end -= cell_end % sizeof( TCell );
1723
1724          cells_max = (PCell)( (char*)ras.buffer + cell_end );
1725          ras.cells = (PCell)( (char*)ras.buffer + cell_start );
1726          if ( ras.cells >= cells_max )
1727            goto ReduceBands;
1728
1729          ras.max_cells = cells_max - ras.cells;
1730          if ( ras.max_cells < 2 )
1731            goto ReduceBands;
1732
1733          for ( yindex = 0; yindex < ras.ycount; yindex++ )
1734            ras.ycells[yindex] = NULL;
1735        }
1736
1737        ras.num_cells = 0;
1738        ras.invalid   = 1;
1739        ras.min_ey    = band->min;
1740        ras.max_ey    = band->max;
1741        ras.count_ey  = band->max - band->min;
1742
1743        error = gray_convert_glyph_inner( RAS_VAR );
1744
1745        if ( !error )
1746        {
1747          gray_sweep( RAS_VAR_ &ras.target );
1748          band--;
1749          continue;
1750        }
1751        else if ( error != ErrRaster_Memory_Overflow )
1752          return 1;
1753
1754      ReduceBands:
1755        /* render pool overflow; we will reduce the render band by half */
1756        bottom = band->min;
1757        top    = band->max;
1758        middle = bottom + ( ( top - bottom ) >> 1 );
1759
1760        /* This is too complex for a single scanline; there must */
1761        /* be some problems.                                     */
1762        if ( middle == bottom )
1763        {
1764#ifdef DEBUG_GRAYS
1765          fprintf( stderr, "Rotten glyph!\n" );
1766#endif
1767          return 1;
1768        }
1769
1770        if ( bottom-top >= ras.band_size )
1771          ras.band_shoot++;
1772
1773        band[1].min = bottom;
1774        band[1].max = middle;
1775        band[0].min = middle;
1776        band[0].max = top;
1777        band++;
1778      }
1779    }
1780
1781    if ( ras.band_shoot > 8 && ras.band_size > 16 )
1782      ras.band_size = ras.band_size / 2;
1783
1784    return 0;
1785  }
1786
1787
1788  static int
1789  gray_raster_render( PRaster                  raster,
1790                      const FT_Raster_Params*  params )
1791  {
1792    const FT_Outline*  outline    = (const FT_Outline*)params->source;
1793    const FT_Bitmap*   target_map = params->target;
1794    PWorker            worker;
1795
1796
1797    if ( !raster || !raster->buffer || !raster->buffer_size )
1798      return ErrRaster_Invalid_Argument;
1799
1800    if ( !outline )
1801      return ErrRaster_Invalid_Outline;
1802
1803    /* return immediately if the outline is empty */
1804    if ( outline->n_points == 0 || outline->n_contours <= 0 )
1805      return 0;
1806
1807    if ( !outline->contours || !outline->points )
1808      return ErrRaster_Invalid_Outline;
1809
1810    if ( outline->n_points !=
1811           outline->contours[outline->n_contours - 1] + 1 )
1812      return ErrRaster_Invalid_Outline;
1813
1814    worker = raster->worker;
1815
1816    /* if direct mode is not set, we must have a target bitmap */
1817    if ( ( params->flags & FT_RASTER_FLAG_DIRECT ) == 0 )
1818    {
1819      if ( !target_map )
1820        return ErrRaster_Invalid_Argument;
1821
1822      /* nothing to do */
1823      if ( !target_map->width || !target_map->rows )
1824        return 0;
1825
1826      if ( !target_map->buffer )
1827        return ErrRaster_Invalid_Argument;
1828    }
1829
1830    /* this version does not support monochrome rendering */
1831    if ( !( params->flags & FT_RASTER_FLAG_AA ) )
1832      return ErrRaster_Invalid_Mode;
1833
1834    /* compute clipping box */
1835    if ( ( params->flags & FT_RASTER_FLAG_DIRECT ) == 0 )
1836    {
1837      /* compute clip box from target pixmap */
1838      ras.clip_box.xMin = 0;
1839      ras.clip_box.yMin = 0;
1840      ras.clip_box.xMax = target_map->width;
1841      ras.clip_box.yMax = target_map->rows;
1842    }
1843    else if ( params->flags & FT_RASTER_FLAG_CLIP )
1844    {
1845      ras.clip_box = params->clip_box;
1846    }
1847    else
1848    {
1849      ras.clip_box.xMin = -32768L;
1850      ras.clip_box.yMin = -32768L;
1851      ras.clip_box.xMax =  32767L;
1852      ras.clip_box.yMax =  32767L;
1853    }
1854
1855    gray_init_cells( worker, raster->buffer, raster->buffer_size );
1856
1857    ras.outline        = *outline;
1858    ras.num_cells      = 0;
1859    ras.invalid        = 1;
1860    ras.band_size      = raster->band_size;
1861    ras.num_gray_spans = 0;
1862
1863    if ( target_map )
1864      ras.target = *target_map;
1865
1866    ras.render_span      = (FT_Raster_Span_Func)gray_render_span;
1867    ras.render_span_data = &ras;
1868
1869    if ( params->flags & FT_RASTER_FLAG_DIRECT )
1870    {
1871      ras.render_span      = (FT_Raster_Span_Func)params->gray_spans;
1872      ras.render_span_data = params->user;
1873    }
1874
1875    return gray_convert_glyph( worker );
1876  }
1877
1878
1879  /**** RASTER OBJECT CREATION: In standalone mode, we simply use *****/
1880  /****                         a static object.                  *****/
1881
1882#ifdef _STANDALONE_
1883
1884  static int
1885  gray_raster_new( void*       memory,
1886                   FT_Raster*  araster )
1887  {
1888    static TRaster  the_raster;
1889
1890    FT_UNUSED( memory );
1891
1892
1893    *araster = (FT_Raster)&the_raster;
1894    FT_MEM_ZERO( &the_raster, sizeof ( the_raster ) );
1895
1896    return 0;
1897  }
1898
1899
1900  static void
1901  gray_raster_done( FT_Raster  raster )
1902  {
1903    /* nothing */
1904    FT_UNUSED( raster );
1905  }
1906
1907#else /* _STANDALONE_ */
1908
1909  static int
1910  gray_raster_new( FT_Memory   memory,
1911                   FT_Raster*  araster )
1912  {
1913    FT_Error  error;
1914    PRaster   raster;
1915
1916
1917    *araster = 0;
1918    if ( !FT_ALLOC( raster, sizeof ( TRaster ) ) )
1919    {
1920      raster->memory = memory;
1921      *araster = (FT_Raster)raster;
1922    }
1923
1924    return error;
1925  }
1926
1927
1928  static void
1929  gray_raster_done( FT_Raster  raster )
1930  {
1931    FT_Memory  memory = (FT_Memory)((PRaster)raster)->memory;
1932
1933
1934    FT_FREE( raster );
1935  }
1936
1937#endif /* _STANDALONE_ */
1938
1939
1940  static void
1941  gray_raster_reset( FT_Raster  raster,
1942                     char*      pool_base,
1943                     long       pool_size )
1944  {
1945    PRaster  rast = (PRaster)raster;
1946
1947
1948    if ( raster )
1949    {
1950      if ( pool_base && pool_size >= (long)sizeof ( TWorker ) + 2048 )
1951      {
1952        PWorker  worker = (PWorker)pool_base;
1953
1954
1955        rast->worker      = worker;
1956        rast->buffer      = pool_base +
1957                              ( ( sizeof ( TWorker ) + sizeof ( TCell ) - 1 ) &
1958                                ~( sizeof ( TCell ) - 1 ) );
1959        rast->buffer_size = (long)( ( pool_base + pool_size ) -
1960                                    (char*)rast->buffer ) &
1961                                      ~( sizeof ( TCell ) - 1 );
1962        rast->band_size   = (int)( rast->buffer_size /
1963                                     ( sizeof ( TCell ) * 8 ) );
1964      }
1965      else
1966      {
1967        rast->buffer      = NULL;
1968        rast->buffer_size = 0;
1969        rast->worker      = NULL;
1970      }
1971    }
1972  }
1973
1974
1975  const FT_Raster_Funcs  ft_grays_raster =
1976  {
1977    FT_GLYPH_FORMAT_OUTLINE,
1978
1979    (FT_Raster_New_Func)     gray_raster_new,
1980    (FT_Raster_Reset_Func)   gray_raster_reset,
1981    (FT_Raster_Set_Mode_Func)0,
1982    (FT_Raster_Render_Func)  gray_raster_render,
1983    (FT_Raster_Done_Func)    gray_raster_done
1984  };
1985
1986
1987/* END */
Note: See TracBrowser for help on using the repository browser.