From b5084e11f7d2d73e0687dee6314c560b8fe6d4cb Mon Sep 17 00:00:00 2001 From: Werner Lemberg Date: Sat, 28 Oct 2000 17:10:06 +0000 Subject: [PATCH] Renamed z1* files back to t1*; the same transition for Z1_* structures Removed obsolete raster1/* files. --- CHANGES | 9 +- docs/BUILD | 2 +- include/freetype/internal/ftdebug.h | 9 +- src/base/ftmac.c | 2 +- src/raster1/ftraster.c | 3293 -------------------------- src/raster1/ftraster.h | 50 - src/raster1/ftrend1.c | 276 --- src/raster1/ftrend1.h | 48 - src/raster1/raster1.c | 35 - src/type1/module.mk | 2 +- src/type1/rules.mk | 24 +- src/type1/{z1afm.c => t1afm.c} | 30 +- src/type1/{z1afm.h => t1afm.h} | 30 +- src/type1/{z1driver.c => t1driver.c} | 62 +- src/type1/{z1driver.h => t1driver.h} | 10 +- src/type1/{z1gload.c => t1gload.c} | 26 +- src/type1/{z1gload.h => t1gload.h} | 20 +- src/type1/{z1load.c => t1load.c} | 302 +-- src/type1/{z1load.h => t1load.h} | 52 +- src/type1/{z1objs.c => t1objs.c} | 48 +- src/type1/{z1objs.h => t1objs.h} | 56 +- src/type1/{z1parse.c => t1parse.c} | 34 +- src/type1/{z1parse.h => t1parse.h} | 52 +- src/type1/{z1tokens.h => t1tokens.h} | 4 +- src/type1/type1.c | 30 +- 25 files changed, 400 insertions(+), 4106 deletions(-) delete mode 100644 src/raster1/ftraster.c delete mode 100644 src/raster1/ftraster.h delete mode 100644 src/raster1/ftrend1.c delete mode 100644 src/raster1/ftrend1.h delete mode 100644 src/raster1/raster1.c rename src/type1/{z1afm.c => t1afm.c} (91%) rename src/type1/{z1afm.h => t1afm.h} (78%) rename src/type1/{z1driver.c => t1driver.c} (91%) rename src/type1/{z1driver.h => t1driver.h} (86%) rename src/type1/{z1gload.c => t1gload.c} (94%) rename src/type1/{z1gload.h => t1gload.h} (79%) rename src/type1/{z1load.c => t1load.c} (86%) rename src/type1/{z1load.h => t1load.h} (61%) rename src/type1/{z1objs.c => t1objs.c} (92%) rename src/type1/{z1objs.h => t1objs.h} (82%) rename src/type1/{z1parse.c => t1parse.c} (94%) rename src/type1/{z1parse.h => t1parse.h} (79%) rename src/type1/{z1tokens.h => t1tokens.h} (95%) diff --git a/CHANGES b/CHANGES index e5ceeb7d7..23980f9bb 100644 --- a/CHANGES +++ b/CHANGES @@ -1,5 +1,8 @@ LATEST CHANGES + - "type1z" renamed back to "type1"; the old "type1" module has been + removed + - revamped the build system to make it a lot more generic. This will allow us to re-use nearly un-modified in lots of other projects (including FreeType Layout) @@ -13,10 +16,10 @@ LATEST CHANGES - updated "docs/docmaker.py", a draft API reference is available at http://www.freetype.org/ft2api.html - - changed "type1z" to use "psaux" + - changed "type1" to use "psaux" - created a new module named "psaux" to hold the Type 1 & Type 2 parsing - routines. It should be used by "type1z", "cid" and "cff" in the future + routines. It should be used by "type1", "cid" and "cff" in the future - fixed an important bug in "FT_Glyph_Get_CBox" @@ -354,7 +357,7 @@ OLD CHANGES FOR BETA 7 - changed the default number of gray levels of the smooth renderer to 256 (instead of the previous 128). Of course, the human eye can't - see any difference ;-) + see any difference ;-) - removed TT_MAX_SUBGLYPHS, there is no static limit on the number of subglyphs in a TrueType font now.. diff --git a/docs/BUILD b/docs/BUILD index b25813a54..47daa9444 100644 --- a/docs/BUILD +++ b/docs/BUILD @@ -198,7 +198,7 @@ III. DETAILED COMPILATION PROCEDURE src/sfnt/sfnt.c - the `sfnt' module src/smooth/smooth.c - the anti-aliasing raster module src/truetype/truetype.c - the TrueType font driver - src/type1z/type1z.c - the Type 1 font driver + src/type1/type1.c - the Type 1 font driver The last module of FreeType 2, winfonts (implementing support for Windows FNT format), is a single file. diff --git a/include/freetype/internal/ftdebug.h b/include/freetype/internal/ftdebug.h index c3648922f..9cfba8f71 100644 --- a/include/freetype/internal/ftdebug.h +++ b/include/freetype/internal/ftdebug.h @@ -86,19 +86,12 @@ trace_t1hint, trace_t1load, trace_t1objs, + trace_t1parse, /* PostScript helper module `psaux' */ trace_t1decode, trace_psobjs, - /* experimental Type 1 driver components */ - trace_z1driver, - trace_z1gload, - trace_z1hint, - trace_z1load, - trace_z1objs, - trace_z1parse, - /* Type 2 driver components */ trace_t2driver, trace_t2gload, diff --git a/src/base/ftmac.c b/src/base/ftmac.c index 09935a296..07b2e77ab 100644 --- a/src/base/ftmac.c +++ b/src/base/ftmac.c @@ -59,7 +59,7 @@ #include #include #include -#include +#include #include #include diff --git a/src/raster1/ftraster.c b/src/raster1/ftraster.c deleted file mode 100644 index 0be0f379d..000000000 --- a/src/raster1/ftraster.c +++ /dev/null @@ -1,3293 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftraster.c */ -/* */ -/* The FreeType glyph rasterizer (body). */ -/* */ -/* Copyright 1996-2000 by */ -/* David Turner, Robert Wilhelm, and Werner Lemberg. */ -/* */ -/* This file is part of the FreeType project, and may only be used, */ -/* modified, and distributed under the terms of the FreeType project */ -/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ -/* this file you indicate that you have read the license and */ -/* understand and accept it fully. */ -/* */ -/***************************************************************************/ - - /*************************************************************************/ - /* */ - /* This is a rewrite of the FreeType 1.x scan-line converter */ - /* */ - /*************************************************************************/ - - -#ifdef FT_FLAT_COMPILE -# include "ftraster.h" -#else -# include -#endif -#include /* for FT_MulDiv() only */ - - - /*************************************************************************/ - /* */ - /* A simple technical note on how the raster works */ - /* ----------------------------------------------- */ - /* */ - /* Converting an outline into a bitmap is achieved in several steps: */ - /* */ - /* 1 - Decomposing the outline into successive `profiles'. Each */ - /* profile is simply an array of scanline intersections on a given */ - /* dimension. A profile's main attributes are */ - /* */ - /* o its scanline position boundaries, i.e. `Ymin' and `Ymax'. */ - /* */ - /* o an array of intersection coordinates for each scanline */ - /* between `Ymin' and `Ymax'. */ - /* */ - /* o a direction, indicating whether it was built going `up' or */ - /* `down', as this is very important for filling rules. */ - /* */ - /* 2 - Sweeping the target map's scanlines in order to compute segment */ - /* `spans' which are then filled. Additionally, this pass */ - /* performs drop-out control. */ - /* */ - /* The outline data is parsed during step 1 only. The profiles are */ - /* built from the bottom of the render pool, used as a stack. The */ - /* following graphics shows the profile list under construction: */ - /* */ - /* ____________________________________________________________ _ _ */ - /* | | | | | */ - /* | profile | coordinates for | profile | coordinates for |--> */ - /* | 1 | profile 1 | 2 | profile 2 |--> */ - /* |_________|___________________|_________|_________________|__ _ _ */ - /* */ - /* ^ ^ */ - /* | | */ - /* start of render pool top */ - /* */ - /* The top of the profile stack is kept in the `top' variable. */ - /* */ - /* As you can see, a profile record is pushed on top of the render */ - /* pool, which is then followed by its coordinates/intersections. If */ - /* a change of direction is detected in the outline, a new profile is */ - /* generated until the end of the outline. */ - /* */ - /* Note that when all profiles have been generated, the function */ - /* Finalize_Profile_Table() is used to record, for each profile, its */ - /* bottom-most scanline as well as the scanline above its upmost */ - /* boundary. These positions are called `y-turns' because they (sort */ - /* of) correspond to local extrema. They are stored in a sorted list */ - /* built from the top of the render pool as a downwards stack: */ - /* */ - /* _ _ _______________________________________ */ - /* | | */ - /* <--| sorted list of | */ - /* <--| extrema scanlines | */ - /* _ _ __________________|____________________| */ - /* */ - /* ^ ^ */ - /* | | */ - /* maxBuff sizeBuff = end of pool */ - /* */ - /* This list is later used during the sweep phase in order to */ - /* optimize performance (see technical note on the sweep below). */ - /* */ - /* Of course, the raster detects whether the two stacks collide and */ - /* handles the situation propertly. */ - /* */ - /*************************************************************************/ - - - /*************************************************************************/ - /*************************************************************************/ - /** **/ - /** CONFIGURATION MACROS **/ - /** **/ - /*************************************************************************/ - /*************************************************************************/ - - /* define DEBUG_RASTER if you want to compile a debugging version */ -#define xxxDEBUG_RASTER - - /* The default render pool size in bytes */ -#define RASTER_RENDER_POOL 8192 - - /* undefine FT_RASTER_OPTION_ANTI_ALIASING if you do not want to support */ - /* 5-levels anti-aliasing */ -#ifdef FT_CONFIG_OPTION_5_GRAY_LEVELS -#define FT_RASTER_OPTION_ANTI_ALIASING -#endif - - /* The size of the two-lines intermediate bitmap used */ - /* for anti-aliasing, in bytes. */ -#define RASTER_GRAY_LINES 2048 - - - /*************************************************************************/ - /*************************************************************************/ - /** **/ - /** OTHER MACROS (do not change) **/ - /** **/ - /*************************************************************************/ - /*************************************************************************/ - - /*************************************************************************/ - /* */ - /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ - /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ - /* messages during execution. */ - /* */ -#undef FT_COMPONENT -#define FT_COMPONENT trace_raster - - -#ifdef _STANDALONE_ - - - /* This macro is used to indicate that a function parameter is unused. */ - /* Its purpose is simply to reduce compiler warnings. Note also that */ - /* simply defining it as `(void)x' doesn't avoid warnings with certain */ - /* ANSI compilers (e.g. LCC). */ -#define FT_UNUSED( x ) (x) = (x) - - /* Disable the tracing mechanism for simplicity -- developers can */ - /* activate it easily by redefining these two macros. */ -#ifndef FT_ERROR -#define FT_ERROR( x ) do ; while ( 0 ) /* nothing */ -#endif - -#ifndef FT_TRACE -#define FT_TRACE( x ) do ; while ( 0 ) /* nothing */ -#endif - -#define Raster_Err_None 0 -#define Raster_Err_Not_Ini -1 -#define Raster_Err_Overflow -2 -#define Raster_Err_Neg_Height -3 -#define Raster_Err_Invalid -4 -#define Raster_Err_Unsupported -5 - - -#else /* _STANDALONE_ */ - - -#include -#include /* for FT_TRACE() and FT_ERROR() */ - -#define Raster_Err_None FT_Err_Ok -#define Raster_Err_Not_Ini FT_Err_Raster_Uninitialized -#define Raster_Err_Overflow FT_Err_Raster_Overflow -#define Raster_Err_Neg_Height FT_Err_Raster_Negative_Height -#define Raster_Err_Invalid FT_Err_Invalid_Outline -#define Raster_Err_Unsupported FT_Err_Cannot_Render_Glyph - - -#endif /* _STANDALONE_ */ - - - /* FMulDiv means `Fast MulDiv'; it is used in case where `b' is */ - /* typically a small value and the result of a*b is known to fit into */ - /* 32 bits. */ -#define FMulDiv( a, b, c ) ( (a) * (b) / (c) ) - - /* On the other hand, SMulDiv means `Slow MulDiv', and is used typically */ - /* for clipping computations. It simply uses the FT_MulDiv() function */ - /* defined in `ftcalc.h'. */ -#define SMulDiv FT_MulDiv - - /* The rasterizer is a very general purpose component; please leave */ - /* the following redefinitions there (you never know your target */ - /* environment). */ - -#ifndef TRUE -#define TRUE 1 -#endif - -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef NULL -#define NULL (void*)0 -#endif - -#ifndef SUCCESS -#define SUCCESS 0 -#endif - -#ifndef FAILURE -#define FAILURE 1 -#endif - - -#define MaxBezier 32 /* The maximum number of stacked Bezier curves. */ - /* Setting this constant to more than 32 is a */ - /* pure waste of space. */ - -#define Pixel_Bits 6 /* fractional bits of *input* coordinates */ - - - /*************************************************************************/ - /*************************************************************************/ - /** **/ - /** SIMPLE TYPE DECLARATIONS **/ - /** **/ - /*************************************************************************/ - /*************************************************************************/ - - typedef int Int; - typedef unsigned int UInt; - typedef short Short; - typedef unsigned short UShort, *PUShort; - typedef long Long, *PLong; - typedef unsigned long ULong; - - typedef unsigned char Byte, *PByte; - typedef char Bool; - - typedef struct TPoint_ - { - Long x; - Long y; - - } TPoint; - - - typedef enum TFlow_ - { - Flow_None = 0, - Flow_Up = 1, - Flow_Down = -1 - - } TFlow; - - - /* States of each line, arc, and profile */ - typedef enum TStates_ - { - Unknown, - Ascending, - Descending, - Flat - - } TStates; - - - typedef struct TProfile_ TProfile; - typedef TProfile* PProfile; - - struct TProfile_ - { - FT_F26Dot6 X; /* current coordinate during sweep */ - PProfile link; /* link to next profile - various purpose */ - PLong offset; /* start of profile's data in render pool */ - Int flow; /* Profile orientation: Asc/Descending */ - Long height; /* profile's height in scanlines */ - Long start; /* profile's starting scanline */ - - UShort countL; /* number of lines to step before this */ - /* profile becomes drawable */ - - PProfile next; /* next profile in same contour, used */ - /* during drop-out control */ - }; - - typedef PProfile TProfileList; - typedef PProfile* PProfileList; - - - /* Simple record used to implement a stack of bands, required */ - /* by the sub-banding mechanism */ - typedef struct TBand_ - { - Short y_min; /* band's minimum */ - Short y_max; /* band's maximum */ - - } TBand; - - -#define AlignProfileSize \ - ( ( sizeof ( TProfile ) + sizeof ( long ) - 1 ) / sizeof ( long ) ) - - -#ifdef TT_STATIC_RASTER - - -#define RAS_ARGS /* void */ -#define RAS_ARG /* void */ - -#define RAS_VARS /* void */ -#define RAS_VAR /* void */ - -#define FT_UNUSED_RASTER do ; while ( 0 ) - - -#else /* TT_STATIC_RASTER */ - - -#define RAS_ARGS TRaster_Instance* raster, -#define RAS_ARG TRaster_Instance* raster - -#define RAS_VARS raster, -#define RAS_VAR raster - -#define FT_UNUSED_RASTER FT_UNUSED( raster ) - - -#endif /* TT_STATIC_RASTER */ - - - typedef struct TRaster_Instance_ TRaster_Instance; - - - /* prototypes used for sweep function dispatch */ - typedef void Function_Sweep_Init( RAS_ARGS Short* min, - Short* max ); - - typedef void Function_Sweep_Span( RAS_ARGS Short y, - FT_F26Dot6 x1, - FT_F26Dot6 x2, - PProfile left, - PProfile right ); - - typedef void Function_Sweep_Step( RAS_ARG ); - - - /* NOTE: These operations are only valid on 2's complement processors */ - -#define FLOOR( x ) ( (x) & -ras.precision ) -#define CEILING( x ) ( ( (x) + ras.precision - 1 ) & -ras.precision ) -#define TRUNC( x ) ( (signed long)(x) >> ras.precision_bits ) -#define FRAC( x ) ( (x) & ( ras.precision - 1 ) ) -#define SCALED( x ) ( ( (x) << ras.scale_shift ) - ras.precision_half ) - - /* Note that I have moved the location of some fields in the */ - /* structure to ensure that the most used variables are used */ - /* at the top. Thus, their offset can be coded with less */ - /* opcodes, and it results in a smaller executable. */ - - struct TRaster_Instance_ - { - Int precision_bits; /* precision related variables */ - Int precision; - Int precision_half; - Long precision_mask; - Int precision_shift; - Int precision_step; - Int precision_jitter; - - Int scale_shift; /* == precision_shift for bitmaps */ - /* == precision_shift+1 for pixmaps */ - - PLong buff; /* The profiles buffer */ - PLong sizeBuff; /* Render pool size */ - PLong maxBuff; /* Profiles buffer size */ - PLong top; /* Current cursor in buffer */ - - FT_Error error; - - Int numTurns; /* number of Y-turns in outline */ - - TPoint* arc; /* current Bezier arc pointer */ - - UShort bWidth; /* target bitmap width */ - PByte bTarget; /* target bitmap buffer */ - PByte gTarget; /* target pixmap buffer */ - - Long lastX, lastY, minY, maxY; - - UShort num_Profs; /* current number of profiles */ - - Bool fresh; /* signals a fresh new profile which */ - /* 'start' field must be completed */ - Bool joint; /* signals that the last arc ended */ - /* exactly on a scanline. Allows */ - /* removal of doublets */ - PProfile cProfile; /* current profile */ - PProfile fProfile; /* head of linked list of profiles */ - PProfile gProfile; /* contour's first profile in case */ - /* of impact */ - - TStates state; /* rendering state */ - - FT_Bitmap target; /* description of target bit/pixmap */ - FT_Outline outline; - - Long traceOfs; /* current offset in target bitmap */ - Long traceG; /* current offset in target pixmap */ - - Short traceIncr; /* sweep's increment in target bitmap */ - - Short gray_min_x; /* current min x during gray rendering */ - Short gray_max_x; /* current max x during gray rendering */ - - /* dispatch variables */ - - Function_Sweep_Init* Proc_Sweep_Init; - Function_Sweep_Span* Proc_Sweep_Span; - Function_Sweep_Span* Proc_Sweep_Drop; - Function_Sweep_Step* Proc_Sweep_Step; - - Byte dropOutControl; /* current drop_out control method */ - - Bool second_pass; /* indicates wether a horizontal pass */ - /* should be performed to control */ - /* drop-out accurately when calling */ - /* Render_Glyph. Note that there is */ - /* no horizontal pass during gray */ - /* rendering. */ - - TPoint arcs[2 * MaxBezier + 1]; /* The Bezier stack */ - - TBand band_stack[16]; /* band stack used for sub-banding */ - Int band_top; /* band stack top */ - - Int count_table[256]; /* Look-up table used to quickly count */ - /* set bits in a gray 2x2 cell */ - - void* memory; - -#ifdef FT_RASTER_OPTION_ANTI_ALIASING - - Byte grays[5]; /* Palette of gray levels used for */ - /* render. */ - - Byte gray_lines[RASTER_GRAY_LINES]; - /* Intermediate table used to render the */ - /* graylevels pixmaps. */ - /* gray_lines is a buffer holding two */ - /* monochrome scanlines */ - - Short gray_width; /* width in bytes of one monochrome */ - /* intermediate scanline of gray_lines. */ - /* Each gray pixel takes 2 bits long there */ - - /* The gray_lines must hold 2 lines, thus with size */ - /* in bytes of at least `gray_width*2'. */ - -#endif /* FT_RASTER_ANTI_ALIASING */ - -#if 0 - PByte flags; /* current flags table */ - PUShort outs; /* current outlines table */ - FT_Vector* coords; - - UShort nPoints; /* number of points in current glyph */ - Short nContours; /* number of contours in current glyph */ -#endif - - }; - - -#ifdef FT_CONFIG_OPTION_STATIC_RASTER - - static TRaster_Instance cur_ras; -#define ras cur_ras - -#else - -#define ras (*raster) - -#endif /* FT_CONFIG_OPTION_STATIC_RASTER */ - - - /*************************************************************************/ - /*************************************************************************/ - /** **/ - /** PROFILES COMPUTATION **/ - /** **/ - /*************************************************************************/ - /*************************************************************************/ - - - /*************************************************************************/ - /* */ - /* */ - /* Set_High_Precision */ - /* */ - /* */ - /* Sets precision variables according to param flag. */ - /* */ - /* */ - /* High :: Set to True for high precision (typically for ppem < 18), */ - /* false otherwise. */ - /* */ - static - void Set_High_Precision( RAS_ARGS Int High ) - { - if ( High ) - { - ras.precision_bits = 10; - ras.precision_step = 128; - ras.precision_jitter = 24; - } - else - { - ras.precision_bits = 6; - ras.precision_step = 32; - ras.precision_jitter = 2; - } - - FT_TRACE6(( "Set_High_Precision(%s)\n", High ? "true" : "false" )); - - ras.precision = 1L << ras.precision_bits; - ras.precision_half = ras.precision / 2; - ras.precision_shift = ras.precision_bits - Pixel_Bits; - ras.precision_mask = -ras.precision; - } - - - /*************************************************************************/ - /* */ - /* */ - /* New_Profile */ - /* */ - /* */ - /* Creates a new profile in the render pool. */ - /* */ - /* */ - /* aState :: The state/orientation of the new profile. */ - /* */ - /* */ - /* SUCCESS on success. FAILURE in case of overflow or of incoherent */ - /* profile. */ - /* */ - static - Bool New_Profile( RAS_ARGS TStates aState ) - { - if ( !ras.fProfile ) - { - ras.cProfile = (PProfile)ras.top; - ras.fProfile = ras.cProfile; - ras.top += AlignProfileSize; - } - - if ( ras.top >= ras.maxBuff ) - { - ras.error = Raster_Err_Overflow; - return FAILURE; - } - - switch ( aState ) - { - case Ascending: - ras.cProfile->flow = Flow_Up; - FT_TRACE6(( "New ascending profile = %lx\n", (long)ras.cProfile )); - break; - - case Descending: - ras.cProfile->flow = Flow_Down; - FT_TRACE6(( "New descending profile = %lx\n", (long)ras.cProfile )); - break; - - default: - FT_ERROR(( "New_Profile: invalid profile direction!\n" )); - ras.error = Raster_Err_Invalid; - return FAILURE; - } - - ras.cProfile->start = 0; - ras.cProfile->height = 0; - ras.cProfile->offset = ras.top; - ras.cProfile->link = (PProfile)0; - ras.cProfile->next = (PProfile)0; - - if ( !ras.gProfile ) - ras.gProfile = ras.cProfile; - - ras.state = aState; - ras.fresh = TRUE; - ras.joint = FALSE; - - return SUCCESS; - } - - - /*************************************************************************/ - /* */ - /* */ - /* End_Profile */ - /* */ - /* */ - /* Finalizes the current profile. */ - /* */ - /* */ - /* SUCCESS on success. FAILURE in case of overflow or incoherency. */ - /* */ - static - Bool End_Profile( RAS_ARG ) - { - Long h; - PProfile oldProfile; - - - h = ras.top - ras.cProfile->offset; - - if ( h < 0 ) - { - FT_ERROR(( "End_Profile: negative height encountered!\n" )); - ras.error = Raster_Err_Neg_Height; - return FAILURE; - } - - if ( h > 0 ) - { - FT_TRACE6(( "Ending profile %lx, start = %ld, height = %ld\n", - (long)ras.cProfile, ras.cProfile->start, h )); - - oldProfile = ras.cProfile; - ras.cProfile->height = h; - ras.cProfile = (PProfile)ras.top; - - ras.top += AlignProfileSize; - - ras.cProfile->height = 0; - ras.cProfile->offset = ras.top; - oldProfile->next = ras.cProfile; - ras.num_Profs++; - } - - if ( ras.top >= ras.maxBuff ) - { - FT_TRACE1(( "overflow in End_Profile\n" )); - ras.error = Raster_Err_Overflow; - return FAILURE; - } - - ras.joint = FALSE; - - return SUCCESS; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Insert_Y_Turn */ - /* */ - /* */ - /* Inserts a salient into the sorted list placed on top of the render */ - /* pool. */ - /* */ - /* */ - /* New y scanline position. */ - /* */ - /* */ - /* SUCCESS on success. FAILURE in case of overflow. */ - /* */ - static - Bool Insert_Y_Turn( RAS_ARGS Int y ) - { - PLong y_turns; - Int y2, n; - - - n = ras.numTurns - 1; - y_turns = ras.sizeBuff - ras.numTurns; - - /* look for first y value that is <= */ - while ( n >= 0 && y < y_turns[n] ) - n--; - - /* if it is <, simply insert it, ignore if == */ - if ( n >= 0 && y > y_turns[n] ) - while ( n >= 0 ) - { - y2 = y_turns[n]; - y_turns[n] = y; - y = y2; - n--; - } - - if ( n < 0 ) - { - if ( ras.maxBuff <= ras.top ) - { - ras.error = Raster_Err_Overflow; - return FAILURE; - } - ras.maxBuff--; - ras.numTurns++; - ras.sizeBuff[-ras.numTurns] = y; - } - - return SUCCESS; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Finalize_Profile_Table */ - /* */ - /* */ - /* Adjusts all links in the profiles list. */ - /* */ - /* */ - /* SUCCESS on success. FAILURE in case of overflow. */ - /* */ - static - Bool Finalize_Profile_Table( RAS_ARG ) - { - Int bottom, top; - UShort n; - PProfile p; - - - n = ras.num_Profs; - - if ( n > 1 ) - { - p = ras.fProfile; - while ( n > 0 ) - { - if ( n > 1 ) - p->link = (PProfile)( p->offset + p->height ); - else - p->link = NULL; - - switch ( p->flow ) - { - case Flow_Down: - bottom = p->start - p->height+1; - top = p->start; - p->start = bottom; - p->offset += p->height - 1; - break; - - case Flow_Up: - default: - bottom = p->start; - top = p->start + p->height - 1; - } - - if ( Insert_Y_Turn( RAS_VARS bottom ) || - Insert_Y_Turn( RAS_VARS top + 1 ) ) - return FAILURE; - - p = p->link; - n--; - } - } - else - ras.fProfile = NULL; - - return SUCCESS; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Split_Conic */ - /* */ - /* */ - /* Subdivides one conic Bezier into two joint sub-arcs in the Bezier */ - /* stack. */ - /* */ - /* */ - /* None (subdivided Bezier is taken from the top of the stack). */ - /* */ - /* */ - /* This routine is the `beef' of this component. It is _the_ inner */ - /* loop that should be optimized to hell to get the best performance. */ - /* */ - static - void Split_Conic( TPoint* base ) - { - Long a, b; - - - base[4].x = base[2].x; - b = base[1].x; - a = base[3].x = ( base[2].x + b ) / 2; - b = base[1].x = ( base[0].x + b ) / 2; - base[2].x = ( a + b ) / 2; - - base[4].y = base[2].y; - b = base[1].y; - a = base[3].y = ( base[2].y + b ) / 2; - b = base[1].y = ( base[0].y + b ) / 2; - base[2].y = ( a + b ) / 2; - - /* hand optimized. gcc doesn't seem to be too good at common */ - /* expression substitution and instruction scheduling ;-) */ - } - - - /*************************************************************************/ - /* */ - /* */ - /* Split_Cubic */ - /* */ - /* */ - /* Subdivides a third-order Bezier arc into two joint sub-arcs in the */ - /* Bezier stack. */ - /* */ - /* */ - /* This routine is the `beef' of the component. It is one of _the_ */ - /* inner loops that should be optimized like hell to get the best */ - /* performance. */ - /* */ - static - void Split_Cubic( TPoint* base ) - { - Long a, b, c, d; - - - base[6].x = base[3].x; - c = base[1].x; - d = base[2].x; - base[1].x = a = ( base[0].x + c + 1 ) >> 1; - base[5].x = b = ( base[3].x + d + 1 ) >> 1; - c = ( c + d + 1 ) >> 1; - base[2].x = a = ( a + c + 1 ) >> 1; - base[4].x = b = ( b + c + 1 ) >> 1; - base[3].x = ( a + b + 1 ) >> 1; - - base[6].y = base[3].y; - c = base[1].y; - d = base[2].y; - base[1].y = a = ( base[0].y + c + 1 ) >> 1; - base[5].y = b = ( base[3].y + d + 1 ) >> 1; - c = ( c + d + 1 ) >> 1; - base[2].y = a = ( a + c + 1 ) >> 1; - base[4].y = b = ( b + c + 1 ) >> 1; - base[3].y = ( a + b + 1 ) >> 1; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Line_Up */ - /* */ - /* */ - /* Computes the x-coordinates of an ascending line segment and stores */ - /* them in the render pool. */ - /* */ - /* */ - /* x1 :: The x-coordinate of the segment's start point. */ - /* */ - /* y1 :: The y-coordinate of the segment's start point. */ - /* */ - /* x2 :: The x-coordinate of the segment's end point. */ - /* */ - /* y2 :: The y-coordinate of the segment's end point. */ - /* */ - /* miny :: A lower vertical clipping bound value. */ - /* */ - /* maxy :: An upper vertical clipping bound value. */ - /* */ - /* */ - /* SUCCESS on success, FAILURE on render pool overflow. */ - /* */ - static - Bool Line_Up( RAS_ARGS Long x1, - Long y1, - Long x2, - Long y2, - Long miny, - Long maxy ) - { - Long Dx, Dy; - Int e1, e2, f1, f2, size; /* XXX: is `Short' sufficient? */ - Long Ix, Rx, Ax; - - PLong top; - - - Dx = x2 - x1; - Dy = y2 - y1; - - if ( Dy <= 0 || y2 < miny || y1 > maxy ) - return SUCCESS; - - if ( y1 < miny ) - { - /* Take care: miny-y1 can be a very large value; we use */ - /* a slow MulDiv function to avoid clipping bugs */ - x1 += SMulDiv( Dx, miny - y1, Dy ); - e1 = TRUNC( miny ); - f1 = 0; - } - else - { - e1 = TRUNC( y1 ); - f1 = FRAC( y1 ); - } - - if ( y2 > maxy ) - { - /* x2 += FMulDiv( Dx, maxy - y2, Dy ); UNNECESSARY */ - e2 = TRUNC( maxy ); - f2 = 0; - } - else - { - e2 = TRUNC( y2 ); - f2 = FRAC( y2 ); - } - - if ( f1 > 0 ) - { - if ( e1 == e2 ) - return SUCCESS; - else - { - x1 += FMulDiv( Dx, ras.precision - f1, Dy ); - e1 += 1; - } - } - else - if ( ras.joint ) - { - ras.top--; - ras.joint = FALSE; - } - - ras.joint = ( f2 == 0 ); - - if ( ras.fresh ) - { - ras.cProfile->start = e1; - ras.fresh = FALSE; - } - - size = e2 - e1 + 1; - if ( ras.top + size >= ras.maxBuff ) - { - ras.error = Raster_Err_Overflow; - return FAILURE; - } - - if ( Dx > 0 ) - { - Ix = ( ras.precision * Dx ) / Dy; - Rx = ( ras.precision * Dx ) % Dy; - Dx = 1; - } - else - { - Ix = -( ( ras.precision * -Dx ) / Dy ); - Rx = ( ras.precision * -Dx ) % Dy; - Dx = -1; - } - - Ax = -Dy; - top = ras.top; - - while ( size > 0 ) - { - *top++ = x1; - - x1 += Ix; - Ax += Rx; - if ( Ax >= 0 ) - { - Ax -= Dy; - x1 += Dx; - } - size--; - } - - ras.top = top; - return SUCCESS; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Line_Down */ - /* */ - /* */ - /* Computes the x-coordinates of an descending line segment and */ - /* stores them in the render pool. */ - /* */ - /* */ - /* x1 :: The x-coordinate of the segment's start point. */ - /* */ - /* y1 :: The y-coordinate of the segment's start point. */ - /* */ - /* x2 :: The x-coordinate of the segment's end point. */ - /* */ - /* y2 :: The y-coordinate of the segment's end point. */ - /* */ - /* miny :: A lower vertical clipping bound value. */ - /* */ - /* maxy :: An upper vertical clipping bound value. */ - /* */ - /* */ - /* SUCCESS on success, FAILURE on render pool overflow. */ - /* */ - static - Bool Line_Down( RAS_ARGS Long x1, - Long y1, - Long x2, - Long y2, - Long miny, - Long maxy ) - { - Bool result, fresh; - - - fresh = ras.fresh; - - result = Line_Up( RAS_VARS x1, -y1, x2, -y2, -maxy, -miny ); - - if ( fresh && !ras.fresh ) - ras.cProfile->start = -ras.cProfile->start; - - return result; - } - - - /* A function type describing the functions used to split Bezier arcs */ - typedef void (*TSplitter)( TPoint* base ); - - - /*************************************************************************/ - /* */ - /* */ - /* Bezier_Up */ - /* */ - /* */ - /* Computes the x-coordinates of an ascending Bezier arc and stores */ - /* them in the render pool. */ - /* */ - /* */ - /* degree :: The degree of the Bezier arc (either 2 or 3). */ - /* */ - /* splitter :: The function to split Bezier arcs. */ - /* */ - /* miny :: A lower vertical clipping bound value. */ - /* */ - /* maxy :: An upper vertical clipping bound value. */ - /* */ - /* */ - /* SUCCESS on success, FAILURE on render pool overflow. */ - /* */ - static - Bool Bezier_Up( RAS_ARGS Int degree, - TSplitter splitter, - Long miny, - Long maxy ) - { - Long y1, y2, e, e2, e0; - Short f1; - - TPoint* arc; - TPoint* start_arc; - - PLong top; - - - arc = ras.arc; - y1 = arc[degree].y; - y2 = arc[0].y; - top = ras.top; - - if ( y2 < miny || y1 > maxy ) - goto Fin; - - e2 = FLOOR( y2 ); - - if ( e2 > maxy ) - e2 = maxy; - - e0 = miny; - - if ( y1 < miny ) - e = miny; - else - { - e = CEILING( y1 ); - f1 = FRAC( y1 ); - e0 = e; - - if ( f1 == 0 ) - { - if ( ras.joint ) - { - top--; - ras.joint = FALSE; - } - - *top++ = arc[degree].x; - - e += ras.precision; - } - } - - if ( ras.fresh ) - { - ras.cProfile->start = TRUNC( e0 ); - ras.fresh = FALSE; - } - - if ( e2 < e ) - goto Fin; - - if ( ( top + TRUNC( e2 - e ) + 1 ) >= ras.maxBuff ) - { - ras.top = top; - ras.error = Raster_Err_Overflow; - return FAILURE; - } - - start_arc = arc; - - while ( arc >= start_arc && e <= e2 ) - { - ras.joint = FALSE; - - y2 = arc[0].y; - - if ( y2 > e ) - { - y1 = arc[degree].y; - if ( y2 - y1 >= ras.precision_step ) - { - splitter( arc ); - arc += degree; - } - else - { - *top++ = arc[degree].x + FMulDiv( arc[0].x-arc[degree].x, - e - y1, y2 - y1 ); - arc -= degree; - e += ras.precision; - } - } - else - { - if ( y2 == e ) - { - ras.joint = TRUE; - *top++ = arc[0].x; - - e += ras.precision; - } - arc -= degree; - } - } - - Fin: - ras.top = top; - ras.arc -= degree; - return SUCCESS; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Bezier_Down */ - /* */ - /* */ - /* Computes the x-coordinates of an descending Bezier arc and stores */ - /* them in the render pool. */ - /* */ - /* */ - /* degree :: The degree of the Bezier arc (either 2 or 3). */ - /* */ - /* splitter :: The function to split Bezier arcs. */ - /* */ - /* miny :: A lower vertical clipping bound value. */ - /* */ - /* maxy :: An upper vertical clipping bound value. */ - /* */ - /* */ - /* SUCCESS on success, FAILURE on render pool overflow. */ - /* */ - static - Bool Bezier_Down( RAS_ARGS Int degree, - TSplitter splitter, - Long miny, - Long maxy ) - { - TPoint* arc = ras.arc; - Bool result, fresh; - - - arc[0].y = -arc[0].y; - arc[1].y = -arc[1].y; - arc[2].y = -arc[2].y; - if ( degree > 2 ) - arc[3].y = -arc[3].y; - - fresh = ras.fresh; - - result = Bezier_Up( RAS_VARS degree, splitter, -maxy, -miny ); - - if ( fresh && !ras.fresh ) - ras.cProfile->start = -ras.cProfile->start; - - arc[0].y = -arc[0].y; - return result; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Line_To */ - /* */ - /* */ - /* Injects a new line segment and adjusts Profiles list. */ - /* */ - /* */ - /* x :: The x-coordinate of the segment's end point (its start point */ - /* is stored in `LastX'). */ - /* */ - /* y :: The y-coordinate of the segment's end point (its start point */ - /* is stored in `LastY'). */ - /* */ - /* */ - /* SUCCESS on success, FAILURE on render pool overflow or incorrect */ - /* profile. */ - /* */ - static - Bool Line_To( RAS_ARGS Long x, - Long y ) - { - /* First, detect a change of direction */ - - switch ( ras.state ) - { - case Unknown: - if ( y > ras.lastY ) - { - if ( New_Profile( RAS_VARS Ascending ) ) - return FAILURE; - } - else - { - if ( y < ras.lastY ) - if ( New_Profile( RAS_VARS Descending ) ) - return FAILURE; - } - break; - - case Ascending: - if ( y < ras.lastY ) - { - if ( End_Profile( RAS_VAR ) || - New_Profile( RAS_VARS Descending ) ) - return FAILURE; - } - break; - - case Descending: - if ( y > ras.lastY ) - { - if ( End_Profile( RAS_VAR ) || - New_Profile( RAS_VARS Ascending ) ) - return FAILURE; - } - break; - - default: - ; - } - - /* Then compute the lines */ - - switch ( ras.state ) - { - case Ascending: - if ( Line_Up( RAS_VARS ras.lastX, ras.lastY, - x, y, ras.minY, ras.maxY ) ) - return FAILURE; - break; - - case Descending: - if ( Line_Down( RAS_VARS ras.lastX, ras.lastY, - x, y, ras.minY, ras.maxY ) ) - return FAILURE; - break; - - default: - ; - } - - ras.lastX = x; - ras.lastY = y; - - return SUCCESS; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Conic_To */ - /* */ - /* */ - /* Injects a new conic arc and adjusts the profile list. */ - /* */ - /* */ - /* cx :: The x-coordinate of the arc's new control point. */ - /* */ - /* cy :: The y-coordinate of the arc's new control point. */ - /* */ - /* x :: The x-coordinate of the arc's end point (its start point is */ - /* stored in `LastX'). */ - /* */ - /* y :: The y-coordinate of the arc's end point (its start point is */ - /* stored in `LastY'). */ - /* */ - /* */ - /* SUCCESS on success, FAILURE on render pool overflow or incorrect */ - /* profile. */ - /* */ - static - Bool Conic_To( RAS_ARGS Long cx, - Long cy, - Long x, - Long y ) - { - Long y1, y2, y3, x3, ymin, ymax; - TStates state_bez; - - - ras.arc = ras.arcs; - ras.arc[2].x = ras.lastX; - ras.arc[2].y = ras.lastY; - ras.arc[1].x = cx; ras.arc[1].y = cy; - ras.arc[0].x = x; ras.arc[0].y = y; - - do - { - y1 = ras.arc[2].y; - y2 = ras.arc[1].y; - y3 = ras.arc[0].y; - x3 = ras.arc[0].x; - - /* first, categorize the Bezier arc */ - - if ( y1 <= y3 ) - { - ymin = y1; - ymax = y3; - } - else - { - ymin = y3; - ymax = y1; - } - - if ( y2 < ymin || y2 > ymax ) - { - /* this arc has no given direction, split it! */ - Split_Conic( ras.arc ); - ras.arc += 2; - } - else if ( y1 == y3 ) - { - /* this arc is flat, ignore it and pop it from the Bezier stack */ - ras.arc -= 2; - } - else - { - /* the arc is y-monotonous, either ascending or descending */ - /* detect a change of direction */ - state_bez = y1 < y3 ? Ascending : Descending; - if ( ras.state != state_bez ) - { - /* finalize current profile if any */ - if ( ras.state != Unknown && - End_Profile( RAS_VAR ) ) - goto Fail; - - /* create a new profile */ - if ( New_Profile( RAS_VARS state_bez ) ) - goto Fail; - } - - /* now call the appropriate routine */ - if ( state_bez == Ascending ) - { - if ( Bezier_Up( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) ) - goto Fail; - } - else - if ( Bezier_Down( RAS_VARS 2, Split_Conic, ras.minY, ras.maxY ) ) - goto Fail; - } - - } while ( ras.arc >= ras.arcs ); - - ras.lastX = x3; - ras.lastY = y3; - - return SUCCESS; - - Fail: - return FAILURE; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Cubic_To */ - /* */ - /* */ - /* Injects a new cubic arc and adjusts the profile list. */ - /* */ - /* */ - /* cx1 :: The x-coordinate of the arc's first new control point. */ - /* */ - /* cy1 :: The y-coordinate of the arc's first new control point. */ - /* */ - /* cx2 :: The x-coordinate of the arc's second new control point. */ - /* */ - /* cy2 :: The y-coordinate of the arc's second new control point. */ - /* */ - /* x :: The x-coordinate of the arc's end point (its start point is */ - /* stored in `LastX'). */ - /* */ - /* y :: The y-coordinate of the arc's end point (its start point is */ - /* stored in `LastY'). */ - /* */ - /* */ - /* SUCCESS on success, FAILURE on render pool overflow or incorrect */ - /* profile. */ - /* */ - static - Bool Cubic_To( RAS_ARGS Long cx1, - Long cy1, - Long cx2, - Long cy2, - Long x, - Long y ) - { - Long y1, y2, y3, y4, x4, ymin1, ymax1, ymin2, ymax2; - TStates state_bez; - - - ras.arc = ras.arcs; - ras.arc[3].x = ras.lastX; - ras.arc[3].y = ras.lastY; - ras.arc[2].x = cx1; ras.arc[2].y = cy1; - ras.arc[1].x = cx2; ras.arc[1].y = cy2; - ras.arc[0].x = x; ras.arc[0].y = y; - - do - { - y1 = ras.arc[3].y; - y2 = ras.arc[2].y; - y3 = ras.arc[1].y; - y4 = ras.arc[0].y; - x4 = ras.arc[0].x; - - /* first, categorize the Bezier arc */ - - if ( y1 <= y4 ) - { - ymin1 = y1; - ymax1 = y4; - } - else - { - ymin1 = y4; - ymax1 = y1; - } - - if ( y2 <= y3 ) - { - ymin2 = y2; - ymax2 = y3; - } - else - { - ymin2 = y3; - ymax2 = y2; - } - - if ( ymin2 < ymin1 || ymax2 > ymax1 ) - { - /* this arc has no given direction, split it! */ - Split_Cubic( ras.arc ); - ras.arc += 3; - } - else if ( y1 == y4 ) - { - /* this arc is flat, ignore it and pop it from the Bezier stack */ - ras.arc -= 3; - } - else - { - state_bez = ( y1 <= y4 ) ? Ascending : Descending; - - /* detect a change of direction */ - if ( ras.state != state_bez ) - { - if ( ras.state != Unknown && - End_Profile( RAS_VAR ) ) - goto Fail; - - if ( New_Profile( RAS_VARS state_bez ) ) - goto Fail; - } - - /* compute intersections */ - if ( state_bez == Ascending ) - { - if ( Bezier_Up( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) ) - goto Fail; - } - else - if ( Bezier_Down( RAS_VARS 3, Split_Cubic, ras.minY, ras.maxY ) ) - goto Fail; - } - - } while ( ras.arc >= ras.arcs ); - - ras.lastX = x4; - ras.lastY = y4; - - return SUCCESS; - - Fail: - return FAILURE; - } - - -#undef SWAP_ -#define SWAP_( x, y ) do \ - { \ - Long swap = x; \ - \ - \ - x = y; \ - y = swap; \ - } while ( 0 ) - - - /*************************************************************************/ - /* */ - /* */ - /* Decompose_Curve */ - /* */ - /* */ - /* Scans the outline arays in order to emit individual segments and */ - /* Beziers by calling Line_To() and Bezier_To(). It handles all */ - /* weird cases, like when the first point is off the curve, or when */ - /* there are simply no `on' points in the contour! */ - /* */ - /* */ - /* first :: The index of the first point in the contour. */ - /* */ - /* last :: The index of the last point in the contour. */ - /* */ - /* flipped :: If set, flip the direction of the curve. */ - /* */ - /* */ - /* SUCCESS on success, FAILURE on error. */ - /* */ - static - Bool Decompose_Curve( RAS_ARGS UShort first, - UShort last, - int flipped ) - { - FT_Vector v_last; - FT_Vector v_control; - FT_Vector v_start; - - FT_Vector* points; - FT_Vector* point; - FT_Vector* limit; - char* tags; - - char tag; /* current point's state */ - - - points = ras.outline.points; - limit = points + last; - - v_start.x = SCALED( points[first].x ); - v_start.y = SCALED( points[first].y ); - v_last.x = SCALED( points[last].x ); - v_last.y = SCALED( points[last].y ); - - if ( flipped ) - { - SWAP_( v_start.x, v_start.y ); - SWAP_( v_last.x, v_last.y ); - } - - v_control = v_start; - - point = points + first; - tags = ras.outline.tags + first; - tag = FT_CURVE_TAG( tags[0] ); - - /* A contour cannot start with a cubic control point! */ - if ( tag == FT_Curve_Tag_Cubic ) - goto Invalid_Outline; - - /* check first point to determine origin */ - if ( tag == FT_Curve_Tag_Conic ) - { - /* first point is conic control. Yes, this happens. */ - if ( FT_CURVE_TAG( ras.outline.tags[last] ) == FT_Curve_Tag_On ) - { - /* start at last point if it is on the curve */ - v_start = v_last; - limit--; - } - else - { - /* if both first and last points are conic, */ - /* start at their middle and record its position */ - /* for closure */ - v_start.x = ( v_start.x + v_last.x ) / 2; - v_start.y = ( v_start.y + v_last.y ) / 2; - - v_last = v_start; - } - point--; - tags--; - } - - ras.lastX = v_start.x; - ras.lastY = v_start.y; - - while ( point < limit ) - { - point++; - tags++; - - tag = FT_CURVE_TAG( tags[0] ); - - switch ( tag ) - { - case FT_Curve_Tag_On: /* emit a single line_to */ - { - Long x, y; - - - x = SCALED( point->x ); - y = SCALED( point->y ); - if ( flipped ) - SWAP_( x, y ); - - if ( Line_To( RAS_VARS x, y ) ) - goto Fail; - continue; - } - - case FT_Curve_Tag_Conic: /* consume conic arcs */ - v_control.x = SCALED( point[0].x ); - v_control.y = SCALED( point[0].y ); - - if ( flipped ) - SWAP_( v_control.x, v_control.y ); - - Do_Conic: - if ( point < limit ) - { - FT_Vector v_middle; - Long x, y; - - - point++; - tags++; - tag = FT_CURVE_TAG( tags[0] ); - - x = SCALED( point[0].x ); - y = SCALED( point[0].y ); - - if ( flipped ) - SWAP_( x, y ); - - if ( tag == FT_Curve_Tag_On ) - { - if ( Conic_To( RAS_VARS v_control.x, v_control.y, x, y ) ) - goto Fail; - continue; - } - - if ( tag != FT_Curve_Tag_Conic ) - goto Invalid_Outline; - - v_middle.x = ( v_control.x + x ) / 2; - v_middle.y = ( v_control.y + y ) / 2; - - if ( Conic_To( RAS_VARS v_control.x, v_control.y, - v_middle.x, v_middle.y ) ) - goto Fail; - - v_control.x = x; - v_control.y = y; - - goto Do_Conic; - } - - if ( Conic_To( RAS_VARS v_control.x, v_control.y, - v_start.x, v_start.y ) ) - goto Fail; - - goto Close; - - default: /* FT_Curve_Tag_Cubic */ - { - Long x1, y1, x2, y2, x3, y3; - - - if ( point + 1 > limit || - FT_CURVE_TAG( tags[1] ) != FT_Curve_Tag_Cubic ) - goto Invalid_Outline; - - point += 2; - tags += 2; - - x1 = SCALED( point[-2].x ); - y1 = SCALED( point[-2].y ); - x2 = SCALED( point[-1].x ); - y2 = SCALED( point[-1].y ); - x3 = SCALED( point[ 0].x ); - y3 = SCALED( point[ 0].y ); - - if ( flipped ) - { - SWAP_( x1, y1 ); - SWAP_( x2, y2 ); - SWAP_( x3, y3 ); - } - - if ( point <= limit ) - { - if ( Cubic_To( RAS_VARS x1, y1, x2, y2, x3, y3 ) ) - goto Fail; - continue; - } - - if ( Cubic_To( RAS_VARS x1, y1, x2, y2, v_start.x, v_start.y ) ) - goto Fail; - goto Close; - } - } - } - - /* close the contour with a line segment */ - if ( Line_To( RAS_VARS v_start.x, v_start.y ) ) - goto Fail; - - Close: - return SUCCESS; - - Invalid_Outline: - ras.error = Raster_Err_Invalid; - - Fail: - return FAILURE; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Convert_Glyph */ - /* */ - /* */ - /* Converts a glyph into a series of segments and arcs and makes a */ - /* profiles list with them. */ - /* */ - /* */ - /* flipped :: If set, flip the direction of curve. */ - /* */ - /* */ - /* SUCCESS on success, FAILURE if any error was encountered during */ - /* rendering. */ - /* */ - static - Bool Convert_Glyph( RAS_ARGS int flipped ) - { - Short i; - UShort start; - - PProfile lastProfile; - - - ras.fProfile = NULL; - ras.joint = FALSE; - ras.fresh = FALSE; - - ras.maxBuff = ras.sizeBuff - AlignProfileSize; - - ras.numTurns = 0; - - ras.cProfile = (PProfile)ras.top; - ras.cProfile->offset = ras.top; - ras.num_Profs = 0; - - start = 0; - - for ( i = 0; i < ras.outline.n_contours; i++ ) - { - ras.state = Unknown; - ras.gProfile = NULL; - - if ( Decompose_Curve( RAS_VARS start, ras.outline.contours[i], flipped ) ) - return FAILURE; - - start = ras.outline.contours[i] + 1; - - /* We must now see whether the extreme arcs join or not */ - if ( FRAC( ras.lastY ) == 0 && - ras.lastY >= ras.minY && - ras.lastY <= ras.maxY ) - if ( ras.gProfile && ras.gProfile->flow == ras.cProfile->flow ) - ras.top--; - /* Note that ras.gProfile can be nil if the contour was too small */ - /* to be drawn. */ - - lastProfile = ras.cProfile; - if ( End_Profile( RAS_VAR ) ) - return FAILURE; - - /* close the `next profile in contour' linked list */ - if ( ras.gProfile ) - lastProfile->next = ras.gProfile; - } - - if ( Finalize_Profile_Table( RAS_VAR ) ) - return FAILURE; - - return ( ras.top < ras.maxBuff ? SUCCESS : FAILURE ); - } - - - /*************************************************************************/ - /*************************************************************************/ - /** **/ - /** SCAN-LINE SWEEPS AND DRAWING **/ - /** **/ - /*************************************************************************/ - /*************************************************************************/ - - - /*************************************************************************/ - /* */ - /* Init_Linked */ - /* */ - /* Initializes an empty linked list. */ - /* */ - static - void Init_Linked( TProfileList* l ) - { - *l = NULL; - } - - - /*************************************************************************/ - /* */ - /* InsNew */ - /* */ - /* Inserts a new profile in a linked list. */ - /* */ - static - void InsNew( PProfileList list, - PProfile profile ) - { - PProfile *old, current; - Long x; - - - old = list; - current = *old; - x = profile->X; - - while ( current ) - { - if ( x < current->X ) - break; - old = ¤t->link; - current = *old; - } - - profile->link = current; - *old = profile; - } - - - /*************************************************************************/ - /* */ - /* DelOld */ - /* */ - /* Removes an old profile from a linked list. */ - /* */ - static - void DelOld( PProfileList list, - PProfile profile ) - { - PProfile *old, current; - - - old = list; - current = *old; - - while ( current ) - { - if ( current == profile ) - { - *old = current->link; - return; - } - - old = ¤t->link; - current = *old; - } - - /* we should never get there, unless the profile was not part of */ - /* the list. */ - } - - - /*************************************************************************/ - /* */ - /* Update */ - /* */ - /* Update all X offsets of a drawing list. */ - /* */ - static - void Update( PProfile first ) - { - PProfile current = first; - - - while ( current ) - { - current->X = *current->offset; - current->offset += current->flow; - current->height--; - current = current->link; - } - } - - - /*************************************************************************/ - /* */ - /* Sort */ - /* */ - /* Sorts a trace list. In 95%, the list is already sorted. We need */ - /* an algorithm which is fast in this case. Bubble sort is enough */ - /* and simple. */ - /* */ - static - void Sort( PProfileList list ) - { - PProfile *old, current, next; - - - /* First, set the new X coordinate of each profile */ - Update( *list ); - - /* Then sort them */ - old = list; - current = *old; - - if ( !current ) - return; - - next = current->link; - - while ( next ) - { - if ( current->X <= next->X ) - { - old = ¤t->link; - current = *old; - - if ( !current ) - return; - } - else - { - *old = next; - current->link = next->link; - next->link = current; - - old = list; - current = *old; - } - - next = current->link; - } - } - - - /*************************************************************************/ - /* */ - /* Vertical Sweep Procedure Set */ - /* */ - /* These four routines are used during the vertical black/white sweep */ - /* phase by the generic Draw_Sweep() function. */ - /* */ - /*************************************************************************/ - - static - void Vertical_Sweep_Init( RAS_ARGS Short* min, - Short* max ) - { - Long pitch = ras.target.pitch; - - FT_UNUSED( max ); - - - ras.traceIncr = (Short)-pitch; - ras.traceOfs = -*min * pitch; - if ( pitch > 0 ) - ras.traceOfs += ( ras.target.rows - 1 ) * pitch; - - ras.gray_min_x = 0; - ras.gray_max_x = 0; - } - - - static - void Vertical_Sweep_Span( RAS_ARGS Short y, - FT_F26Dot6 x1, - FT_F26Dot6 x2, - PProfile left, - PProfile right ) - { - Long e1, e2; - Short c1, c2; - Byte f1, f2; - Byte* target; - - FT_UNUSED( y ); - FT_UNUSED( left ); - FT_UNUSED( right ); - - - /* Drop-out control */ - - e1 = TRUNC( CEILING( x1 ) ); - - if ( x2 - x1 - ras.precision <= ras.precision_jitter ) - e2 = e1; - else - e2 = TRUNC( FLOOR( x2 ) ); - - if ( e2 >= 0 && e1 < ras.bWidth ) - { - if ( e1 < 0 ) - e1 = 0; - if ( e2 >= ras.bWidth ) - e2 = ras.bWidth - 1; - - c1 = (Short)( e1 >> 3 ); - c2 = (Short)( e2 >> 3 ); - - f1 = (unsigned char)0xFF >> ( e1 & 7 ); - f2 = ~( (unsigned char)0x7F >> ( e2 & 7 ) ); - - if ( ras.gray_min_x > c1 ) ras.gray_min_x = c1; - if ( ras.gray_max_x < c2 ) ras.gray_max_x = c2; - - target = ras.bTarget + ras.traceOfs + c1; - c2 -= c1; - - if ( c2 > 0 ) - { - target[0] |= f1; - - /* memset() is slower than the following code on many platforms. */ - /* This is due to the fact that, in the vast majority of cases, */ - /* the span length in bytes is relatively small. */ - c2--; - while ( c2 > 0 ) - { - *(++target) = 0xFF; - c2--; - } - target[1] |= f2; - } - else - *target |= ( f1 & f2 ); - } - } - - - static - void Vertical_Sweep_Drop( RAS_ARGS Short y, - FT_F26Dot6 x1, - FT_F26Dot6 x2, - PProfile left, - PProfile right ) - { - Long e1, e2; - Short c1, f1; - - - /* Drop-out control */ - - e1 = CEILING( x1 ); - e2 = FLOOR ( x2 ); - - if ( e1 > e2 ) - { - if ( e1 == e2 + ras.precision ) - { - switch ( ras.dropOutControl ) - { - case 1: - e1 = e2; - break; - - case 4: - e1 = CEILING( (x1 + x2 + 1) / 2 ); - break; - - case 2: - case 5: - /* Drop-out Control Rule #4 */ - - /* The spec is not very clear regarding rule #4. It */ - /* presents a method that is way too costly to implement */ - /* while the general idea seems to get rid of `stubs'. */ - /* */ - /* Here, we only get rid of stubs recognized if: */ - /* */ - /* upper stub: */ - /* */ - /* - P_Left and P_Right are in the same contour */ - /* - P_Right is the successor of P_Left in that contour */ - /* - y is the top of P_Left and P_Right */ - /* */ - /* lower stub: */ - /* */ - /* - P_Left and P_Right are in the same contour */ - /* - P_Left is the successor of P_Right in that contour */ - /* - y is the bottom of P_Left */ - /* */ - - /* FIXXXME: uncommenting this line solves the disappearing */ - /* bit problem in the `7' of verdana 10pts, but */ - /* makes a new one in the `C' of arial 14pts */ - -#if 0 - if ( x2 - x1 < ras.precision_half ) -#endif - { - /* upper stub test */ - if ( left->next == right && left->height <= 0 ) - return; - - /* lower stub test */ - if ( right->next == left && left->start == y ) - return; - } - - /* check that the rightmost pixel isn't set */ - - e1 = TRUNC( e1 ); - - c1 = (Short)( e1 >> 3 ); - f1 = e1 & 7; - - if ( e1 >= 0 && e1 < ras.bWidth && - ras.bTarget[ras.traceOfs + c1] & ( 0x80 >> f1 ) ) - return; - - if ( ras.dropOutControl == 2 ) - e1 = e2; - else - e1 = CEILING( ( x1 + x2 + 1 ) / 2 ); - - break; - - default: - return; /* unsupported mode */ - } - } - else - return; - } - - e1 = TRUNC( e1 ); - - if ( e1 >= 0 && e1 < ras.bWidth ) - { - c1 = (Short)( e1 >> 3 ); - f1 = e1 & 7; - - if ( ras.gray_min_x > c1 ) ras.gray_min_x = c1; - if ( ras.gray_max_x < c1 ) ras.gray_max_x = c1; - - ras.bTarget[ras.traceOfs + c1] |= (char)( 0x80 >> f1 ); - } - } - - - static - void Vertical_Sweep_Step( RAS_ARG ) - { - ras.traceOfs += ras.traceIncr; - } - - - /***********************************************************************/ - /* */ - /* Horizontal Sweep Procedure Set */ - /* */ - /* These four routines are used during the horizontal black/white */ - /* sweep phase by the generic Draw_Sweep() function. */ - /* */ - /***********************************************************************/ - - static - void Horizontal_Sweep_Init( RAS_ARGS Short* min, - Short* max ) - { - /* nothing, really */ - FT_UNUSED( raster ); - FT_UNUSED( min ); - FT_UNUSED( max ); - } - - - static - void Horizontal_Sweep_Span( RAS_ARGS Short y, - FT_F26Dot6 x1, - FT_F26Dot6 x2, - PProfile left, - PProfile right ) - { - Long e1, e2; - PByte bits; - Byte f1; - - FT_UNUSED( left ); - FT_UNUSED( right ); - - - if ( x2 - x1 < ras.precision ) - { - e1 = CEILING( x1 ); - e2 = FLOOR ( x2 ); - - if ( e1 == e2 ) - { - bits = ras.bTarget + ( y >> 3 ); - f1 = (Byte)( 0x80 >> ( y & 7 ) ); - - e1 = TRUNC( e1 ); - - if ( e1 >= 0 && e1 < ras.target.rows ) - { - PByte p; - - - p = bits - e1*ras.target.pitch; - if ( ras.target.pitch > 0 ) - p += ( ras.target.rows - 1 ) * ras.target.pitch; - - p[0] |= f1; - } - } - } - } - - - static - void Horizontal_Sweep_Drop( RAS_ARGS Short y, - FT_F26Dot6 x1, - FT_F26Dot6 x2, - PProfile left, - PProfile right ) - { - Long e1, e2; - PByte bits; - Byte f1; - - - /* During the horizontal sweep, we only take care of drop-outs */ - - e1 = CEILING( x1 ); - e2 = FLOOR ( x2 ); - - if ( e1 > e2 ) - { - if ( e1 == e2 + ras.precision ) - { - switch ( ras.dropOutControl ) - { - case 1: - e1 = e2; - break; - - case 4: - e1 = CEILING( ( x1 + x2 + 1 ) / 2 ); - break; - - case 2: - case 5: - - /* Drop-out Control Rule #4 */ - - /* The spec is not very clear regarding rule #4. It */ - /* presents a method that is way too costly to implement */ - /* while the general idea seems to get rid of `stubs'. */ - /* */ - - /* rightmost stub test */ - if ( left->next == right && left->height <= 0 ) - return; - - /* leftmost stub test */ - if ( right->next == left && left->start == y ) - return; - - /* check that the rightmost pixel isn't set */ - - e1 = TRUNC( e1 ); - - bits = ras.bTarget + ( y >> 3 ); - f1 = (Byte)( 0x80 >> ( y & 7 ) ); - - bits -= e1 * ras.target.pitch; - if ( ras.target.pitch > 0 ) - bits += ( ras.target.rows - 1 ) * ras.target.pitch; - - if ( e1 >= 0 && - e1 < ras.target.rows && - *bits & f1 ) - return; - - if ( ras.dropOutControl == 2 ) - e1 = e2; - else - e1 = CEILING( ( x1 + x2 + 1 ) / 2 ); - - break; - - default: - return; /* unsupported mode */ - } - } - else - return; - } - - bits = ras.bTarget + ( y >> 3 ); - f1 = (Byte)( 0x80 >> ( y & 7 ) ); - - e1 = TRUNC( e1 ); - - if ( e1 >= 0 && e1 < ras.target.rows ) - { - bits -= e1 * ras.target.pitch; - if ( ras.target.pitch > 0 ) - bits += ( ras.target.rows - 1 ) * ras.target.pitch; - - bits[0] |= f1; - } - } - - - static - void Horizontal_Sweep_Step( RAS_ARG ) - { - /* Nothing, really */ - FT_UNUSED( raster ); - } - - -#ifdef FT_RASTER_OPTION_ANTI_ALIASING - - - /*************************************************************************/ - /* */ - /* Vertical Gray Sweep Procedure Set */ - /* */ - /* These two routines are used during the vertical gray-levels sweep */ - /* phase by the generic Draw_Sweep() function. */ - /* */ - /* NOTES */ - /* */ - /* - The target pixmap's width *must* be a multiple of 4. */ - /* */ - /* - You have to use the function Vertical_Sweep_Span() for the gray */ - /* span call. */ - /* */ - /*************************************************************************/ - - static - void Vertical_Gray_Sweep_Init( RAS_ARGS Short* min, - Short* max ) - { - Long pitch, byte_len; - - - *min = *min & -2; - *max = ( *max + 3 ) & -2; - - ras.traceOfs = 0; - pitch = ras.target.pitch; - byte_len = -pitch; - ras.traceIncr = (Short)byte_len; - ras.traceG = ( *min / 2 ) * byte_len; - - if ( pitch > 0 ) - { - ras.traceG += ( ras.target.rows - 1 ) * pitch; - byte_len = -byte_len; - } - - ras.gray_min_x = (Short)byte_len; - ras.gray_max_x = -(Short)byte_len; - } - - - static - void Vertical_Gray_Sweep_Step( RAS_ARG ) - { - Int c1, c2; - PByte pix, bit, bit2; - Int* count = ras.count_table; - Byte* grays; - - - ras.traceOfs += ras.gray_width; - - if ( ras.traceOfs > ras.gray_width ) - { - pix = ras.gTarget + ras.traceG + ras.gray_min_x * 4; - grays = ras.grays; - - if ( ras.gray_max_x >= 0 ) - { - Long last_pixel = ras.target.width - 1; - Int last_cell = last_pixel >> 2; - Int last_bit = last_pixel & 3; - Bool over = 0; - - - if ( ras.gray_max_x >= last_cell && last_bit != 3 ) - { - ras.gray_max_x = last_cell - 1; - over = 1; - } - - if ( ras.gray_min_x < 0 ) - ras.gray_min_x = 0; - - bit = ras.bTarget + ras.gray_min_x; - bit2 = bit + ras.gray_width; - - c1 = ras.gray_max_x - ras.gray_min_x; - - while ( c1 >= 0 ) - { - c2 = count[*bit] + count[*bit2]; - - if ( c2 ) - { - pix[0] = grays[(c2 >> 12) & 0x000F]; - pix[1] = grays[(c2 >> 8 ) & 0x000F]; - pix[2] = grays[(c2 >> 4 ) & 0x000F]; - pix[3] = grays[ c2 & 0x000F]; - - *bit = 0; - *bit2 = 0; - } - - bit++; - bit2++; - pix += 4; - c1--; - } - - if ( over ) - { - c2 = count[*bit] + count[*bit2]; - if ( c2 ) - { - switch ( last_bit ) - { - case 2: - pix[2] = grays[(c2 >> 4 ) & 0x000F]; - case 1: - pix[1] = grays[(c2 >> 8 ) & 0x000F]; - default: - pix[0] = grays[(c2 >> 12) & 0x000F]; - } - - *bit = 0; - *bit2 = 0; - } - } - } - - ras.traceOfs = 0; - ras.traceG += ras.traceIncr; - - ras.gray_min_x = 32000; - ras.gray_max_x = -32000; - } - } - - - static - void Horizontal_Gray_Sweep_Span( RAS_ARGS Short y, - FT_F26Dot6 x1, - FT_F26Dot6 x2, - PProfile left, - PProfile right ) - { - /* nothing, really */ - FT_UNUSED( raster ); - FT_UNUSED( y ); - FT_UNUSED( x1 ); - FT_UNUSED( x2 ); - FT_UNUSED( left ); - FT_UNUSED( right ); - } - - - static - void Horizontal_Gray_Sweep_Drop( RAS_ARGS Short y, - FT_F26Dot6 x1, - FT_F26Dot6 x2, - PProfile left, - PProfile right ) - { - Long e1, e2; - PByte pixel; - Byte color; - - - /* During the horizontal sweep, we only take care of drop-outs */ - e1 = CEILING( x1 ); - e2 = FLOOR ( x2 ); - - if ( e1 > e2 ) - { - if ( e1 == e2 + ras.precision ) - { - switch ( ras.dropOutControl ) - { - case 1: - e1 = e2; - break; - - case 4: - e1 = CEILING( ( x1 + x2 + 1 ) / 2 ); - break; - - case 2: - case 5: - - /* Drop-out Control Rule #4 */ - - /* The spec is not very clear regarding rule #4. It */ - /* presents a method that is way too costly to implement */ - /* while the general idea seems to get rid of `stubs'. */ - /* */ - - /* rightmost stub test */ - if ( left->next == right && left->height <= 0 ) - return; - - /* leftmost stub test */ - if ( right->next == left && left->start == y ) - return; - - if ( ras.dropOutControl == 2 ) - e1 = e2; - else - e1 = CEILING( ( x1 + x2 + 1 ) / 2 ); - - break; - - default: - return; /* unsupported mode */ - } - } - else - return; - } - - if ( e1 >= 0 ) - { - if ( x2 - x1 >= ras.precision_half ) - color = ras.grays[2]; - else - color = ras.grays[1]; - - e1 = TRUNC( e1 ) / 2; - if ( e1 < ras.target.rows ) - { - pixel = ras.gTarget - e1 * ras.target.pitch + y / 2; - if ( ras.target.pitch > 0 ) - pixel += ( ras.target.rows - 1 ) * ras.target.pitch; - - if ( pixel[0] == ras.grays[0] ) - pixel[0] = color; - } - } - } - - -#endif /* FT_RASTER_OPTION_ANTI_ALIASING */ - - - /*************************************************************************/ - /* */ - /* Generic Sweep Drawing routine */ - /* */ - /*************************************************************************/ - - static - Bool Draw_Sweep( RAS_ARG ) - { - Short y, y_change, y_height; - - PProfile P, Q, P_Left, P_Right; - - Short min_Y, max_Y, top, bottom, dropouts; - - Long x1, x2, xs, e1, e2; - - TProfileList wait; - TProfileList draw_left, draw_right; - - - /* Init empty linked lists */ - - Init_Linked( &wait ); - - Init_Linked( &draw_left ); - Init_Linked( &draw_right ); - - /* first, compute min and max Y */ - - P = ras.fProfile; - max_Y = (Short)TRUNC( ras.minY ); - min_Y = (Short)TRUNC( ras.maxY ); - - while ( P ) - { - Q = P->link; - - bottom = (Short)P->start; - top = (Short)P->start + P->height - 1; - - if ( min_Y > bottom ) min_Y = bottom; - if ( max_Y < top ) max_Y = top; - - P->X = 0; - InsNew( &wait, P ); - - P = Q; - } - - /* Check the Y-turns */ - if ( ras.numTurns == 0 ) - { - ras.error = Raster_Err_Invalid; - return FAILURE; - } - - /* Now inits the sweep */ - - ras.Proc_Sweep_Init( RAS_VARS &min_Y, &max_Y ); - - /* Then compute the distance of each profile from min_Y */ - - P = wait; - - while ( P ) - { - P->countL = P->start - min_Y; - P = P->link; - } - - /* Let's go */ - - y = min_Y; - y_height = 0; - - if ( ras.numTurns > 0 && - ras.sizeBuff[-ras.numTurns] == min_Y ) - ras.numTurns--; - - while ( ras.numTurns > 0 ) - { - /* look in the wait list for new activations */ - - P = wait; - - while ( P ) - { - Q = P->link; - P->countL -= y_height; - if ( P->countL == 0 ) - { - DelOld( &wait, P ); - - switch ( P->flow ) - { - case Flow_Up: - InsNew( &draw_left, P ); - break; - - case Flow_Down: - InsNew( &draw_right, P ); - break; - } - } - - P = Q; - } - - /* Sort the drawing lists */ - - Sort( &draw_left ); - Sort( &draw_right ); - - y_change = (Short)ras.sizeBuff[-ras.numTurns--]; - y_height = y_change - y; - - while ( y < y_change ) - { - /* Let's trace */ - - dropouts = 0; - - P_Left = draw_left; - P_Right = draw_right; - - while ( P_Left ) - { - x1 = P_Left ->X; - x2 = P_Right->X; - - if ( x1 > x2 ) - { - xs = x1; - x1 = x2; - x2 = xs; - } - - if ( x2 - x1 <= ras.precision ) - { - e1 = FLOOR( x1 ); - e2 = CEILING( x2 ); - - if ( ras.dropOutControl != 0 && - ( e1 > e2 || e2 == e1 + ras.precision ) ) - { - /* a drop out was detected */ - - P_Left ->X = x1; - P_Right->X = x2; - - /* mark profile for drop-out processing */ - P_Left->countL = 1; - dropouts++; - - goto Skip_To_Next; - } - } - - ras.Proc_Sweep_Span( RAS_VARS y, x1, x2, P_Left, P_Right ); - - Skip_To_Next: - - P_Left = P_Left->link; - P_Right = P_Right->link; - } - - /* now perform the dropouts _after_ the span drawing -- */ - /* drop-outs processing has been moved out of the loop */ - /* for performance tuning */ - if ( dropouts > 0 ) - goto Scan_DropOuts; - - Next_Line: - - ras.Proc_Sweep_Step( RAS_VAR ); - - y++; - - if ( y < y_change ) - { - Sort( &draw_left ); - Sort( &draw_right ); - } - } - - /* Now finalize the profiles that needs it */ - - P = draw_left; - while ( P ) - { - Q = P->link; - if ( P->height == 0 ) - DelOld( &draw_left, P ); - P = Q; - } - - P = draw_right; - while ( P ) - { - Q = P->link; - if ( P->height == 0 ) - DelOld( &draw_right, P ); - P = Q; - } - } - - /* for gray-scaling, flushes the bitmap scanline cache */ - while ( y <= max_Y ) - { - ras.Proc_Sweep_Step( RAS_VAR ); - y++; - } - - return SUCCESS; - - Scan_DropOuts: - - P_Left = draw_left; - P_Right = draw_right; - - while ( P_Left ) - { - if ( P_Left->countL ) - { - P_Left->countL = 0; -#if 0 - dropouts--; /* -- this is useful when debugging only */ -#endif - ras.Proc_Sweep_Drop( RAS_VARS y, - P_Left->X, - P_Right->X, - P_Left, - P_Right ); - } - - P_Left = P_Left->link; - P_Right = P_Right->link; - } - - goto Next_Line; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Render_Single_Pass */ - /* */ - /* */ - /* Performs one sweep with sub-banding. */ - /* */ - /* */ - /* flipped :: If set, flip the direction of the outline. */ - /* */ - /* */ - /* Renderer error code. */ - /* */ - static - int Render_Single_Pass( RAS_ARGS Bool flipped ) - { - Short i, j, k; - - - while ( ras.band_top >= 0 ) - { - ras.maxY = (Long)ras.band_stack[ras.band_top].y_max * ras.precision; - ras.minY = (Long)ras.band_stack[ras.band_top].y_min * ras.precision; - - ras.top = ras.buff; - - ras.error = Raster_Err_None; - - if ( Convert_Glyph( RAS_VARS flipped ) ) - { - if ( ras.error != Raster_Err_Overflow ) - return FAILURE; - - ras.error = Raster_Err_None; - - /* sub-banding */ - -#ifdef DEBUG_RASTER - ClearBand( RAS_VARS TRUNC( ras.minY ), TRUNC( ras.maxY ) ); -#endif - - i = ras.band_stack[ras.band_top].y_min; - j = ras.band_stack[ras.band_top].y_max; - - k = ( i + j ) / 2; - - if ( ras.band_top >= 7 || k < i ) - { - ras.band_top = 0; - ras.error = Raster_Err_Invalid; - - return ras.error; - } - - ras.band_stack[ras.band_top + 1].y_min = k; - ras.band_stack[ras.band_top + 1].y_max = j; - - ras.band_stack[ras.band_top].y_max = k - 1; - - ras.band_top++; - } - else - { - if ( ras.fProfile ) - if ( Draw_Sweep( RAS_VAR ) ) - return ras.error; - ras.band_top--; - } - } - - return SUCCESS; - } - - - /*************************************************************************/ - /* */ - /* */ - /* Render_Glyph */ - /* */ - /* */ - /* Renders a glyph in a bitmap. Sub-banding if needed. */ - /* */ - /* */ - /* FreeType error code. 0 means success. */ - /* */ - LOCAL_FUNC - FT_Error Render_Glyph( RAS_ARG ) - { - FT_Error error; - - - Set_High_Precision( RAS_VARS ras.outline.flags & - ft_outline_high_precision ); - ras.scale_shift = ras.precision_shift; - ras.dropOutControl = 2; - ras.second_pass = !( ras.outline.flags & ft_outline_single_pass ); - - /* Vertical Sweep */ - ras.Proc_Sweep_Init = Vertical_Sweep_Init; - ras.Proc_Sweep_Span = Vertical_Sweep_Span; - ras.Proc_Sweep_Drop = Vertical_Sweep_Drop; - ras.Proc_Sweep_Step = Vertical_Sweep_Step; - - ras.band_top = 0; - ras.band_stack[0].y_min = 0; - ras.band_stack[0].y_max = ras.target.rows - 1; - - ras.bWidth = ras.target.width; - ras.bTarget = (Byte*)ras.target.buffer; - - if ( ( error = Render_Single_Pass( RAS_VARS 0 ) ) != 0 ) - return error; - - /* Horizontal Sweep */ - if ( ras.second_pass && ras.dropOutControl != 0 ) - { - ras.Proc_Sweep_Init = Horizontal_Sweep_Init; - ras.Proc_Sweep_Span = Horizontal_Sweep_Span; - ras.Proc_Sweep_Drop = Horizontal_Sweep_Drop; - ras.Proc_Sweep_Step = Horizontal_Sweep_Step; - - ras.band_top = 0; - ras.band_stack[0].y_min = 0; - ras.band_stack[0].y_max = ras.target.width - 1; - - if ( ( error = Render_Single_Pass( RAS_VARS 1 ) ) != 0 ) - return error; - } - - return FT_Err_Ok; - } - - -#ifdef FT_RASTER_OPTION_ANTI_ALIASING - - - /*************************************************************************/ - /* */ - /* */ - /* Render_Gray_Glyph */ - /* */ - /* */ - /* Renders a glyph with grayscaling. Sub-banding if needed. */ - /* */ - /* */ - /* FreeType error code. 0 means success. */ - /* */ - LOCAL_FUNC - FT_Error Render_Gray_Glyph( RAS_ARG ) - { - Long pixel_width; - FT_Error error; - - - Set_High_Precision( RAS_VARS ras.outline.flags & - ft_outline_high_precision ); - ras.scale_shift = ras.precision_shift + 1; - ras.dropOutControl = 2; - ras.second_pass = !( ras.outline.flags & ft_outline_single_pass ); - - /* Vertical Sweep */ - - ras.band_top = 0; - ras.band_stack[0].y_min = 0; - ras.band_stack[0].y_max = 2 * ras.target.rows - 1; - - ras.bWidth = ras.gray_width; - pixel_width = 2 * ( ( ras.target.width + 3 ) >> 2 ); - - if ( ras.bWidth > pixel_width ) - ras.bWidth = pixel_width; - - ras.bWidth = ras.bWidth * 8; - ras.bTarget = (Byte*)ras.gray_lines; - ras.gTarget = (Byte*)ras.target.buffer; - - ras.Proc_Sweep_Init = Vertical_Gray_Sweep_Init; - ras.Proc_Sweep_Span = Vertical_Sweep_Span; - ras.Proc_Sweep_Drop = Vertical_Sweep_Drop; - ras.Proc_Sweep_Step = Vertical_Gray_Sweep_Step; - - error = Render_Single_Pass( RAS_VARS 0 ); - if ( error ) - return error; - - /* Horizontal Sweep */ - if ( ras.second_pass && ras.dropOutControl != 0 ) - { - ras.Proc_Sweep_Init = Horizontal_Sweep_Init; - ras.Proc_Sweep_Span = Horizontal_Gray_Sweep_Span; - ras.Proc_Sweep_Drop = Horizontal_Gray_Sweep_Drop; - ras.Proc_Sweep_Step = Horizontal_Sweep_Step; - - ras.band_top = 0; - ras.band_stack[0].y_min = 0; - ras.band_stack[0].y_max = ras.target.width * 2 - 1; - - error = Render_Single_Pass( RAS_VARS 1 ); - if ( error ) - return error; - } - - return FT_Err_Ok; - } - -#else /* FT_RASTER_OPTION_ANTI_ALIASING */ - - LOCAL_FUNC - FT_Error Render_Gray_Glyph( RAS_ARG ) - { - FT_UNUSED_RASTER; - - return FT_Err_Cannot_Render_Glyph; - } - -#endif /* FT_RASTER_OPTION_ANTI_ALIASING */ - - - static - void ft_black_init( TRaster_Instance* raster ) - { - FT_UInt n; - FT_ULong c; - - - /* setup count table */ - for ( n = 0; n < 256; n++ ) - { - c = ( n & 0x55 ) + ( ( n & 0xAA ) >> 1 ); - - c = ( ( c << 6 ) & 0x3000 ) | - ( ( c << 4 ) & 0x0300 ) | - ( ( c << 2 ) & 0x0030 ) | - (c & 0x0003 ); - - raster->count_table[n] = c; - } - -#ifdef FT_RASTER_OPTION_ANTI_ALIASING - - /* set default 5-levels gray palette */ - for ( n = 0; n < 5; n++ ) - raster->grays[n] = n * 255 / 4; - - raster->gray_width = RASTER_GRAY_LINES / 2; - -#endif - } - - - /**** RASTER OBJECT CREATION: In standalone mode, we simply use *****/ - /**** a static object. *****/ - - -#ifdef _STANDALONE_ - - - static - int ft_black_new( void* memory, - FT_Raster *araster ) - { - static FT_RasterRec_ the_raster; - - - *araster = &the_raster; - memset( &the_raster, sizeof ( the_raster ), 0 ); - ft_black_init( &the_raster ); - - return 0; - } - - - static - void ft_black_done( FT_Raster raster ) - { - /* nothing */ - raster->init = 0; - } - - -#else /* _STANDALONE_ */ - - - static - int ft_black_new( FT_Memory memory, - TRaster_Instance** araster ) - { - FT_Error error; - TRaster_Instance* raster; - - - *araster = 0; - if ( !ALLOC( raster, sizeof ( *raster ) ) ) - { - raster->memory = memory; - ft_black_init( raster ); - - *araster = raster; - } - - return error; - } - - - static - void ft_black_done( TRaster_Instance* raster ) - { - FT_Memory memory = (FT_Memory)raster->memory; - FREE( raster ); - } - - -#endif /* _STANDALONE_ */ - - - static - void ft_black_reset( TRaster_Instance* raster, - const char* pool_base, - long pool_size ) - { - if ( raster && pool_base && pool_size >= 4096 ) - { - /* save the pool */ - raster->buff = (PLong)pool_base; - raster->sizeBuff = raster->buff + pool_size / sizeof ( Long ); - } - } - - - static - void ft_black_set_mode( TRaster_Instance* raster, - unsigned long mode, - const char* palette ) - { -#ifdef FT_RASTER_OPTION_ANTI_ALIASING - - if ( mode == FT_MAKE_TAG( 'p', 'a', 'l', '5' ) ) - { - /* set 5-levels gray palette */ - raster->grays[0] = palette[0]; - raster->grays[1] = palette[1]; - raster->grays[2] = palette[2]; - raster->grays[3] = palette[3]; - raster->grays[4] = palette[4]; - } - -#else - - FT_UNUSED( raster ); - FT_UNUSED( mode ); - FT_UNUSED( palette ); - -#endif - } - - - static - int ft_black_render( TRaster_Instance* raster, - FT_Raster_Params* params ) - { - FT_Outline* outline = (FT_Outline*)params->source; - FT_Bitmap* target_map = params->target; - - - if ( !raster || !raster->buff || !raster->sizeBuff ) - return Raster_Err_Not_Ini; - - /* return immediately if the outline is empty */ - if ( outline->n_points == 0 || outline->n_contours <= 0 ) - return Raster_Err_None; - - if ( !outline || !outline->contours || !outline->points ) - return Raster_Err_Invalid; - - if ( outline->n_points != outline->contours[outline->n_contours - 1] + 1 ) - return Raster_Err_Invalid; - - if ( !target_map || !target_map->buffer ) - return Raster_Err_Invalid; - - /* this version of the raster does not support direct rendering, sorry */ - if ( params->flags & ft_raster_flag_direct ) - return Raster_Err_Unsupported; - - ras.outline = *outline; - ras.target = *target_map; - - return ( ( params->flags & ft_raster_flag_aa ) - ? Render_Gray_Glyph( raster ) - : Render_Glyph( raster ) ); - } - - - const FT_Raster_Funcs ft_standard_raster = - { - ft_glyph_format_outline, - (FT_Raster_New_Func) ft_black_new, - (FT_Raster_Reset_Func) ft_black_reset, - (FT_Raster_Set_Mode_Func)ft_black_set_mode, - (FT_Raster_Render_Func) ft_black_render, - (FT_Raster_Done_Func) ft_black_done - }; - - -/* END */ diff --git a/src/raster1/ftraster.h b/src/raster1/ftraster.h deleted file mode 100644 index 36fa51cd8..000000000 --- a/src/raster1/ftraster.h +++ /dev/null @@ -1,50 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftraster.h */ -/* */ -/* The FreeType glyph rasterizer (specification). */ -/* */ -/* Copyright 1996-2000 by */ -/* David Turner, Robert Wilhelm, and Werner Lemberg. */ -/* */ -/* This file is part of the FreeType project, and may only be used */ -/* modified and distributed under the terms of the FreeType project */ -/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ -/* this file you indicate that you have read the license and */ -/* understand and accept it fully. */ -/* */ -/***************************************************************************/ - - -#ifndef FTRASTER_H -#define FTRASTER_H - -#ifdef __cplusplus - extern "C" { -#endif - -#include - - - /*************************************************************************/ - /* */ - /* Uncomment the following line if you are using ftraster.c as a */ - /* standalone module, fully independent of FreeType. */ - /* */ -/* #define _STANDALONE_ */ - -#ifndef FT_EXPORT_VAR -#define FT_EXPORT_VAR( x ) extern x -#endif - - FT_EXPORT_VAR( const FT_Raster_Funcs ) ft_standard_raster; - -#ifdef __cplusplus - } -#endif - - -#endif /* FTRASTER_H */ - - -/* END */ diff --git a/src/raster1/ftrend1.c b/src/raster1/ftrend1.c deleted file mode 100644 index 891610556..000000000 --- a/src/raster1/ftrend1.c +++ /dev/null @@ -1,276 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftrend1.c */ -/* */ -/* The FreeType glyph rasterizer interface (body). */ -/* */ -/* Copyright 1996-2000 by */ -/* David Turner, Robert Wilhelm, and Werner Lemberg. */ -/* */ -/* This file is part of the FreeType project, and may only be used, */ -/* modified, and distributed under the terms of the FreeType project */ -/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ -/* this file you indicate that you have read the license and */ -/* understand and accept it fully. */ -/* */ -/***************************************************************************/ - - -#include -#include - - -#ifdef FT_FLAT_COMPILE - -#include "ftrend1.h" -#include "ftraster.h" - -#else - -#include -#include - -#endif - - - /* initialize renderer -- init its raster */ - static - FT_Error ft_raster1_init( FT_Renderer render ) - { - FT_Library library = FT_MODULE_LIBRARY( render ); - - - render->clazz->raster_class->raster_reset( render->raster, - library->raster_pool, - library->raster_pool_size ); - - return FT_Err_Ok; - } - - - /* set render-specific mode */ - static - FT_Error ft_raster1_set_mode( FT_Renderer render, - FT_ULong mode_tag, - FT_Pointer data ) - { - /* we simply pass it to the raster */ - return render->clazz->raster_class->raster_set_mode( render->raster, - mode_tag, - data ); - } - - - /* transform a given glyph image */ - static - FT_Error ft_raster1_transform( FT_Renderer render, - FT_GlyphSlot slot, - FT_Matrix* matrix, - FT_Vector* delta ) - { - FT_Error error = FT_Err_Ok; - - - if ( slot->format != render->glyph_format ) - { - error = FT_Err_Invalid_Argument; - goto Exit; - } - - if ( matrix ) - FT_Outline_Transform( &slot->outline, matrix ); - - if ( delta ) - FT_Outline_Translate( &slot->outline, delta->x, delta->y ); - - Exit: - return error; - } - - - /* return the glyph's control box */ - static - void ft_raster1_get_cbox( FT_Renderer render, - FT_GlyphSlot slot, - FT_BBox* cbox ) - { - MEM_Set( cbox, 0, sizeof ( *cbox ) ); - - if ( slot->format == render->glyph_format ) - FT_Outline_Get_CBox( &slot->outline, cbox ); - } - - - /* convert a slot's glyph image into a bitmap */ - static - FT_Error ft_raster1_render( FT_Renderer render, - FT_GlyphSlot slot, - FT_UInt mode, - FT_Vector* origin ) - { - FT_Error error; - FT_Outline* outline; - FT_BBox cbox; - FT_UInt width, height, pitch; - FT_Bitmap* bitmap; - FT_Memory memory; - - FT_Raster_Params params; - - - /* check glyph image format */ - if ( slot->format != render->glyph_format ) - { - error = FT_Err_Invalid_Argument; - goto Exit; - } - - /* check rendering mode */ - if ( mode != ft_render_mode_mono ) - { - /* raster1 is only capable of producing monochrome bitmaps */ - if ( render->clazz == &ft_raster1_renderer_class ) - return FT_Err_Cannot_Render_Glyph; - } - else - { - /* raster5 is only capable of producing 5-gray-levels bitmaps */ - if ( render->clazz == &ft_raster5_renderer_class ) - return FT_Err_Cannot_Render_Glyph; - } - - outline = &slot->outline; - - /* translate the outline to the new origin if needed */ - if ( origin ) - FT_Outline_Translate( outline, origin->x, origin->y ); - - /* compute the control box, and grid fit it */ - FT_Outline_Get_CBox( outline, &cbox ); - - cbox.xMin &= -64; - cbox.yMin &= -64; - cbox.xMax = ( cbox.xMax + 63 ) & -64; - cbox.yMax = ( cbox.yMax + 63 ) & -64; - - width = ( cbox.xMax - cbox.xMin ) >> 6; - height = ( cbox.yMax - cbox.yMin ) >> 6; - bitmap = &slot->bitmap; - memory = render->root.memory; - - /* release old bitmap buffer */ - if ( slot->flags & ft_glyph_own_bitmap ) - { - FREE( bitmap->buffer ); - slot->flags &= ~ft_glyph_own_bitmap; - } - - /* allocate new one, depends on pixel format */ - if ( !( mode & ft_render_mode_mono ) ) - { - /* we pad to 32 bits, only for backwards compatibility with FT 1.x */ - pitch = ( width + 3 ) & -4; - bitmap->pixel_mode = ft_pixel_mode_grays; - bitmap->num_grays = 256; - } - else - { - pitch = ( width + 7 ) >> 3; - bitmap->pixel_mode = ft_pixel_mode_mono; - } - - bitmap->width = width; - bitmap->rows = height; - bitmap->pitch = pitch; - - if ( ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) ) - goto Exit; - - slot->flags |= ft_glyph_own_bitmap; - - /* translate outline to render it into the bitmap */ - FT_Outline_Translate( outline, -cbox.xMin, -cbox.yMin ); - - /* set up parameters */ - params.target = bitmap; - params.source = outline; - params.flags = 0; - - if ( bitmap->pixel_mode == ft_pixel_mode_grays ) - params.flags |= ft_raster_flag_aa; - - /* render outline into the bitmap */ - error = render->raster_render( render->raster, ¶ms ); - if ( error ) - goto Exit; - - slot->format = ft_glyph_format_bitmap; - slot->bitmap_left = cbox.xMin >> 6; - slot->bitmap_top = cbox.yMax >> 6; - - Exit: - return error; - } - - - FT_CPLUSPLUS( const FT_Renderer_Class ) ft_raster1_renderer_class = - { - { - ft_module_renderer, - sizeof( FT_RendererRec ), - - "raster1", - 0x10000L, - 0x20000L, - - 0, /* module specific interface */ - - (FT_Module_Constructor)ft_raster1_init, - (FT_Module_Destructor) 0, - (FT_Module_Requester) 0 - }, - - ft_glyph_format_outline, - - (FTRenderer_render) ft_raster1_render, - (FTRenderer_transform)ft_raster1_transform, - (FTRenderer_getCBox) ft_raster1_get_cbox, - (FTRenderer_setMode) ft_raster1_set_mode, - - (FT_Raster_Funcs*) &ft_standard_raster - }; - - - /* This renderer is _NOT_ part of the default modules; you will need */ - /* to register it by hand in your application. It should only be */ - /* used for backwards-compatibility with FT 1.x anyway. */ - /* */ - FT_CPLUSPLUS( const FT_Renderer_Class ) ft_raster5_renderer_class = - { - { - ft_module_renderer, - sizeof( FT_RendererRec ), - - "raster5", - 0x10000L, - 0x20000L, - - 0, /* module specific interface */ - - (FT_Module_Constructor)ft_raster1_init, - (FT_Module_Destructor) 0, - (FT_Module_Requester) 0 - }, - - ft_glyph_format_outline, - - (FTRenderer_render) ft_raster1_render, - (FTRenderer_transform)ft_raster1_transform, - (FTRenderer_getCBox) ft_raster1_get_cbox, - (FTRenderer_setMode) ft_raster1_set_mode, - - (FT_Raster_Funcs*) &ft_standard_raster - }; - - -/* END */ diff --git a/src/raster1/ftrend1.h b/src/raster1/ftrend1.h deleted file mode 100644 index 76926ae34..000000000 --- a/src/raster1/ftrend1.h +++ /dev/null @@ -1,48 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftrend1.h */ -/* */ -/* The FreeType glyph rasterizer interface (specification). */ -/* */ -/* Copyright 1996-2000 by */ -/* David Turner, Robert Wilhelm, and Werner Lemberg. */ -/* */ -/* This file is part of the FreeType project, and may only be used, */ -/* modified, and distributed under the terms of the FreeType project */ -/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ -/* this file you indicate that you have read the license and */ -/* understand and accept it fully. */ -/* */ -/***************************************************************************/ - - -#ifndef FTREND1_H -#define FTREND1_H - - -#include - - -#ifdef __cplusplus - extern "C" { -#endif - - - FT_EXPORT_VAR( const FT_Renderer_Class ) ft_raster1_renderer_class; - - /* this renderer is _NOT_ part of the default modules, you'll need */ - /* to register it by hand in your application. It should only be */ - /* used for backwards-compatibility with FT 1.x anyway. */ - /* */ - FT_EXPORT_VAR( const FT_Renderer_Class ) ft_raster5_renderer_class; - - -#ifdef __cplusplus - } -#endif - - -#endif /* FTREND1_H */ - - -/* END */ diff --git a/src/raster1/raster1.c b/src/raster1/raster1.c deleted file mode 100644 index cf2835abc..000000000 --- a/src/raster1/raster1.c +++ /dev/null @@ -1,35 +0,0 @@ -/***************************************************************************/ -/* */ -/* raster1.c */ -/* */ -/* FreeType monochrome rasterer module component (body only). */ -/* */ -/* Copyright 1996-2000 by */ -/* David Turner, Robert Wilhelm, and Werner Lemberg. */ -/* */ -/* This file is part of the FreeType project, and may only be used, */ -/* modified, and distributed under the terms of the FreeType project */ -/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ -/* this file you indicate that you have read the license and */ -/* understand and accept it fully. */ -/* */ -/***************************************************************************/ - - -#define FT_MAKE_OPTION_SINGLE_OBJECT - - -#ifdef FT_FLAT_COMPILE - -#include "ftraster.c" -#include "ftrend1.c" - -#else - -#include -#include - -#endif - - -/* END */ diff --git a/src/type1/module.mk b/src/type1/module.mk index a9f9de411..82d9355ba 100644 --- a/src/type1/module.mk +++ b/src/type1/module.mk @@ -1,5 +1,5 @@ # -# FreeType 2 Type1z module definition +# FreeType 2 Type1 module definition # diff --git a/src/type1/rules.mk b/src/type1/rules.mk index 2d616901c..c00b5941c 100644 --- a/src/type1/rules.mk +++ b/src/type1/rules.mk @@ -1,5 +1,5 @@ # -# FreeType 2 Type1z driver configuration rules +# FreeType 2 Type1 driver configuration rules # @@ -26,20 +26,20 @@ T1_COMPILE := $(FT_COMPILE) # Type1 driver sources (i.e., C files) # -T1_DRV_SRC := $(T1_DIR_)z1parse.c \ - $(T1_DIR_)z1load.c \ - $(T1_DIR_)z1driver.c \ - $(T1_DIR_)z1afm.c \ - $(T1_DIR_)z1gload.c \ - $(T1_DIR_)z1objs.c +T1_DRV_SRC := $(T1_DIR_)t1parse.c \ + $(T1_DIR_)t1load.c \ + $(T1_DIR_)t1driver.c \ + $(T1_DIR_)t1afm.c \ + $(T1_DIR_)t1gload.c \ + $(T1_DIR_)t1objs.c # Type1 driver headers # T1_DRV_H := $(T1_DRV_SRC:%.c=%.h) \ - $(T1_DIR_)z1tokens.h + $(T1_DIR_)t1tokens.h -# Type1z driver object(s) +# Type1 driver object(s) # # T1_DRV_OBJ_M is used during `multi' builds # T1_DRV_OBJ_S is used during `single' builds @@ -47,18 +47,18 @@ T1_DRV_H := $(T1_DRV_SRC:%.c=%.h) \ T1_DRV_OBJ_M := $(T1_DRV_SRC:$(T1_DIR_)%.c=$(OBJ_)%.$O) T1_DRV_OBJ_S := $(OBJ_)type1.$O -# Type1z driver source file for single build +# Type1 driver source file for single build # T1_DRV_SRC_S := $(T1_DIR_)type1.c -# Type1z driver - single object +# Type1 driver - single object # $(T1_DRV_OBJ_S): $(T1_DRV_SRC_S) $(T1_DRV_SRC) $(FREETYPE_H) $(T1_DRV_H) $(T1_COMPILE) $T$@ $(T1_DRV_SRC_S) -# Type1z driver - multiple objects +# Type1 driver - multiple objects # $(OBJ_)%.$O: $(T1_DIR_)%.c $(FREETYPE_H) $(T1_DRV_H) $(T1_COMPILE) $T$@ $< diff --git a/src/type1/z1afm.c b/src/type1/t1afm.c similarity index 91% rename from src/type1/z1afm.c rename to src/type1/t1afm.c index f7d0282f1..6e6e71465 100644 --- a/src/type1/z1afm.c +++ b/src/type1/t1afm.c @@ -1,6 +1,6 @@ /***************************************************************************/ /* */ -/* z1afm.c */ +/* t1afm.c */ /* */ /* AFM support for Type 1 fonts (body). */ /* */ @@ -18,11 +18,11 @@ #ifdef FT_FLAT_COMPILE -#include "z1afm.h" +#include "t1afm.h" #else -#include +#include #endif @@ -42,12 +42,12 @@ /* messages during execution. */ /* */ #undef FT_COMPONENT -#define FT_COMPONENT trace_z1afm +#define FT_COMPONENT trace_t1afm LOCAL_FUNC - void Z1_Done_AFM( FT_Memory memory, - Z1_AFM* afm ) + void T1_Done_AFM( FT_Memory memory, + T1_AFM* afm ) { FREE( afm->kern_pairs ); afm->num_pairs = 0; @@ -153,8 +153,8 @@ int compare_kern_pairs( const void* a, const void* b ) { - Z1_Kern_Pair* pair1 = (Z1_Kern_Pair*)a; - Z1_Kern_Pair* pair2 = (Z1_Kern_Pair*)b; + T1_Kern_Pair* pair1 = (T1_Kern_Pair*)a; + T1_Kern_Pair* pair2 = (T1_Kern_Pair*)b; FT_ULong index1 = KERN_INDEX( pair1->glyph1, pair1->glyph2 ); FT_ULong index2 = KERN_INDEX( pair2->glyph1, pair2->glyph2 ); @@ -166,7 +166,7 @@ /* parse an AFM file -- for now, only read the kerning pairs */ LOCAL_FUNC - FT_Error Z1_Read_AFM( FT_Face t1_face, + FT_Error T1_Read_AFM( FT_Face t1_face, FT_Stream stream ) { FT_Error error; @@ -175,9 +175,9 @@ FT_Byte* limit; FT_Byte* p; FT_Int count = 0; - Z1_Kern_Pair* pair; + T1_Kern_Pair* pair; T1_Font* type1 = &((T1_Face)t1_face)->type1; - Z1_AFM* afm = 0; + T1_AFM* afm = 0; if ( ACCESS_Frame( stream->size ) ) @@ -202,7 +202,7 @@ /* allocate the pairs */ if ( ALLOC( afm, sizeof ( *afm ) ) || - ALLOC_ARRAY( afm->kern_pairs, count, Z1_Kern_Pair ) ) + ALLOC_ARRAY( afm->kern_pairs, count, T1_Kern_Pair ) ) goto Exit; /* now, read each kern pair */ @@ -237,7 +237,7 @@ } /* now, sort the kern pairs according to their glyph indices */ - qsort( afm->kern_pairs, count, sizeof ( Z1_Kern_Pair ), + qsort( afm->kern_pairs, count, sizeof ( T1_Kern_Pair ), compare_kern_pairs ); Exit: @@ -252,12 +252,12 @@ /* find the kerning for a given glyph pair */ LOCAL_FUNC - void Z1_Get_Kerning( Z1_AFM* afm, + void T1_Get_Kerning( T1_AFM* afm, FT_UInt glyph1, FT_UInt glyph2, FT_Vector* kerning ) { - Z1_Kern_Pair *min, *mid, *max; + T1_Kern_Pair *min, *mid, *max; FT_ULong index = KERN_INDEX( glyph1, glyph2 ); diff --git a/src/type1/z1afm.h b/src/type1/t1afm.h similarity index 78% rename from src/type1/z1afm.h rename to src/type1/t1afm.h index 5e25e7efb..1a442f690 100644 --- a/src/type1/z1afm.h +++ b/src/type1/t1afm.h @@ -1,6 +1,6 @@ /***************************************************************************/ /* */ -/* z1afm.h */ +/* t1afm.h */ /* */ /* AFM support for Type 1 fonts (specification). */ /* */ @@ -16,17 +16,17 @@ /***************************************************************************/ -#ifndef Z1AFM_H -#define Z1AFM_H +#ifndef T1AFM_H +#define T1AFM_H #ifdef FT_FLAT_COMPILE -#include "z1objs.h" +#include "t1objs.h" #else -#include +#include #endif @@ -36,33 +36,33 @@ #endif - typedef struct Z1_Kern_Pair_ + typedef struct T1_Kern_Pair_ { FT_UInt glyph1; FT_UInt glyph2; FT_Vector kerning; - } Z1_Kern_Pair; + } T1_Kern_Pair; - typedef struct Z1_AFM_ + typedef struct T1_AFM_ { FT_Int num_pairs; - Z1_Kern_Pair* kern_pairs; + T1_Kern_Pair* kern_pairs; - } Z1_AFM; + } T1_AFM; LOCAL_DEF - FT_Error Z1_Read_AFM( FT_Face face, + FT_Error T1_Read_AFM( FT_Face face, FT_Stream stream ); LOCAL_DEF - void Z1_Done_AFM( FT_Memory memory, - Z1_AFM* afm ); + void T1_Done_AFM( FT_Memory memory, + T1_AFM* afm ); LOCAL_DEF - void Z1_Get_Kerning( Z1_AFM* afm, + void T1_Get_Kerning( T1_AFM* afm, FT_UInt glyph1, FT_UInt glyph2, FT_Vector* kerning ); @@ -73,7 +73,7 @@ #endif -#endif /* Z1AFM_H */ +#endif /* T1AFM_H */ /* END */ diff --git a/src/type1/z1driver.c b/src/type1/t1driver.c similarity index 91% rename from src/type1/z1driver.c rename to src/type1/t1driver.c index c3aacb3f0..68c1f427d 100644 --- a/src/type1/z1driver.c +++ b/src/type1/t1driver.c @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1driver.c */ +/* t1driver.c */ /* */ -/* Experimental Type 1 driver interface (body). */ +/* Type 1 driver interface (body). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -18,17 +18,17 @@ #ifdef FT_FLAT_COMPILE -#include "z1driver.h" -#include "z1gload.h" -#include "z1load.h" -#include "z1afm.h" +#include "t1driver.h" +#include "t1gload.h" +#include "t1load.h" +#include "t1afm.h" #else -#include -#include -#include -#include +#include +#include +#include +#include #endif @@ -47,11 +47,11 @@ /* messages during execution. */ /* */ #undef FT_COMPONENT -#define FT_COMPONENT trace_z1driver +#define FT_COMPONENT trace_t1driver static - FT_Error get_z1_glyph_name( T1_Face face, + FT_Error get_t1_glyph_name( T1_Face face, FT_UInt glyph_index, FT_Pointer buffer, FT_UInt buffer_max ) @@ -112,23 +112,23 @@ FT_UNUSED( interface ); if ( strcmp( (const char*)interface, "glyph_name" ) == 0 ) - return (FT_Module_Interface)get_z1_glyph_name; + return (FT_Module_Interface)get_t1_glyph_name; -#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT +#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT if ( strcmp( (const char*)interface, "get_mm" ) == 0 ) - return (FT_Module_Interface)Z1_Get_Multi_Master; + return (FT_Module_Interface)T1_Get_Multi_Master; if ( strcmp( (const char*)interface, "set_mm_design") == 0 ) - return (FT_Module_Interface)Z1_Set_MM_Design; + return (FT_Module_Interface)T1_Set_MM_Design; if ( strcmp( (const char*)interface, "set_mm_blend") == 0 ) - return (FT_Module_Interface)Z1_Set_MM_Blend; + return (FT_Module_Interface)T1_Set_MM_Blend; #endif return 0; } -#ifndef Z1_CONFIG_OPTION_NO_AFM +#ifndef T1_CONFIG_OPTION_NO_AFM /*************************************************************************/ /* */ @@ -168,15 +168,15 @@ FT_UInt right_glyph, FT_Vector* kerning ) { - Z1_AFM* afm; + T1_AFM* afm; kerning->x = 0; kerning->y = 0; - afm = (Z1_AFM*)face->afm_data; + afm = (T1_AFM*)face->afm_data; if ( afm ) - Z1_Get_Kerning( afm, left_glyph, right_glyph, kerning ); + T1_Get_Kerning( afm, left_glyph, right_glyph, kerning ); return T1_Err_Ok; } @@ -295,17 +295,17 @@ 0, /* format interface */ - (FT_Module_Constructor)Z1_Init_Driver, - (FT_Module_Destructor) Z1_Done_Driver, + (FT_Module_Constructor)T1_Init_Driver, + (FT_Module_Destructor) T1_Done_Driver, (FT_Module_Requester) Get_Interface, }, sizeof( T1_FaceRec ), - sizeof( Z1_SizeRec ), - sizeof( Z1_GlyphSlotRec ), + sizeof( T1_SizeRec ), + sizeof( T1_GlyphSlotRec ), - (FTDriver_initFace) Z1_Init_Face, - (FTDriver_doneFace) Z1_Done_Face, + (FTDriver_initFace) T1_Init_Face, + (FTDriver_doneFace) T1_Done_Face, (FTDriver_initSize) 0, (FTDriver_doneSize) 0, (FTDriver_initGlyphSlot)0, @@ -313,15 +313,15 @@ (FTDriver_setCharSizes) 0, (FTDriver_setPixelSizes)0, - (FTDriver_loadGlyph) Z1_Load_Glyph, + (FTDriver_loadGlyph) T1_Load_Glyph, (FTDriver_getCharIndex) Get_Char_Index, -#ifdef Z1_CONFIG_OPTION_NO_AFM +#ifdef T1_CONFIG_OPTION_NO_AFM (FTDriver_getKerning) 0, (FTDriver_attachFile) 0, #else (FTDriver_getKerning) Get_Kerning, - (FTDriver_attachFile) Z1_Read_AFM, + (FTDriver_attachFile) T1_Read_AFM, #endif (FTDriver_getAdvances) 0 }; @@ -331,7 +331,7 @@ EXPORT_FUNC( const FT_Driver_Class* ) getDriverClass( void ) { - return &t1z_driver_class; + return &t1_driver_class; } #endif /* FT_CONFIG_OPTION_DYNAMIC_DRIVERS */ diff --git a/src/type1/z1driver.h b/src/type1/t1driver.h similarity index 86% rename from src/type1/z1driver.h rename to src/type1/t1driver.h index 4367ca873..8b5fcb672 100644 --- a/src/type1/z1driver.h +++ b/src/type1/t1driver.h @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1driver.h */ +/* t1driver.h */ /* */ -/* High-level experimental Type 1 driver interface (specification). */ +/* High-level Type 1 driver interface (specification). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -16,8 +16,8 @@ /***************************************************************************/ -#ifndef Z1DRIVER_H -#define Z1DRIVER_H +#ifndef T1DRIVER_H +#define T1DRIVER_H #include @@ -33,7 +33,7 @@ #endif -#endif /* Z1DRIVER_H */ +#endif /* T1DRIVER_H */ /* END */ diff --git a/src/type1/z1gload.c b/src/type1/t1gload.c similarity index 94% rename from src/type1/z1gload.c rename to src/type1/t1gload.c index 57e44a0f1..e7ccaaf6d 100644 --- a/src/type1/z1gload.c +++ b/src/type1/t1gload.c @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1gload.c */ +/* t1gload.c */ /* */ -/* Experimental Type 1 Glyph Loader (body). */ +/* Type 1 Glyph Loader (body). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -18,11 +18,11 @@ #ifdef FT_FLAT_COMPILE -#include "z1gload.h" +#include "t1gload.h" #else -#include +#include #endif @@ -43,7 +43,7 @@ /* messages during execution. */ /* */ #undef FT_COMPONENT -#define FT_COMPONENT trace_z1gload +#define FT_COMPONENT trace_t1gload /*************************************************************************/ @@ -64,7 +64,7 @@ LOCAL_FUNC_X - FT_Error Z1_Parse_Glyph( T1_Decoder* decoder, + FT_Error T1_Parse_Glyph( T1_Decoder* decoder, FT_UInt glyph_index ) { T1_Face face = (T1_Face)decoder->builder.face; @@ -82,7 +82,7 @@ LOCAL_FUNC - FT_Error Z1_Compute_Max_Advance( T1_Face face, + FT_Error T1_Compute_Max_Advance( T1_Face face, FT_Int* max_advance ) { FT_Error error; @@ -101,7 +101,7 @@ 0, /* glyph slot */ (FT_Byte**)type1->glyph_names, face->blend, - Z1_Parse_Glyph ); + T1_Parse_Glyph ); if ( error ) return error; @@ -117,7 +117,7 @@ for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ ) { /* now get load the unscaled outline */ - error = Z1_Parse_Glyph( &decoder, glyph_index ); + error = T1_Parse_Glyph( &decoder, glyph_index ); /* ignore the error if one occured - skip to next glyph */ } @@ -144,8 +144,8 @@ LOCAL_FUNC - FT_Error Z1_Load_Glyph( Z1_GlyphSlot glyph, - Z1_Size size, + FT_Error T1_Load_Glyph( T1_GlyphSlot glyph, + T1_Size size, FT_Int glyph_index, FT_Int load_flags ) { @@ -180,7 +180,7 @@ (FT_GlyphSlot)glyph, (FT_Byte**)type1->glyph_names, face->blend, - Z1_Parse_Glyph ); + T1_Parse_Glyph ); if ( error ) goto Exit; @@ -192,7 +192,7 @@ /* now load the unscaled outline */ - error = Z1_Parse_Glyph( &decoder, glyph_index ); + error = T1_Parse_Glyph( &decoder, glyph_index ); if ( error ) goto Exit; diff --git a/src/type1/z1gload.h b/src/type1/t1gload.h similarity index 79% rename from src/type1/z1gload.h rename to src/type1/t1gload.h index da4560aec..e414da1d6 100644 --- a/src/type1/z1gload.h +++ b/src/type1/t1gload.h @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1gload.h */ +/* t1gload.h */ /* */ -/* Experimental Type 1 Glyph Loader (specification). */ +/* Type 1 Glyph Loader (specification). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -16,17 +16,17 @@ /***************************************************************************/ -#ifndef Z1GLOAD_H -#define Z1GLOAD_H +#ifndef T1GLOAD_H +#define T1GLOAD_H #ifdef FT_FLAT_COMPILE -#include "z1objs.h" +#include "t1objs.h" #else -#include +#include #endif @@ -37,12 +37,12 @@ LOCAL_DEF - FT_Error Z1_Compute_Max_Advance( T1_Face face, + FT_Error T1_Compute_Max_Advance( T1_Face face, FT_Int* max_advance ); LOCAL_DEF - FT_Error Z1_Load_Glyph( Z1_GlyphSlot glyph, - Z1_Size size, + FT_Error T1_Load_Glyph( T1_GlyphSlot glyph, + T1_Size size, FT_Int glyph_index, FT_Int load_flags ); @@ -52,7 +52,7 @@ #endif -#endif /* Z1GLOAD_H */ +#endif /* T1GLOAD_H */ /* END */ diff --git a/src/type1/z1load.c b/src/type1/t1load.c similarity index 86% rename from src/type1/z1load.c rename to src/type1/t1load.c index b36711527..eb1ab2aee 100644 --- a/src/type1/z1load.c +++ b/src/type1/t1load.c @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1load.c */ +/* t1load.c */ /* */ -/* Experimental Type 1 font loader (body). */ +/* Type 1 font loader (body). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -71,11 +71,11 @@ #ifdef FT_FLAT_COMPILE -#include "z1load.h" +#include "t1load.h" #else -#include +#include #endif @@ -91,10 +91,10 @@ /* messages during execution. */ /* */ #undef FT_COMPONENT -#define FT_COMPONENT trace_z1load +#define FT_COMPONENT trace_t1load -#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT +#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT /*************************************************************************/ @@ -190,7 +190,7 @@ LOCAL_FUNC - FT_Error Z1_Get_Multi_Master( T1_Face face, + FT_Error T1_Get_Multi_Master( T1_Face face, FT_Multi_Master* master ) { T1_Blend* blend = face->blend; @@ -222,7 +222,7 @@ LOCAL_FUNC - FT_Error Z1_Set_MM_Blend( T1_Face face, + FT_Error T1_Set_MM_Blend( T1_Face face, FT_UInt num_coords, FT_Fixed* coords ) { @@ -268,7 +268,7 @@ LOCAL_FUNC - FT_Error Z1_Set_MM_Design( T1_Face face, + FT_Error T1_Set_MM_Design( T1_Face face, FT_UInt num_coords, FT_Long* coords ) { @@ -330,7 +330,7 @@ final_blends[n] = the_blend; } - error = Z1_Set_MM_Blend( face, num_coords, final_blends ); + error = T1_Set_MM_Blend( face, num_coords, final_blends ); } return error; @@ -338,7 +338,7 @@ LOCAL_FUNC - void Z1_Done_Blend( T1_Face face ) + void T1_Done_Blend( T1_Face face ) { FT_Memory memory = face->root.memory; T1_Blend* blend = face->blend; @@ -391,7 +391,7 @@ static void parse_blend_axis_types( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { T1_Token axis_tokens[ T1_MAX_MM_AXIS ]; FT_Int n, num_axis; @@ -401,7 +401,7 @@ /* take an array of objects */ - Z1_ToTokenArray( &loader->parser, axis_tokens, + T1_ToTokenArray( &loader->parser, axis_tokens, T1_MAX_MM_AXIS, &num_axis ); if ( num_axis <= 0 || num_axis > T1_MAX_MM_AXIS ) { @@ -452,19 +452,19 @@ static void parse_blend_design_positions( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - T1_Token design_tokens[ T1_MAX_MM_DESIGNS ]; - FT_Int num_designs; - FT_Int num_axis; - Z1_Parser* parser = &loader->parser; + T1_Token design_tokens[ T1_MAX_MM_DESIGNS ]; + FT_Int num_designs; + FT_Int num_axis; + T1_ParserRec* parser = &loader->parser; - FT_Error error = 0; - T1_Blend* blend; + FT_Error error = 0; + T1_Blend* blend; /* get the array of design tokens - compute number of designs */ - Z1_ToTokenArray( parser, design_tokens, T1_MAX_MM_DESIGNS, &num_designs ); + T1_ToTokenArray( parser, design_tokens, T1_MAX_MM_DESIGNS, &num_designs ); if ( num_designs <= 0 || num_designs > T1_MAX_MM_DESIGNS ) { FT_ERROR(( "parse_blend_design_positions:" )); @@ -494,7 +494,7 @@ token = design_tokens + n; parser->root.cursor = token->start - 1; parser->root.limit = token->limit + 1; - Z1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &n_axis ); + T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &n_axis ); if ( n == 0 ) { @@ -519,7 +519,7 @@ parser->root.cursor = token2->start; parser->root.limit = token2->limit; - blend->design_pos[n][axis] = Z1_ToFixed( parser, 0 ); + blend->design_pos[n][axis] = T1_ToFixed( parser, 0 ); } } @@ -534,19 +534,19 @@ static void parse_blend_design_map( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - FT_Error error = 0; - Z1_Parser* parser = &loader->parser; - T1_Blend* blend; - T1_Token axis_tokens[ T1_MAX_MM_AXIS ]; - FT_Int n, num_axis; - FT_Byte* old_cursor; - FT_Byte* old_limit; - FT_Memory memory = face->root.memory; + FT_Error error = 0; + T1_ParserRec* parser = &loader->parser; + T1_Blend* blend; + T1_Token axis_tokens[ T1_MAX_MM_AXIS ]; + FT_Int n, num_axis; + FT_Byte* old_cursor; + FT_Byte* old_limit; + FT_Memory memory = face->root.memory; - Z1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &num_axis ); + T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &num_axis ); if ( num_axis <= 0 || num_axis > T1_MAX_MM_AXIS ) { FT_ERROR(( "parse_blend_design_map: incorrect number of axes: %d\n", @@ -600,8 +600,8 @@ for ( p = 0; p < num_points; p++ ) { - map->design_points[p] = Z1_ToInt( parser ); - map->blend_points [p] = Z1_ToFixed( parser, 0 ); + map->design_points[p] = T1_ToInt( parser ); + map->blend_points [p] = T1_ToFixed( parser, 0 ); } } @@ -615,15 +615,15 @@ static void parse_weight_vector( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - FT_Error error = 0; - Z1_Parser* parser = &loader->parser; - T1_Blend* blend = face->blend; - T1_Token master; - FT_UInt n; - FT_Byte* old_cursor; - FT_Byte* old_limit; + FT_Error error = 0; + T1_ParserRec* parser = &loader->parser; + T1_Blend* blend = face->blend; + T1_Token master; + FT_UInt n; + FT_Byte* old_cursor; + FT_Byte* old_limit; if ( !blend || blend->num_designs == 0 ) @@ -633,7 +633,7 @@ goto Exit; } - Z1_ToToken( parser, &master ); + T1_ToToken( parser, &master ); if ( master.type != t1_token_array ) { FT_ERROR(( "parse_weight_vector: incorrect format!\n" )); @@ -650,7 +650,7 @@ for ( n = 0; n < blend->num_designs; n++ ) { blend->default_weight_vector[n] = - blend->weight_vector[n] = Z1_ToFixed( parser, 0 ); + blend->weight_vector[n] = T1_ToFixed( parser, 0 ); } parser->root.cursor = old_cursor; @@ -667,9 +667,9 @@ /* */ static void parse_shared_dict( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - Z1_Parser* parser = &loader->parser; + T1_ParserRec* parser = &loader->parser; FT_UNUSED( face ); @@ -678,7 +678,7 @@ parser->root.error = 0; } -#endif /* Z1_CONFIG_OPTION_NO_MM_SUPPORT */ +#endif /* T1_CONFIG_OPTION_NO_MM_SUPPORT */ /*************************************************************************/ @@ -700,7 +700,7 @@ static FT_Error t1_load_keyword( T1_Face face, - Z1_Loader* loader, + T1_Loader* loader, T1_Field* field ) { FT_Error error; @@ -754,10 +754,10 @@ if ( field->type == t1_field_integer_array || field->type == t1_field_fixed_array ) - error = Z1_Load_Field_Table( &loader->parser, field, + error = T1_Load_Field_Table( &loader->parser, field, objects, max_objects, 0 ); else - error = Z1_Load_Field( &loader->parser, field, + error = T1_Load_Field( &loader->parser, field, objects, max_objects, 0 ); Exit: @@ -781,9 +781,9 @@ static - int read_binary_data( Z1_Parser* parser, - FT_Int* size, - FT_Byte** base ) + int read_binary_data( T1_ParserRec* parser, + FT_Int* size, + FT_Byte** base ) { FT_Byte* cur; FT_Byte* limit = parser->root.limit; @@ -794,15 +794,15 @@ /* `size' [white*] RD white ....... ND */ /* */ - Z1_Skip_Spaces( parser ); + T1_Skip_Spaces( parser ); cur = parser->root.cursor; if ( cur < limit && (FT_Byte)( *cur - '0' ) < 10 ) { - *size = Z1_ToInt( parser ); + *size = T1_ToInt( parser ); - Z1_Skip_Spaces( parser ); - Z1_Skip_Alpha ( parser ); /* `RD' or `-|' or something else */ + T1_Skip_Spaces( parser ); + T1_Skip_Alpha ( parser ); /* `RD' or `-|' or something else */ /* there is only one whitespace char after the */ /* `RD' or `-|' token */ @@ -824,18 +824,18 @@ static void parse_font_name( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - Z1_Parser* parser = &loader->parser; - FT_Error error; - FT_Memory memory = parser->root.memory; - FT_Int len; - FT_Byte* cur; - FT_Byte* cur2; - FT_Byte* limit; + T1_ParserRec* parser = &loader->parser; + FT_Error error; + FT_Memory memory = parser->root.memory; + FT_Int len; + FT_Byte* cur; + FT_Byte* cur2; + FT_Byte* limit; - Z1_Skip_Spaces( parser ); + T1_Skip_Spaces( parser ); cur = parser->root.cursor; limit = parser->root.limit; @@ -866,14 +866,14 @@ static void parse_font_bbox( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - Z1_Parser* parser = &loader->parser; - FT_Short temp[4]; - FT_BBox* bbox = &face->type1.font_bbox; + T1_ParserRec* parser = &loader->parser; + FT_Short temp[4]; + FT_BBox* bbox = &face->type1.font_bbox; - (void)Z1_ToCoordArray( parser, 4, temp ); + (void)T1_ToCoordArray( parser, 4, temp ); bbox->xMin = temp[0]; bbox->yMin = temp[1]; bbox->xMax = temp[2]; @@ -883,19 +883,19 @@ static void parse_font_matrix( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - Z1_Parser* parser = &loader->parser; - FT_Matrix* matrix = &face->type1.font_matrix; - FT_Vector* offset = &face->type1.font_offset; - FT_Fixed temp[6]; + T1_ParserRec* parser = &loader->parser; + FT_Matrix* matrix = &face->type1.font_matrix; + FT_Vector* offset = &face->type1.font_offset; + FT_Fixed temp[6]; if ( matrix->xx || matrix->yx ) /* with synthetic fonts, it's possible we get here twice */ return; - (void)Z1_ToFixedArray( parser, 6, temp, 3 ); + (void)T1_ToFixedArray( parser, 6, temp, 3 ); /* we need to scale the values by 1.0/temp[3] */ if ( temp[3] != 0x10000L ) @@ -921,11 +921,11 @@ static void parse_encoding( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - Z1_Parser* parser = &loader->parser; - FT_Byte* cur = parser->root.cursor; - FT_Byte* limit = parser->root.limit; + T1_ParserRec* parser = &loader->parser; + FT_Byte* cur = parser->root.cursor; + FT_Byte* limit = parser->root.limit; PSAux_Interface* psaux = (PSAux_Interface*)face->psaux; @@ -954,11 +954,11 @@ /* read the number of entries in the encoding, should be 256 */ - count = Z1_ToInt( parser ); + count = T1_ToInt( parser ); if ( parser->root.error ) return; - /* we use a Z1_Table to store our charnames */ + /* we use a T1_Table to store our charnames */ encode->num_chars = count; if ( ALLOC_ARRAY( encode->char_index, count, FT_Short ) || ALLOC_ARRAY( encode->char_name, count, FT_String* ) || @@ -975,7 +975,7 @@ char* notdef = ".notdef"; - Z1_Add_Table( char_table, n, notdef, 8 ); + T1_Add_Table( char_table, n, notdef, 8 ); } /* Now, we will need to read a record of the form */ @@ -1022,7 +1022,7 @@ parser->root.cursor = cur; - charcode = Z1_ToInt( parser ); + charcode = T1_ToInt( parser ); cur = parser->root.cursor; /* skip whitespace */ @@ -1042,7 +1042,7 @@ len = cur2 - cur - 1; - parser->root.error = Z1_Add_Table( char_table, charcode, + parser->root.error = T1_Add_Table( char_table, charcode, cur + 1, len + 1 ); char_table->elements[charcode][len] = '\0'; if ( parser->root.error ) @@ -1081,25 +1081,25 @@ static void parse_subrs( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - Z1_Parser* parser = &loader->parser; - PS_Table* table = &loader->subrs; - FT_Memory memory = parser->root.memory; - FT_Error error; - FT_Int n; + T1_ParserRec* parser = &loader->parser; + PS_Table* table = &loader->subrs; + FT_Memory memory = parser->root.memory; + FT_Error error; + FT_Int n; PSAux_Interface* psaux = (PSAux_Interface*)face->psaux; - loader->num_subrs = Z1_ToInt( parser ); + loader->num_subrs = T1_ToInt( parser ); if ( parser->root.error ) return; /* position the parser right before the `dup' of the first subr */ - Z1_Skip_Spaces( parser ); - Z1_Skip_Alpha( parser ); /* `array' */ - Z1_Skip_Spaces( parser ); + T1_Skip_Spaces( parser ); + T1_Skip_Alpha( parser ); /* `array' */ + T1_Skip_Spaces( parser ); /* initialize subrs array */ error = psaux->ps_table_funcs->init( table, loader->num_subrs, memory ); @@ -1122,7 +1122,7 @@ if ( strncmp( (char*)parser->root.cursor, "dup", 3 ) != 0 ) break; - index = Z1_ToInt( parser ); + index = T1_ToInt( parser ); if ( !read_binary_data( parser, &size, &base ) ) return; @@ -1131,14 +1131,14 @@ /* (bound to `noaccess put') or by two separate tokens: */ /* `noaccess' & `put'. We position the parser right */ /* before the next `dup', if any. */ - Z1_Skip_Spaces( parser ); - Z1_Skip_Alpha( parser ); /* `NP' or `I' or `noaccess' */ - Z1_Skip_Spaces( parser ); + T1_Skip_Spaces( parser ); + T1_Skip_Alpha( parser ); /* `NP' or `I' or `noaccess' */ + T1_Skip_Spaces( parser ); if ( strncmp( (char*)parser->root.cursor, "put", 3 ) == 0 ) { - Z1_Skip_Alpha( parser ); /* skip `put' */ - Z1_Skip_Spaces( parser ); + T1_Skip_Alpha( parser ); /* skip `put' */ + T1_Skip_Spaces( parser ); } /* some fonts use a value of -1 for lenIV to indicate that */ @@ -1148,12 +1148,12 @@ /* */ if ( face->type1.private_dict.lenIV >= 0 ) { - Z1_Decrypt( base, size, 4330 ); + T1_Decrypt( base, size, 4330 ); size -= face->type1.private_dict.lenIV; base += face->type1.private_dict.lenIV; } - error = Z1_Add_Table( table, index, base, size ); + error = T1_Add_Table( table, index, base, size ); if ( error ) goto Fail; } @@ -1166,13 +1166,13 @@ static void parse_charstrings( T1_Face face, - Z1_Loader* loader ) + T1_Loader* loader ) { - Z1_Parser* parser = &loader->parser; - PS_Table* code_table = &loader->charstrings; - PS_Table* name_table = &loader->glyph_names; - FT_Memory memory = parser->root.memory; - FT_Error error; + T1_ParserRec* parser = &loader->parser; + PS_Table* code_table = &loader->charstrings; + PS_Table* name_table = &loader->glyph_names; + FT_Memory memory = parser->root.memory; + FT_Error error; PSAux_Interface* psaux = (PSAux_Interface*)face->psaux; @@ -1187,7 +1187,7 @@ /* with synthetic fonts, it's possible we get here twice */ return; - loader->num_glyphs = Z1_ToInt( parser ); + loader->num_glyphs = T1_ToInt( parser ); if ( parser->root.error ) return; @@ -1216,7 +1216,7 @@ /* */ /* note that we stop when we find a `def' */ /* */ - Z1_Skip_Spaces( parser ); + T1_Skip_Spaces( parser ); cur = parser->root.cursor; if ( cur >= limit ) @@ -1236,7 +1236,7 @@ break; if ( *cur != '/' ) - Z1_Skip_Alpha( parser ); + T1_Skip_Alpha( parser ); else { FT_Byte* cur2 = cur + 1; @@ -1247,7 +1247,7 @@ cur2++; len = cur2 - cur - 1; - error = Z1_Add_Table( name_table, n, cur + 1, len + 1 ); + error = T1_Add_Table( name_table, n, cur + 1, len + 1 ); if ( error ) goto Fail; @@ -1268,12 +1268,12 @@ if ( face->type1.private_dict.lenIV >= 0 ) { - Z1_Decrypt( base, size, 4330 ); + T1_Decrypt( base, size, 4330 ); size -= face->type1.private_dict.lenIV; base += face->type1.private_dict.lenIV; } - error = Z1_Add_Table( code_table, n, base, size ); + error = T1_Add_Table( code_table, n, base, size ); if ( error ) goto Fail; @@ -1296,36 +1296,36 @@ /* index 0. Then take end of table name/code and place it into index */ /* notdef_index. */ - error = Z1_Add_Table( name_table, n, + error = T1_Add_Table( name_table, n, name_table->elements[0], name_table->lengths [0] ); if ( error ) goto Fail; - error = Z1_Add_Table( code_table, n, + error = T1_Add_Table( code_table, n, code_table->elements[0], code_table->lengths [0] ); if ( error ) goto Fail; - error = Z1_Add_Table( name_table, 0, + error = T1_Add_Table( name_table, 0, name_table->elements[notdef_index], name_table->lengths [notdef_index] ); if ( error ) goto Fail; - error = Z1_Add_Table( code_table, 0, + error = T1_Add_Table( code_table, 0, code_table->elements[notdef_index], code_table->lengths [notdef_index] ); if ( error ) goto Fail; - error = Z1_Add_Table( name_table, notdef_index, + error = T1_Add_Table( name_table, notdef_index, name_table->elements[n], name_table->lengths [n] ); if ( error ) goto Fail; - error = Z1_Add_Table( code_table, notdef_index, + error = T1_Add_Table( code_table, notdef_index, code_table->elements[n], code_table->lengths [n] ); if ( error ) @@ -1345,23 +1345,23 @@ char* notdef_name = ".notdef"; - error = Z1_Add_Table( name_table, n, + error = T1_Add_Table( name_table, n, name_table->elements[0], name_table->lengths [0] ); if ( error ) goto Fail; - error = Z1_Add_Table( code_table, n, + error = T1_Add_Table( code_table, n, code_table->elements[0], code_table->lengths [0] ); if ( error ) goto Fail; - error = Z1_Add_Table( name_table, 0, notdef_name, 8 ); + error = T1_Add_Table( name_table, 0, notdef_name, 8 ); if ( error ) goto Fail; - error = Z1_Add_Table( code_table, 0, notdef_glyph, 5 ); + error = T1_Add_Table( code_table, 0, notdef_glyph, 5 ); if ( error ) goto Fail; @@ -1384,11 +1384,11 @@ #ifdef FT_FLAT_COMPILE -#include "z1tokens.h" +#include "t1tokens.h" #else -#include +#include #endif @@ -1400,7 +1400,7 @@ T1_FIELD_CALLBACK( "Subrs", parse_subrs ) T1_FIELD_CALLBACK( "CharStrings", parse_charstrings ) -#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT +#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT T1_FIELD_CALLBACK( "BlendDesignPositions", parse_blend_design_positions ) T1_FIELD_CALLBACK( "BlendDesignMap", parse_blend_design_map ) T1_FIELD_CALLBACK( "BlendAxisTypes", parse_blend_axis_types ) @@ -1414,11 +1414,11 @@ static FT_Error parse_dict( T1_Face face, - Z1_Loader* loader, + T1_Loader* loader, FT_Byte* base, FT_Long size ) { - Z1_Parser* parser = &loader->parser; + T1_ParserRec* parser = &loader->parser; parser->root.cursor = base; @@ -1456,7 +1456,7 @@ /* skip the `known' keyword and the token following it */ cur += 5; loader->parser.root.cursor = cur; - Z1_ToToken( &loader->parser, &token ); + T1_ToToken( &loader->parser, &token ); /* if the last token was an array, skip it! */ if ( token.type == t1_token_array ) @@ -1513,7 +1513,7 @@ { /* we found it -- run the parsing callback! */ parser->root.cursor = cur2; - Z1_Skip_Spaces( parser ); + T1_Skip_Spaces( parser ); parser->root.error = t1_load_keyword( face, loader, keyword ); @@ -1536,7 +1536,7 @@ static - void t1_init_loader( Z1_Loader* loader, + void t1_init_loader( T1_Loader* loader, T1_Face face ) { FT_UNUSED( face ); @@ -1555,29 +1555,29 @@ static - void t1_done_loader( Z1_Loader* loader ) + void t1_done_loader( T1_Loader* loader ) { - Z1_Parser* parser = &loader->parser; + T1_ParserRec* parser = &loader->parser; /* finalize tables */ - Z1_Release_Table( &loader->encoding_table ); - Z1_Release_Table( &loader->charstrings ); - Z1_Release_Table( &loader->glyph_names ); - Z1_Release_Table( &loader->subrs ); + T1_Release_Table( &loader->encoding_table ); + T1_Release_Table( &loader->charstrings ); + T1_Release_Table( &loader->glyph_names ); + T1_Release_Table( &loader->subrs ); /* finalize parser */ - Z1_Done_Parser( parser ); + T1_Done_Parser( parser ); } LOCAL_FUNC - FT_Error Z1_Open_Face( T1_Face face ) + FT_Error T1_Open_Face( T1_Face face ) { - Z1_Loader loader; - Z1_Parser* parser; - T1_Font* type1 = &face->type1; - FT_Error error; + T1_Loader loader; + T1_ParserRec* parser; + T1_Font* type1 = &face->type1; + FT_Error error; PSAux_Interface* psaux = (PSAux_Interface*)face->psaux; @@ -1588,7 +1588,7 @@ type1->private_dict.lenIV = 4; parser = &loader.parser; - error = Z1_New_Parser( parser, + error = T1_New_Parser( parser, face->root.stream, face->root.memory, psaux ); @@ -1599,7 +1599,7 @@ if ( error ) goto Exit; - error = Z1_Get_Private_Dict( parser ); + error = T1_Get_Private_Dict( parser ); if ( error ) goto Exit; @@ -1614,13 +1614,13 @@ if ( !loader.subrs.init ) { - FT_ERROR(( "Z1_Open_Face: no subrs array in face!\n" )); + FT_ERROR(( "T1_Open_Face: no subrs array in face!\n" )); error = T1_Err_Invalid_File_Format; } if ( !loader.charstrings.init ) { - FT_ERROR(( "Z1_Open_Face: no charstrings array in face!\n" )); + FT_ERROR(( "T1_Open_Face: no charstrings array in face!\n" )); error = T1_Err_Invalid_File_Format; } diff --git a/src/type1/z1load.h b/src/type1/t1load.h similarity index 61% rename from src/type1/z1load.h rename to src/type1/t1load.h index 0a20d9311..2ca43aa9b 100644 --- a/src/type1/z1load.h +++ b/src/type1/t1load.h @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1load.h */ +/* t1load.h */ /* */ -/* Experimental Type 1 font loader (specification). */ +/* Type 1 font loader (specification). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -16,8 +16,8 @@ /***************************************************************************/ -#ifndef Z1LOAD_H -#define Z1LOAD_H +#ifndef T1LOAD_H +#define T1LOAD_H #include #include @@ -26,11 +26,11 @@ #ifdef FT_FLAT_COMPILE -#include "z1parse.h" +#include "t1parse.h" #else -#include +#include #endif @@ -39,55 +39,55 @@ extern "C" { #endif - typedef struct Z1_Loader_ + typedef struct T1_Loader_ { - Z1_Parser parser; /* parser used to read the stream */ + T1_ParserRec parser; /* parser used to read the stream */ - FT_Int num_chars; /* number of characters in encoding */ - PS_Table encoding_table; /* PS_Table used to store the */ - /* encoding character names */ + FT_Int num_chars; /* number of characters in encoding */ + PS_Table encoding_table; /* PS_Table used to store the */ + /* encoding character names */ - FT_Int num_glyphs; - PS_Table glyph_names; - PS_Table charstrings; + FT_Int num_glyphs; + PS_Table glyph_names; + PS_Table charstrings; - FT_Int num_subrs; - PS_Table subrs; - FT_Bool fontdata; + FT_Int num_subrs; + PS_Table subrs; + FT_Bool fontdata; - } Z1_Loader; + } T1_Loader; LOCAL_DEF - FT_Error Z1_Open_Face( T1_Face face ); + FT_Error T1_Open_Face( T1_Face face ); -#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT +#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT LOCAL_DEF - FT_Error Z1_Get_Multi_Master( T1_Face face, + FT_Error T1_Get_Multi_Master( T1_Face face, FT_Multi_Master* master ); LOCAL_DEF - FT_Error Z1_Set_MM_Blend( T1_Face face, + FT_Error T1_Set_MM_Blend( T1_Face face, FT_UInt num_coords, FT_Fixed* coords ); LOCAL_DEF - FT_Error Z1_Set_MM_Design( T1_Face face, + FT_Error T1_Set_MM_Design( T1_Face face, FT_UInt num_coords, FT_Long* coords ); LOCAL_DEF - void Z1_Done_Blend( T1_Face face ); + void T1_Done_Blend( T1_Face face ); -#endif /* !Z1_CONFIG_OPTION_NO_MM_SUPPORT */ +#endif /* !T1_CONFIG_OPTION_NO_MM_SUPPORT */ #ifdef __cplusplus } #endif -#endif /* Z1LOAD_H */ +#endif /* T1LOAD_H */ /* END */ diff --git a/src/type1/z1objs.c b/src/type1/t1objs.c similarity index 92% rename from src/type1/z1objs.c rename to src/type1/t1objs.c index 6ec21b3d1..57ee657a1 100644 --- a/src/type1/z1objs.c +++ b/src/type1/t1objs.c @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1objs.c */ +/* t1objs.c */ /* */ -/* Experimental Type 1 objects manager (body). */ +/* Type 1 objects manager (body). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -22,15 +22,15 @@ #ifdef FT_FLAT_COMPILE -#include "z1gload.h" -#include "z1load.h" -#include "z1afm.h" +#include "t1gload.h" +#include "t1load.h" +#include "t1afm.h" #else -#include -#include -#include +#include +#include +#include #endif @@ -46,7 +46,7 @@ /* messages during execution. */ /* */ #undef FT_COMPONENT -#define FT_COMPONENT trace_z1objs +#define FT_COMPONENT trace_t1objs /*************************************************************************/ @@ -59,7 +59,7 @@ /*************************************************************************/ /* */ /* */ - /* Z1_Done_Face */ + /* T1_Done_Face */ /* */ /* */ /* The face object destructor. */ @@ -68,7 +68,7 @@ /* face :: A typeless pointer to the face object to destroy. */ /* */ LOCAL_FUNC - void Z1_Done_Face( T1_Face face ) + void T1_Done_Face( T1_Face face ) { FT_Memory memory; T1_Font* type1 = &face->type1; @@ -78,9 +78,9 @@ { memory = face->root.memory; -#ifndef Z1_CONFIG_OPTION_NO_MM_SUPPORT +#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT /* release multiple masters information */ - Z1_Done_Blend( face ); + T1_Done_Blend( face ); face->blend = 0; #endif @@ -111,10 +111,10 @@ FREE( type1->encoding.char_index ); FREE( type1->font_name ); -#ifndef Z1_CONFIG_OPTION_NO_AFM +#ifndef T1_CONFIG_OPTION_NO_AFM /* release afm data if present */ if ( face->afm_data ) - Z1_Done_AFM( memory, (Z1_AFM*)face->afm_data ); + T1_Done_AFM( memory, (T1_AFM*)face->afm_data ); #endif /* release unicode map, if any */ @@ -130,7 +130,7 @@ /*************************************************************************/ /* */ /* */ - /* Z1_Init_Face */ + /* T1_Init_Face */ /* */ /* */ /* The face object constructor. */ @@ -151,7 +151,7 @@ /* FreeType error code. 0 means success. */ /* */ LOCAL_FUNC - FT_Error Z1_Init_Face( FT_Stream stream, + FT_Error T1_Init_Face( FT_Stream stream, T1_Face face, FT_Int face_index, FT_Int num_params, @@ -188,7 +188,7 @@ } /* open the tokenizer, this will also check the font format */ - error = Z1_Open_Face( face ); + error = T1_Open_Face( face ); if ( error ) goto Exit; @@ -199,7 +199,7 @@ /* check the face index */ if ( face_index != 0 ) { - FT_ERROR(( "Z1_Init_Face: invalid face index\n" )); + FT_ERROR(( "T1_Init_Face: invalid face index\n" )); error = T1_Err_Invalid_Argument; goto Exit; } @@ -278,7 +278,7 @@ FT_Int max_advance; - error = Z1_Compute_Max_Advance( face, &max_advance ); + error = T1_Compute_Max_Advance( face, &max_advance ); /* in case of error, keep the standard width */ if ( !error ) @@ -365,7 +365,7 @@ /*************************************************************************/ /* */ /* */ - /* Z1_Init_Driver */ + /* T1_Init_Driver */ /* */ /* */ /* Initializes a given Type 1 driver object. */ @@ -377,7 +377,7 @@ /* FreeType error code. 0 means success. */ /* */ LOCAL_FUNC - FT_Error Z1_Init_Driver( Z1_Driver driver ) + FT_Error T1_Init_Driver( T1_Driver driver ) { FT_UNUSED( driver ); @@ -388,7 +388,7 @@ /*************************************************************************/ /* */ /* */ - /* Z1_Done_Driver */ + /* T1_Done_Driver */ /* */ /* */ /* Finalizes a given Type 1 driver. */ @@ -397,7 +397,7 @@ /* driver :: A handle to the target Type 1 driver. */ /* */ LOCAL_DEF - void Z1_Done_Driver( Z1_Driver driver ) + void T1_Done_Driver( T1_Driver driver ) { FT_UNUSED( driver ); } diff --git a/src/type1/z1objs.h b/src/type1/t1objs.h similarity index 82% rename from src/type1/z1objs.h rename to src/type1/t1objs.h index c655a6731..f53bb7d8c 100644 --- a/src/type1/z1objs.h +++ b/src/type1/t1objs.h @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1objs.h */ +/* t1objs.h */ /* */ -/* Experimental Type 1 objects manager (specification). */ +/* Type 1 objects manager (specification). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -16,8 +16,8 @@ /***************************************************************************/ -#ifndef Z1OBJS_H -#define Z1OBJS_H +#ifndef T1OBJS_H +#define T1OBJS_H #include #include @@ -29,47 +29,47 @@ #endif /* The following structures must be defined by the hinter */ - typedef struct Z1_Size_Hints_ Z1_Size_Hints; - typedef struct Z1_Glyph_Hints_ Z1_Glyph_Hints; + typedef struct T1_Size_Hints_ T1_Size_Hints; + typedef struct T1_Glyph_Hints_ T1_Glyph_Hints; /*************************************************************************/ /* */ /* */ - /* Z1_Driver */ + /* T1_Driver */ /* */ /* */ /* A handle to a Type 1 driver object. */ /* */ - typedef struct Z1_DriverRec_ *Z1_Driver; + typedef struct T1_DriverRec_ *T1_Driver; /*************************************************************************/ /* */ /* */ - /* Z1_Size */ + /* T1_Size */ /* */ /* */ /* A handle to a Type 1 size object. */ /* */ - typedef struct Z1_SizeRec_* Z1_Size; + typedef struct T1_SizeRec_* T1_Size; /*************************************************************************/ /* */ /* */ - /* Z1_GlyphSlot */ + /* T1_GlyphSlot */ /* */ /* */ /* A handle to a Type 1 glyph slot object. */ /* */ - typedef struct Z1_GlyphSlotRec_* Z1_GlyphSlot; + typedef struct T1_GlyphSlotRec_* T1_GlyphSlot; /*************************************************************************/ /* */ /* */ - /* Z1_CharMap */ + /* T1_CharMap */ /* */ /* */ /* A handle to a Type 1 character mapping object. */ @@ -79,7 +79,7 @@ /* The driver is responsible for making up charmap objects */ /* corresponding to these tables. */ /* */ - typedef struct Z1_CharMapRec_* Z1_CharMap; + typedef struct T1_CharMapRec_* T1_CharMap; /*************************************************************************/ @@ -92,31 +92,31 @@ /*************************************************************************/ /* */ /* */ - /* Z1_SizeRec */ + /* T1_SizeRec */ /* */ /* */ /* Type 1 size record. */ /* */ - typedef struct Z1_SizeRec_ + typedef struct T1_SizeRec_ { FT_SizeRec root; FT_Bool valid; - Z1_Size_Hints* hints; /* defined in the hinter. This allows */ + T1_Size_Hints* hints; /* defined in the hinter. This allows */ /* us to experiment with different */ /* hinting schemes without having to */ - /* change `z1objs' each time. */ - } Z1_SizeRec; + /* change `t1objs' each time. */ + } T1_SizeRec; /*************************************************************************/ /* */ /* */ - /* Z1_GlyphSlotRec */ + /* T1_GlyphSlotRec */ /* */ /* */ /* Type 1 glyph slot record. */ /* */ - typedef struct Z1_GlyphSlotRec_ + typedef struct T1_GlyphSlotRec_ { FT_GlyphSlotRec root; @@ -129,33 +129,33 @@ FT_Fixed x_scale; FT_Fixed y_scale; - Z1_Glyph_Hints* hints; /* defined in the hinter */ + T1_Glyph_Hints* hints; /* defined in the hinter */ - } Z1_GlyphSlotRec; + } T1_GlyphSlotRec; LOCAL_DEF - FT_Error Z1_Init_Face( FT_Stream stream, + FT_Error T1_Init_Face( FT_Stream stream, T1_Face face, FT_Int face_index, FT_Int num_params, FT_Parameter* params ); LOCAL_DEF - void Z1_Done_Face( T1_Face face ); + void T1_Done_Face( T1_Face face ); LOCAL_DEF - FT_Error Z1_Init_Driver( Z1_Driver driver ); + FT_Error T1_Init_Driver( T1_Driver driver ); LOCAL_DEF - void Z1_Done_Driver( Z1_Driver driver ); + void T1_Done_Driver( T1_Driver driver ); #ifdef __cplusplus } #endif -#endif /* Z1OBJS_H */ +#endif /* T1OBJS_H */ /* END */ diff --git a/src/type1/z1parse.c b/src/type1/t1parse.c similarity index 94% rename from src/type1/z1parse.c rename to src/type1/t1parse.c index 64e0f8443..00b29ab03 100644 --- a/src/type1/z1parse.c +++ b/src/type1/t1parse.c @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1parse.c */ +/* t1parse.c */ /* */ -/* Experimental Type 1 parser (body). */ +/* Type 1 parser (body). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -21,14 +21,14 @@ /* The Type 1 parser is in charge of the following: */ /* */ /* - provide an implementation of a growing sequence of objects called */ - /* a `Z1_Table' (used to build various tables needed by the loader). */ + /* a `T1_Table' (used to build various tables needed by the loader). */ /* */ /* - opening .pfb and .pfa files to extract their top-level and private */ /* dictionaries. */ /* */ /* - read numbers, arrays & strings from any dictionary. */ /* */ - /* See `z1load.c' to see how data is loaded from the font file. */ + /* See `t1load.c' to see how data is loaded from the font file. */ /* */ /*************************************************************************/ @@ -42,11 +42,11 @@ #ifdef FT_FLAT_COMPILE -#include "z1parse.h" +#include "t1parse.h" #else -#include +#include #endif @@ -61,7 +61,7 @@ /* messages during execution. */ /* */ #undef FT_COMPONENT -#define FT_COMPONENT trace_z1parse +#define FT_COMPONENT trace_t1parse /*************************************************************************/ @@ -75,10 +75,10 @@ /*************************************************************************/ -#define IS_Z1_WHITESPACE( c ) ( (c) == ' ' || (c) == '\t' ) -#define IS_Z1_LINESPACE( c ) ( (c) == '\r' || (c) == '\n' ) +#define IS_T1_WHITESPACE( c ) ( (c) == ' ' || (c) == '\t' ) +#define IS_T1_LINESPACE( c ) ( (c) == '\r' || (c) == '\n' ) -#define IS_Z1_SPACE( c ) ( IS_Z1_WHITESPACE( c ) || IS_Z1_LINESPACE( c ) ) +#define IS_T1_SPACE( c ) ( IS_T1_WHITESPACE( c ) || IS_T1_LINESPACE( c ) ) typedef struct PFB_Tag_ @@ -127,7 +127,7 @@ LOCAL_FUNC - FT_Error Z1_New_Parser( Z1_Parser* parser, + FT_Error T1_New_Parser( T1_ParserRec* parser, FT_Stream stream, FT_Memory memory, PSAux_Interface* psaux ) @@ -236,7 +236,7 @@ LOCAL_FUNC - void Z1_Done_Parser( Z1_Parser* parser ) + void T1_Done_Parser( T1_ParserRec* parser ) { FT_Memory memory = parser->root.memory; @@ -276,7 +276,7 @@ LOCAL_FUNC - void Z1_Decrypt( FT_Byte* buffer, + void T1_Decrypt( FT_Byte* buffer, FT_Int length, FT_UShort seed ) { @@ -294,7 +294,7 @@ LOCAL_FUNC - FT_Error Z1_Get_Private_Dict( Z1_Parser* parser ) + FT_Error T1_Get_Private_Dict( T1_ParserRec* parser ) { FT_Stream stream = parser->stream; FT_Memory memory = parser->root.memory; @@ -332,7 +332,7 @@ /* and allocate private dictionary buffer */ if ( parser->private_len == 0 ) { - FT_ERROR(( "Z1_Get_Private_Dict:" )); + FT_ERROR(( "T1_Get_Private_Dict:" )); FT_ERROR(( " invalid private dictionary section\n" )); error = T1_Err_Invalid_File_Format; goto Fail; @@ -393,7 +393,7 @@ cur++; if ( cur >= limit ) { - FT_ERROR(( "Z1_Get_Private_Dict:" )); + FT_ERROR(( "T1_Get_Private_Dict:" )); FT_ERROR(( " could not find `eexec' keyword\n" )); error = T1_Err_Invalid_File_Format; goto Exit; @@ -473,7 +473,7 @@ } /* we now decrypt the encoded binary private dictionary */ - Z1_Decrypt( parser->private_dict, parser->private_len, 55665 ); + T1_Decrypt( parser->private_dict, parser->private_len, 55665 ); parser->root.base = parser->private_dict; parser->root.cursor = parser->private_dict; parser->root.limit = parser->root.cursor + parser->private_len; diff --git a/src/type1/z1parse.h b/src/type1/t1parse.h similarity index 79% rename from src/type1/z1parse.h rename to src/type1/t1parse.h index 2615382aa..bc7c348cf 100644 --- a/src/type1/z1parse.h +++ b/src/type1/t1parse.h @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1parse.h */ +/* t1parse.h */ /* */ -/* Experimental Type 1 parser (specification). */ +/* Type 1 parser (specification). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -16,8 +16,8 @@ /***************************************************************************/ -#ifndef Z1PARSE_H -#define Z1PARSE_H +#ifndef T1PARSE_H +#define T1PARSE_H #include #include @@ -30,10 +30,10 @@ /*************************************************************************/ /* */ /* */ - /* Z1_Parser */ + /* T1_ParserRec */ /* */ /* */ - /* A Z1_Parser is an object used to parse a Type 1 fonts very */ + /* A T1_ParserRec is an object used to parse a Type 1 fonts very */ /* quickly. */ /* */ /* */ @@ -57,7 +57,7 @@ /* single_block :: A boolean. Indicates that the private dictionary */ /* is stored in lieu of the base dictionary. */ /* */ - typedef struct Z1_Parser_ + typedef struct T1_ParserRec_ { T1_Parser root; FT_Stream stream; @@ -72,17 +72,17 @@ FT_Byte in_memory; FT_Byte single_block; - } Z1_Parser; + } T1_ParserRec; -#define Z1_Add_Table( p, i, o, l ) (p)->funcs.add( (p), i, o, l ) -#define Z1_Done_Table( p ) \ +#define T1_Add_Table( p, i, o, l ) (p)->funcs.add( (p), i, o, l ) +#define T1_Done_Table( p ) \ do \ { \ if ( (p)->funcs.done ) \ (p)->funcs.done( p ); \ } while ( 0 ) -#define Z1_Release_Table( p ) \ +#define T1_Release_Table( p ) \ do \ { \ if ( (p)->funcs.release ) \ @@ -90,43 +90,43 @@ } while ( 0 ) -#define Z1_Skip_Spaces( p ) (p)->root.funcs.skip_spaces( &(p)->root ) -#define Z1_Skip_Alpha( p ) (p)->root.funcs.skip_alpha ( &(p)->root ) +#define T1_Skip_Spaces( p ) (p)->root.funcs.skip_spaces( &(p)->root ) +#define T1_Skip_Alpha( p ) (p)->root.funcs.skip_alpha ( &(p)->root ) -#define Z1_ToInt( p ) (p)->root.funcs.to_int( &(p)->root ) -#define Z1_ToFixed( p, t ) (p)->root.funcs.to_fixed( &(p)->root, t ) +#define T1_ToInt( p ) (p)->root.funcs.to_int( &(p)->root ) +#define T1_ToFixed( p, t ) (p)->root.funcs.to_fixed( &(p)->root, t ) -#define Z1_ToCoordArray( p, m, c ) \ +#define T1_ToCoordArray( p, m, c ) \ (p)->root.funcs.to_coord_array( &(p)->root, m, c ) -#define Z1_ToFixedArray( p, m, f, t ) \ +#define T1_ToFixedArray( p, m, f, t ) \ (p)->root.funcs.to_fixed_array( &(p)->root, m, f, t ) -#define Z1_ToToken( p, t ) \ +#define T1_ToToken( p, t ) \ (p)->root.funcs.to_token( &(p)->root, t ) -#define Z1_ToTokenArray( p, t, m, c ) \ +#define T1_ToTokenArray( p, t, m, c ) \ (p)->root.funcs.to_token_array( &(p)->root, t, m, c ) -#define Z1_Load_Field( p, f, o, m, pf ) \ +#define T1_Load_Field( p, f, o, m, pf ) \ (p)->root.funcs.load_field( &(p)->root, f, o, m, pf ) -#define Z1_Load_Field_Table( p, f, o, m, pf ) \ +#define T1_Load_Field_Table( p, f, o, m, pf ) \ (p)->root.funcs.load_field_table( &(p)->root, f, o, m, pf ) LOCAL_DEF - FT_Error Z1_New_Parser( Z1_Parser* parser, + FT_Error T1_New_Parser( T1_ParserRec* parser, FT_Stream stream, FT_Memory memory, PSAux_Interface* psaux ); LOCAL_DEF - FT_Error Z1_Get_Private_Dict( Z1_Parser* parser ); + FT_Error T1_Get_Private_Dict( T1_ParserRec* parser ); LOCAL_DEF - void Z1_Decrypt( FT_Byte* buffer, + void T1_Decrypt( FT_Byte* buffer, FT_Int length, FT_UShort seed ); LOCAL_DEF - void Z1_Done_Parser( Z1_Parser* parser ); + void T1_Done_Parser( T1_ParserRec* parser ); #ifdef __cplusplus @@ -134,7 +134,7 @@ #endif -#endif /* Z1PARSE_H */ +#endif /* T1PARSE_H */ /* END */ diff --git a/src/type1/z1tokens.h b/src/type1/t1tokens.h similarity index 95% rename from src/type1/z1tokens.h rename to src/type1/t1tokens.h index b128bde54..6c9dbdf57 100644 --- a/src/type1/z1tokens.h +++ b/src/type1/t1tokens.h @@ -1,8 +1,8 @@ /***************************************************************************/ /* */ -/* z1tokens.h */ +/* t1tokens.h */ /* */ -/* Experimental Type 1 tokenizer (specification). */ +/* Type 1 tokenizer (specification). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ diff --git a/src/type1/type1.c b/src/type1/type1.c index 07d9145e6..d01c1cbde 100644 --- a/src/type1/type1.c +++ b/src/type1/type1.c @@ -2,7 +2,7 @@ /* */ /* type1.c */ /* */ -/* FreeType experimental Type 1 driver component (body only). */ +/* FreeType Type 1 driver component (body only). */ /* */ /* Copyright 1996-2000 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ @@ -21,26 +21,26 @@ #ifdef FT_FLAT_COMPILE -#include "z1parse.c" -#include "z1load.c" -#include "z1objs.c" -#include "z1driver.c" -#include "z1gload.c" +#include "t1parse.c" +#include "t1load.c" +#include "t1objs.c" +#include "t1driver.c" +#include "t1gload.c" -#ifndef Z1_CONFIG_OPTION_NO_AFM -#include "z1afm.c" +#ifndef T1_CONFIG_OPTION_NO_AFM +#include "t1afm.c" #endif #else /* FT_FLAT_COMPILE */ -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -#ifndef Z1_CONFIG_OPTION_NO_AFM -#include +#ifndef T1_CONFIG_OPTION_NO_AFM +#include #endif #endif /* FT_FLAT_COMPILE */