628 lines
34 KiB
C
628 lines
34 KiB
C
/***************************************************************************/
|
|
/* */
|
|
/* ftimage.h */
|
|
/* */
|
|
/* This file defines the glyph image formats recognized by FreeType, as */
|
|
/* well as the default raster interface. */
|
|
/* */
|
|
/* Copyright 1996-1999 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 FTIMAGE_H
|
|
#define FTIMAGE_H
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Type> */
|
|
/* FT_Pos */
|
|
/* */
|
|
/* <Description> */
|
|
/* The type FT_Pos is a 32-bit integer used to store vectorial */
|
|
/* coordinates. Depending on the context, these can represent */
|
|
/* distances in integer font units, or 26.6 fixed float pixel */
|
|
/* coordinates. */
|
|
/* */
|
|
typedef signed long FT_Pos;
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Struct> */
|
|
/* FT_Vector */
|
|
/* */
|
|
/* <Description> */
|
|
/* A simple structure used to store a 2d vector; coordinates are of */
|
|
/* the FT_Pos type. */
|
|
/* */
|
|
/* <Fields> */
|
|
/* x :: The horizontal coordinate. */
|
|
/* y :: The vertical coordinate. */
|
|
/* */
|
|
typedef struct FT_Vector_
|
|
{
|
|
FT_Pos x;
|
|
FT_Pos y;
|
|
|
|
} FT_Vector;
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* <Enum>
|
|
* FT_Pixel_Mode
|
|
*
|
|
* <Description>
|
|
* An enumeration type used to describe the format of pixels
|
|
* in a given bitmap. Note that additional formats may be added
|
|
* in the future.
|
|
*
|
|
* <Fields>
|
|
* ft_pixel_mode_mono :: a monochrome bitmap (1 bit/pixel)
|
|
*
|
|
* ft_pixel_mode_grays :: an 8-bit gray-levels bitmap. Note that
|
|
* the total number of gray levels is given
|
|
* in the `num_grays' field of the FT_Bitmap
|
|
* structure.
|
|
*
|
|
* ft_pixel_mode_pal2 :: a 2-bit paletted bitmap.
|
|
* currently unused by FreeType.
|
|
*
|
|
* ft_pixel_mode_pal4 :: a 4-bit paletted bitmap.
|
|
* currently unused by FreeType.
|
|
*
|
|
* ft_pixel_mode_pal8 :: an 8-bit paletted bitmap.
|
|
* currently unused by FreeType.
|
|
*
|
|
* ft_pixel_mode_rgb15 :: a 15-bit RGB bitmap. Uses 5:5:5 encoding
|
|
* currently unused by FreeType.
|
|
*
|
|
* ft_pixel_mode_rgb16 :: a 16-bit RGB bitmap. Uses 5:6:5 encoding
|
|
* currently unused by FreeType.
|
|
*
|
|
* ft_pixel_mode_rgb24 :: a 24-bit RGB bitmap.
|
|
* currently unused by FreeType.
|
|
*
|
|
* ft_pixel_mode_rgb32 :: a 32-bit RGB bitmap.
|
|
* currently unused by FreeType.
|
|
*
|
|
* <Note>
|
|
* Some anti-aliased bitmaps might be embedded in TrueType fonts
|
|
* using formats pal2 or pal4, though no fonts presenting those
|
|
* have been found to date..
|
|
*
|
|
*************************************************************************/
|
|
|
|
typedef enum FT_Pixel_Mode_
|
|
{
|
|
ft_pixel_mode_none = 0,
|
|
ft_pixel_mode_mono,
|
|
ft_pixel_mode_grays,
|
|
ft_pixel_mode_pal2,
|
|
ft_pixel_mode_pal4,
|
|
ft_pixel_mode_pal8,
|
|
ft_pixel_mode_rgb15,
|
|
ft_pixel_mode_rgb16,
|
|
ft_pixel_mode_rgb24,
|
|
ft_pixel_mode_rgb32,
|
|
|
|
ft_pixel_mode_max /* do not remove */
|
|
|
|
} FT_Pixel_Mode;
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* <Enum>
|
|
* FT_Palette_Mode
|
|
*
|
|
* <Description>
|
|
* An enumeration type used to describe the format of a bitmap
|
|
* palette, used with ft_pixel_mode_pal4 and ft_pixel_mode_pal8
|
|
*
|
|
* <Fields>
|
|
* ft_palette_mode_rgb :: the palette is an array of 3-bytes RGB records
|
|
*
|
|
* ft_palette_mode_rgba :: the palette is an array of 4-bytes RGBA records
|
|
*
|
|
* <Note>
|
|
* As ft_pixel_mode_pal2, pal4 and pal8 are currently unused by
|
|
* FreeType, these types are not handled by the library itself.
|
|
*
|
|
*************************************************************************/
|
|
|
|
typedef enum FT_Palette_Mode_
|
|
{
|
|
ft_palette_mode_rgb = 0,
|
|
ft_palette_mode_rgba,
|
|
|
|
ft_palettte_mode_max /* do not remove */
|
|
|
|
} FT_Palette_Mode;
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* <Struct>
|
|
* FT_Bitmap
|
|
*
|
|
* <Description>
|
|
* A structure used to describe a bitmap or pixmap to the raster.
|
|
* Note that we now manage pixmaps of various depths through the
|
|
* `pixel_mode' field.
|
|
*
|
|
* <Fields>
|
|
* rows :: The number of bitmap rows.
|
|
*
|
|
* width :: The number of pixels in bitmap row.
|
|
*
|
|
* pitch :: The pitch's absolute value is the number of bytes
|
|
* taken by one bitmap row, including padding. However,
|
|
* the pitch is positive when the bitmap has a `down'
|
|
* flow, and negative when it has an `up' flow. In all
|
|
* cases, the pitch is an offset to add to a bitmap
|
|
* pointer in order to go down one row.
|
|
*
|
|
* buffer :: A typeless pointer to the bitmap buffer. This value
|
|
* should be aligned on 32-bit boundaries in most cases.
|
|
*
|
|
* num_grays :: this field is only used with ft_pixel_mode_grays,
|
|
* it gives the number of gray levels used in the
|
|
* bitmap.
|
|
*
|
|
* pixel_mode :: the pixel_mode, i.e. how pixel bits are stored
|
|
*
|
|
* palette_mode :: this field is only used with paletted pixel modes,
|
|
* it indicates how the palette is stored
|
|
*
|
|
* palette :: a typeless pointer to the bitmap palette. only used
|
|
* for paletted pixel modes.
|
|
*
|
|
* <Note>
|
|
* When using pixel modes pal2, pal4 and pal8 with a void `palette'
|
|
* field, a gray pixmap with respectively 4, 16 and 256 levels of gray
|
|
* is assumed. This, in order to be compatible with some embedded bitmap
|
|
* formats defined in the TrueType spec.
|
|
*
|
|
* Note that no font was found presenting such embedded bitmaps, so this
|
|
* is currently completely unhandled by the library.
|
|
*
|
|
*
|
|
*************************************************************************/
|
|
|
|
typedef struct FT_Bitmap_
|
|
{
|
|
int rows;
|
|
int width;
|
|
int pitch;
|
|
void* buffer;
|
|
short num_grays;
|
|
char pixel_mode;
|
|
char palette_mode;
|
|
void* palette;
|
|
|
|
} FT_Bitmap;
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Struct> */
|
|
/* FT_Outline */
|
|
/* */
|
|
/* <Description> */
|
|
/* This structure is used to describe an outline to the scan-line */
|
|
/* converter. It's a copy of the TT_Outline type that was defined */
|
|
/* in FreeType 1.x. */
|
|
/* */
|
|
/* <Fields> */
|
|
/* n_contours :: The number of contours in the outline. */
|
|
/* */
|
|
/* n_points :: The number of points in the outline. */
|
|
/* */
|
|
/* points :: A pointer to an array of `n_points' FT_Vector */
|
|
/* elements, giving the outline's point */
|
|
/* coordinates. */
|
|
/* */
|
|
/* flags :: A pointer to an array of `n_points' chars, */
|
|
/* giving each outline point's type. If bit 0 is */
|
|
/* set, the point is `off' the curve, i.e., a */
|
|
/* Bezier control point, while it is `on' when */
|
|
/* unset. */
|
|
/* */
|
|
/* Bit 1 is meaningful for `off' points only. If */
|
|
/* set, it indicates a third-order Bezier arc */
|
|
/* control point; and a second-order control point */
|
|
/* if unset. */
|
|
/* */
|
|
/* contours :: An array of `n_contours' shorts, giving the end */
|
|
/* point of each contour within the outline. For */
|
|
/* example, the first contour is defined by the */
|
|
/* points `0' to `contours[0]', the second one is */
|
|
/* defined by the points `contours[0]+1' to */
|
|
/* `contours[1]', etc. */
|
|
/* */
|
|
/* owner :: This flag is a boolean which is set whenever the */
|
|
/* outline structure/object owns the arrays it */
|
|
/* refers to in the fields `points', `flags', and */
|
|
/* `contours'. */
|
|
/* */
|
|
/* high_precision :: This flag is set automatically by the FreeType */
|
|
/* library. It indicates that the scan-line */
|
|
/* converter should use a higher precision when */
|
|
/* rendering the outline. This is useful at small */
|
|
/* pixel sizes to get adequate results, though at */
|
|
/* the price of slower rendering. Don't try to */
|
|
/* render large outlines with this flag set. Note */
|
|
/* that it may be ignored in later implementations. */
|
|
/* */
|
|
/* second_pass :: A boolean which is set when the scan-line */
|
|
/* converter should perform a second pass to */
|
|
/* eliminate vertical drop-outs (only vertical */
|
|
/* drop-outs are checked on the first pass). This */
|
|
/* field may be ignored by later implementations. */
|
|
/* */
|
|
/* dropout_mode :: Specifies the drop-out control mode to use while */
|
|
/* rendering an outline. Valid values are 0 (no */
|
|
/* drop out check), 1, 2, 4, and 5. See the */
|
|
/* TrueType specification for more details. A */
|
|
/* value of 2 is usually an excellent generic */
|
|
/* choice. This field may be ignored by some */
|
|
/* raster implementations. */
|
|
/* */
|
|
/* */
|
|
typedef struct FT_Outline_
|
|
{
|
|
short n_contours; /* number of contours in glyph */
|
|
short n_points; /* number of points in the glyph */
|
|
|
|
FT_Vector* points; /* the outline's points */
|
|
char* flags; /* the points flags */
|
|
short* contours; /* the contour end points */
|
|
|
|
char owner; /* the outline owns the coordinates, */
|
|
/* flags, and contours array it uses */
|
|
|
|
char high_precision; /* high precision rendering */
|
|
char second_pass; /* two sweeps rendering */
|
|
char dropout_mode; /* dropout mode */
|
|
|
|
} FT_Outline;
|
|
|
|
|
|
#define FT_CURVE_TAG( flag ) (flag & 3)
|
|
|
|
#define FT_Curve_Tag_On 1
|
|
#define FT_Curve_Tag_Conic 0
|
|
#define FT_Curve_Tag_Cubic 2
|
|
|
|
#define FT_Curve_Tag_Touch_X 8 /* reserved for the TrueType hinter */
|
|
#define FT_Curve_Tag_Touch_Y 16 /* reserved for the TrueType hinter */
|
|
|
|
#define FT_Curve_Tag_Touch_Both ( FT_Curve_Tag_Touch_X | \
|
|
FT_Curve_Tag_Touch_Y)
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <FuncType> */
|
|
/* FT_Outline_MoveTo_Func */
|
|
/* */
|
|
/* <Description> */
|
|
/* A function pointer type used to describe the signature of a `move */
|
|
/* to' function during outline walking/decomposition. */
|
|
/* */
|
|
/* A `move to' is emitted to start a new contour in an outline. */
|
|
/* */
|
|
/* <Input> */
|
|
/* to :: A pointer to the target point of the `move to'. */
|
|
/* user :: A typeless pointer which is passed from the caller of the */
|
|
/* decomposition function. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Error code. 0 means success. */
|
|
/* */
|
|
typedef int (*FT_Outline_MoveTo_Func)( FT_Vector* to,
|
|
void* user );
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <FuncType> */
|
|
/* FT_Outline_LineTo_Func */
|
|
/* */
|
|
/* <Description> */
|
|
/* A function pointer type used to describe the signature of a `line */
|
|
/* to' function during outline walking/decomposition. */
|
|
/* */
|
|
/* A `line to' is emitted to indicate a segment in the outline. */
|
|
/* */
|
|
/* <Input> */
|
|
/* to :: A pointer to the target point of the `line to'. */
|
|
/* user :: A typeless pointer which is passed from the caller of the */
|
|
/* decomposition function. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Error code. 0 means success. */
|
|
/* */
|
|
typedef int (*FT_Outline_LineTo_Func)( FT_Vector* to,
|
|
void* user );
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <FuncType> */
|
|
/* FT_Outline_ConicTo_Func */
|
|
/* */
|
|
/* <Description> */
|
|
/* A function pointer type use to describe the signature of a `conic */
|
|
/* to' function during outline walking/decomposition. */
|
|
/* */
|
|
/* A `conic to' is emitted to indicate a second-order Bezier arc in */
|
|
/* the outline. */
|
|
/* */
|
|
/* <Input> */
|
|
/* control :: An intermediate control point between the last position */
|
|
/* and the new target in `to'. */
|
|
/* */
|
|
/* to :: A pointer to the target end point of the conic arc. */
|
|
/* */
|
|
/* user :: A typeless pointer which is passed from the caller of */
|
|
/* the decomposition function. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Error code. 0 means success. */
|
|
/* */
|
|
typedef int (*FT_Outline_ConicTo_Func)( FT_Vector* control,
|
|
FT_Vector* to,
|
|
void* user );
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <FuncType> */
|
|
/* FT_Outline_CubicTo_Func */
|
|
/* */
|
|
/* <Description> */
|
|
/* A function pointer type used to describe the signature of a `cubic */
|
|
/* to' function during outline walking/decomposition. */
|
|
/* */
|
|
/* A `cubic to' is emitted to indicate a third-order Bezier arc. */
|
|
/* */
|
|
/* <Input> */
|
|
/* control1 :: A pointer to the first Bezier control point. */
|
|
/* control2 :: A pointer to the second Bezier control point. */
|
|
/* to :: A pointer to the target end point. */
|
|
/* user :: A typeless pointer which is passed from the caller of */
|
|
/* the decomposition function. */
|
|
/* */
|
|
/* <Return> */
|
|
/* Error code. 0 means success. */
|
|
/* */
|
|
typedef int (*FT_Outline_CubicTo_Func)( FT_Vector* control1,
|
|
FT_Vector* control2,
|
|
FT_Vector* to,
|
|
void* user );
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Struct> */
|
|
/* FT_Outline_Funcs */
|
|
/* */
|
|
/* <Description> */
|
|
/* A structure to hold various function pointers used during outline */
|
|
/* decomposition in order to emit segments, conic, and cubic Beziers, */
|
|
/* as well as `move to' and `close to' operations. */
|
|
/* */
|
|
/* <Fields> */
|
|
/* move_to :: The `move to' emitter. */
|
|
/* line_to :: The segment emitter. */
|
|
/* conic_to :: The second-order Bezier arc emitter. */
|
|
/* cubic_to :: The third-order Bezier arc emitter. */
|
|
/* */
|
|
typedef struct FT_Outline_Funcs_
|
|
{
|
|
FT_Outline_MoveTo_Func move_to;
|
|
FT_Outline_LineTo_Func line_to;
|
|
FT_Outline_ConicTo_Func conic_to;
|
|
FT_Outline_CubicTo_Func cubic_to;
|
|
|
|
} FT_Outline_Funcs;
|
|
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Macro> */
|
|
/* FT_IMAGE_TAG */
|
|
/* */
|
|
/* <Description> */
|
|
/* This macro converts four letter tags which are used to label */
|
|
/* TrueType tables into an unsigned long to be used within FreeType. */
|
|
/* */
|
|
#define FT_IMAGE_TAG( _x1, _x2, _x3, _x4 ) \
|
|
(((unsigned long)_x1 << 24) | \
|
|
((unsigned long)_x2 << 16) | \
|
|
((unsigned long)_x3 << 8) | \
|
|
(unsigned long)_x4)
|
|
|
|
|
|
/***********************************************************************
|
|
*
|
|
* <Enum>
|
|
* FT_Glyph_Tag
|
|
*
|
|
* <Description>
|
|
* An enumeration type used to describethe format of a given glyph
|
|
* image. Note that this version of FreeType only supports two image
|
|
* formats, even though future font drivers will be able to register
|
|
* their own format.
|
|
*
|
|
* <Fields>
|
|
* ft_glyph_format_bitmap :: the glyph image is a bitmap, and can
|
|
* be described as a FT_Bitmap
|
|
*
|
|
* ft_glyph_format_outline :: the glyph image is a vectorial image
|
|
* made of bezier control points, and can
|
|
* be described as a FT_Outline
|
|
*
|
|
***********************************************************************/
|
|
|
|
typedef enum FT_Glyph_Tag_
|
|
{
|
|
ft_glyph_format_none = 0,
|
|
ft_glyph_format_composite = FT_IMAGE_TAG('c','o','m','p'),
|
|
ft_glyph_format_bitmap = FT_IMAGE_TAG('b','i','t','s'),
|
|
ft_glyph_format_outline = FT_IMAGE_TAG('o','u','t','l')
|
|
|
|
} FT_Glyph_Tag;
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <Type> */
|
|
/* FT_Raster */
|
|
/* */
|
|
/* <Description> */
|
|
/* A handle (pointer) to a raster object. Each object can be used */
|
|
/* independently to convert an outline into a bitmap or pixmap. */
|
|
/* */
|
|
typedef struct FT_RasterRec_* FT_Raster;
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <FuncType> */
|
|
/* FT_Raster_Init_Proc */
|
|
/* */
|
|
/* <Description> */
|
|
/* Initializes a fresh raster object which should have been allocated */
|
|
/* by client applications. This function is also used to set the */
|
|
/* object's render pool. It can be used repeatedly on a single */
|
|
/* object if one wants to change the pool's address or size. */
|
|
/* */
|
|
/* Note that the render pool has no state and is only used during a */
|
|
/* call to FT_Raster_Render(). It is thus theorically possible to */
|
|
/* share it between several non-concurrent components of your */
|
|
/* applications when memory is a scarce resource. */
|
|
/* */
|
|
/* <Input> */
|
|
/* raster :: a handle to the target raster object. */
|
|
/* pool_base :: the render pool's base address in memory */
|
|
/* pool_size :: the render pool's size in bytes. this must be at */
|
|
/* least 4 kByte. */
|
|
/* <Return> */
|
|
/* An error condition, used as a FT_Error in the FreeType library. */
|
|
/* 0 means success. */
|
|
/* */
|
|
typedef int (*FT_Raster_Init_Proc)( FT_Raster raster,
|
|
const char* pool_base,
|
|
long pool_size );
|
|
|
|
|
|
/*************************************************************************/
|
|
/* */
|
|
/* <FuncType> */
|
|
/* FT_Raster_Set_Mode_Proc */
|
|
/* */
|
|
/* <Description> */
|
|
/* Some raster implementations may have several modes of operation. */
|
|
/* This function is used to select one of them, as well as pass some */
|
|
/* arguments. */
|
|
/* */
|
|
/* <Input> */
|
|
/* raster :: The target raster object. */
|
|
/* */
|
|
/* mode :: A pointer used to describe the mode to set. This is */
|
|
/* completely raster-specific, and could be, for example, */
|
|
/* a text string. */
|
|
/* */
|
|
/* args :: An argument to the set_mode command. This is completely */
|
|
/* specific to the raster and the mode used. */
|
|
/* */
|
|
/* <Return> */
|
|
/* An error code, used as a FT_Error by the FreeType library. */
|
|
/* 0 means success. */
|
|
/* */
|
|
typedef int (*FT_Raster_Set_Mode_Proc)( FT_Raster raster,
|
|
const char* mode,
|
|
const char* args );
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* <FuncType>
|
|
* FT_Raster_Render_Proc
|
|
*
|
|
* <Description>
|
|
* Renders an outline into a target bitmap/pixmap.
|
|
*
|
|
* <Input>
|
|
* raster :: A handle to a raster object used during rendering.
|
|
*
|
|
* source_image :: a typeless pointer to the source glyph image.
|
|
* (usually a FT_Outline*).
|
|
*
|
|
* target_bitmap :: descriptor to the target bitmap.
|
|
*
|
|
* <Return>
|
|
* Error code, interpreted as a FT_Error by FreeType library.
|
|
* 0 means success.
|
|
*
|
|
*************************************************************************/
|
|
|
|
typedef int (*FT_Raster_Render_Proc)( FT_Raster raster,
|
|
void* source_image,
|
|
FT_Bitmap* target_bitmap );
|
|
|
|
|
|
/**************************************************************************
|
|
*
|
|
* <Struct>
|
|
* FT_Raster_Interface
|
|
*
|
|
* <Description>
|
|
* A structure used to model the default raster interface. A raster
|
|
* is a module in charge of converting a glyph image into a bitmap.
|
|
*
|
|
* <Fields>
|
|
* size :: the size in bytes of the given raster object. This
|
|
* is used to allocate a new raster when calling
|
|
* `FT_Set_Raster'.
|
|
*
|
|
* format :: the source glyph image format this raster is able to
|
|
* handle.
|
|
*
|
|
* init :: the raster's initialisation routine
|
|
*
|
|
* set_mode :: the raster's mode set routine
|
|
*
|
|
* render :: the raster's rendering routine
|
|
*
|
|
**************************************************************************/
|
|
|
|
typedef struct FT_Raster_Interface_
|
|
{
|
|
long size;
|
|
FT_Glyph_Tag format_tag;
|
|
FT_Raster_Init_Proc init;
|
|
FT_Raster_Set_Mode_Proc set_mode;
|
|
FT_Raster_Render_Proc render;
|
|
|
|
|
|
} FT_Raster_Interface;
|
|
|
|
|
|
#endif /* FTIMAGE_H */
|
|
|
|
|