| 0,0 → 1,1313 |
|---|
| /***************************************************************************/ |
| /* */ |
| /* ftimage.h */ |
| /* */ |
| /* FreeType glyph image formats and default raster interface */ |
| /* (specification). */ |
| /* */ |
| /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */ |
| /* 2010 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. */ |
| /* */ |
| /***************************************************************************/ |
| |
| /*************************************************************************/ |
| /* */ |
| /* Note: A `raster' is simply a scan-line converter, used to render */ |
| /* FT_Outlines into FT_Bitmaps. */ |
| /* */ |
| /*************************************************************************/ |
| |
| |
| #ifndef __FTIMAGE_H__ |
| #define __FTIMAGE_H__ |
| |
| |
| /* _STANDALONE_ is from ftgrays.c */ |
| #ifndef _STANDALONE_ |
| #include <ft2build.h> |
| #endif |
| |
| |
| FT_BEGIN_HEADER |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Section> */ |
| /* basic_types */ |
| /* */ |
| /*************************************************************************/ |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Type> */ |
| /* FT_Pos */ |
| /* */ |
| /* <Description> */ |
| /* The type FT_Pos is used to store vectorial coordinates. Depending */ |
| /* on the context, these can represent distances in integer font */ |
| /* units, or 16.16, 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; |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Struct> */ |
| /* FT_BBox */ |
| /* */ |
| /* <Description> */ |
| /* A structure used to hold an outline's bounding box, i.e., the */ |
| /* coordinates of its extrema in the horizontal and vertical */ |
| /* directions. */ |
| /* */ |
| /* <Fields> */ |
| /* xMin :: The horizontal minimum (left-most). */ |
| /* */ |
| /* yMin :: The vertical minimum (bottom-most). */ |
| /* */ |
| /* xMax :: The horizontal maximum (right-most). */ |
| /* */ |
| /* yMax :: The vertical maximum (top-most). */ |
| /* */ |
| /* <Note> */ |
| /* The bounding box is specified with the coordinates of the lower */ |
| /* left and the upper right corner. In PostScript, those values are */ |
| /* often called (llx,lly) and (urx,ury), respectively. */ |
| /* */ |
| /* If `yMin' is negative, this value gives the glyph's descender. */ |
| /* Otherwise, the glyph doesn't descend below the baseline. */ |
| /* Similarly, if `ymax' is positive, this value gives the glyph's */ |
| /* ascender. */ |
| /* */ |
| /* `xMin' gives the horizontal distance from the glyph's origin to */ |
| /* the left edge of the glyph's bounding box. If `xMin' is negative, */ |
| /* the glyph extends to the left of the origin. */ |
| /* */ |
| typedef struct FT_BBox_ |
| { |
| FT_Pos xMin, yMin; |
| FT_Pos xMax, yMax; |
| |
| } FT_BBox; |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <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. */ |
| /* */ |
| /* <Values> */ |
| /* FT_PIXEL_MODE_NONE :: */ |
| /* Value~0 is reserved. */ |
| /* */ |
| /* FT_PIXEL_MODE_MONO :: */ |
| /* A monochrome bitmap, using 1~bit per pixel. Note that pixels */ |
| /* are stored in most-significant order (MSB), which means that */ |
| /* the left-most pixel in a byte has value 128. */ |
| /* */ |
| /* FT_PIXEL_MODE_GRAY :: */ |
| /* An 8-bit bitmap, generally used to represent anti-aliased glyph */ |
| /* images. Each pixel is stored in one byte. Note that the number */ |
| /* of `gray' levels is stored in the `num_grays' field of the */ |
| /* @FT_Bitmap structure (it generally is 256). */ |
| /* */ |
| /* FT_PIXEL_MODE_GRAY2 :: */ |
| /* A 2-bit per pixel bitmap, used to represent embedded */ |
| /* anti-aliased bitmaps in font files according to the OpenType */ |
| /* specification. We haven't found a single font using this */ |
| /* format, however. */ |
| /* */ |
| /* FT_PIXEL_MODE_GRAY4 :: */ |
| /* A 4-bit per pixel bitmap, representing embedded anti-aliased */ |
| /* bitmaps in font files according to the OpenType specification. */ |
| /* We haven't found a single font using this format, however. */ |
| /* */ |
| /* FT_PIXEL_MODE_LCD :: */ |
| /* An 8-bit bitmap, representing RGB or BGR decimated glyph images */ |
| /* used for display on LCD displays; the bitmap is three times */ |
| /* wider than the original glyph image. See also */ |
| /* @FT_RENDER_MODE_LCD. */ |
| /* */ |
| /* FT_PIXEL_MODE_LCD_V :: */ |
| /* An 8-bit bitmap, representing RGB or BGR decimated glyph images */ |
| /* used for display on rotated LCD displays; the bitmap is three */ |
| /* times taller than the original glyph image. See also */ |
| /* @FT_RENDER_MODE_LCD_V. */ |
| /* */ |
| typedef enum FT_Pixel_Mode_ |
| { |
| FT_PIXEL_MODE_NONE = 0, |
| FT_PIXEL_MODE_MONO, |
| FT_PIXEL_MODE_GRAY, |
| FT_PIXEL_MODE_GRAY2, |
| FT_PIXEL_MODE_GRAY4, |
| FT_PIXEL_MODE_LCD, |
| FT_PIXEL_MODE_LCD_V, |
| |
| FT_PIXEL_MODE_MAX /* do not remove */ |
| |
| } FT_Pixel_Mode; |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Enum> */ |
| /* ft_pixel_mode_xxx */ |
| /* */ |
| /* <Description> */ |
| /* A list of deprecated constants. Use the corresponding */ |
| /* @FT_Pixel_Mode values instead. */ |
| /* */ |
| /* <Values> */ |
| /* ft_pixel_mode_none :: See @FT_PIXEL_MODE_NONE. */ |
| /* ft_pixel_mode_mono :: See @FT_PIXEL_MODE_MONO. */ |
| /* ft_pixel_mode_grays :: See @FT_PIXEL_MODE_GRAY. */ |
| /* ft_pixel_mode_pal2 :: See @FT_PIXEL_MODE_GRAY2. */ |
| /* ft_pixel_mode_pal4 :: See @FT_PIXEL_MODE_GRAY4. */ |
| /* */ |
| #define ft_pixel_mode_none FT_PIXEL_MODE_NONE |
| #define ft_pixel_mode_mono FT_PIXEL_MODE_MONO |
| #define ft_pixel_mode_grays FT_PIXEL_MODE_GRAY |
| #define ft_pixel_mode_pal2 FT_PIXEL_MODE_GRAY2 |
| #define ft_pixel_mode_pal4 FT_PIXEL_MODE_GRAY4 |
| |
| /* */ |
| |
| #if 0 |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Enum> */ |
| /* FT_Palette_Mode */ |
| /* */ |
| /* <Description> */ |
| /* THIS TYPE IS DEPRECATED. DO NOT USE IT! */ |
| /* */ |
| /* An enumeration type to describe the format of a bitmap palette, */ |
| /* used with ft_pixel_mode_pal4 and ft_pixel_mode_pal8. */ |
| /* */ |
| /* <Values> */ |
| /* ft_palette_mode_rgb :: The palette is an array of 3-byte RGB */ |
| /* records. */ |
| /* */ |
| /* ft_palette_mode_rgba :: The palette is an array of 4-byte 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_palette_mode_max /* do not remove */ |
| |
| } FT_Palette_Mode; |
| |
| /* */ |
| |
| #endif |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <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. */ |
| /* */ |
| /* Note that `padding' means the alignment of a */ |
| /* bitmap to a byte border, and FreeType functions */ |
| /* normally align to the smallest possible integer */ |
| /* value. */ |
| /* */ |
| /* For the B/W rasterizer, `pitch' is always an even */ |
| /* number. */ |
| /* */ |
| /* To change the pitch of a bitmap (say, to make it a */ |
| /* multiple of 4), use @FT_Bitmap_Convert. */ |
| /* Alternatively, you might use callback functions to */ |
| /* directly render to the application's surface; see */ |
| /* the file `example2.cpp' in the tutorial for a */ |
| /* demonstration. */ |
| /* */ |
| /* 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_GRAY; it gives the number of gray */ |
| /* levels used in the bitmap. */ |
| /* */ |
| /* pixel_mode :: The pixel mode, i.e., how pixel bits are stored. */ |
| /* See @FT_Pixel_Mode for possible values. */ |
| /* */ |
| /* palette_mode :: This field is intended for paletted pixel modes; */ |
| /* it indicates how the palette is stored. Not */ |
| /* used currently. */ |
| /* */ |
| /* palette :: A typeless pointer to the bitmap palette; this */ |
| /* field is intended for paletted pixel modes. Not */ |
| /* used currently. */ |
| /* */ |
| /* <Note> */ |
| /* For now, the only pixel modes supported by FreeType are mono and */ |
| /* grays. However, drivers might be added in the future to support */ |
| /* more `colorful' options. */ |
| /* */ |
| typedef struct FT_Bitmap_ |
| { |
| int rows; |
| int width; |
| int pitch; |
| unsigned char* buffer; |
| short num_grays; |
| char pixel_mode; |
| char palette_mode; |
| void* palette; |
| |
| } FT_Bitmap; |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Section> */ |
| /* outline_processing */ |
| /* */ |
| /*************************************************************************/ |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Struct> */ |
| /* FT_Outline */ |
| /* */ |
| /* <Description> */ |
| /* This structure is used to describe an outline to the scan-line */ |
| /* converter. */ |
| /* */ |
| /* <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. */ |
| /* */ |
| /* tags :: A pointer to an array of `n_points' chars, giving */ |
| /* each outline point's type. */ |
| /* */ |
| /* If bit~0 is unset, the point is `off' the curve, */ |
| /* i.e., a Bézier control point, while it is `on' if */ |
| /* set. */ |
| /* */ |
| /* Bit~1 is meaningful for `off' points only. If set, */ |
| /* it indicates a third-order Bézier arc control point; */ |
| /* and a second-order control point if unset. */ |
| /* */ |
| /* If bit~2 is set, bits 5-7 contain the drop-out mode */ |
| /* (as defined in the OpenType specification; the value */ |
| /* is the same as the argument to the SCANMODE */ |
| /* instruction). */ |
| /* */ |
| /* Bits 3 and~4 are reserved for internal purposes. */ |
| /* */ |
| /* 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. */ |
| /* */ |
| /* flags :: A set of bit flags used to characterize the outline */ |
| /* and give hints to the scan-converter and hinter on */ |
| /* how to convert/grid-fit it. See @FT_OUTLINE_FLAGS. */ |
| /* */ |
| /* <Note> */ |
| /* The B/W rasterizer only checks bit~2 in the `tags' array for the */ |
| /* first point of each contour. The drop-out mode as given with */ |
| /* @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, and */ |
| /* @FT_OUTLINE_INCLUDE_STUBS in `flags' is then overridden. */ |
| /* */ |
| 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* tags; /* the points flags */ |
| short* contours; /* the contour end points */ |
| |
| int flags; /* outline masks */ |
| |
| } FT_Outline; |
| |
| /* Following limits must be consistent with */ |
| /* FT_Outline.{n_contours,n_points} */ |
| #define FT_OUTLINE_CONTOURS_MAX SHRT_MAX |
| #define FT_OUTLINE_POINTS_MAX SHRT_MAX |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Enum> */ |
| /* FT_OUTLINE_FLAGS */ |
| /* */ |
| /* <Description> */ |
| /* A list of bit-field constants use for the flags in an outline's */ |
| /* `flags' field. */ |
| /* */ |
| /* <Values> */ |
| /* FT_OUTLINE_NONE :: */ |
| /* Value~0 is reserved. */ |
| /* */ |
| /* FT_OUTLINE_OWNER :: */ |
| /* If set, this flag indicates that the outline's field arrays */ |
| /* (i.e., `points', `flags', and `contours') are `owned' by the */ |
| /* outline object, and should thus be freed when it is destroyed. */ |
| /* */ |
| /* FT_OUTLINE_EVEN_ODD_FILL :: */ |
| /* By default, outlines are filled using the non-zero winding rule. */ |
| /* If set to 1, the outline will be filled using the even-odd fill */ |
| /* rule (only works with the smooth rasterizer). */ |
| /* */ |
| /* FT_OUTLINE_REVERSE_FILL :: */ |
| /* By default, outside contours of an outline are oriented in */ |
| /* clock-wise direction, as defined in the TrueType specification. */ |
| /* This flag is set if the outline uses the opposite direction */ |
| /* (typically for Type~1 fonts). This flag is ignored by the scan */ |
| /* converter. */ |
| /* */ |
| /* FT_OUTLINE_IGNORE_DROPOUTS :: */ |
| /* By default, the scan converter will try to detect drop-outs in */ |
| /* an outline and correct the glyph bitmap to ensure consistent */ |
| /* shape continuity. If set, this flag hints the scan-line */ |
| /* converter to ignore such cases. See below for more information. */ |
| /* */ |
| /* FT_OUTLINE_SMART_DROPOUTS :: */ |
| /* Select smart dropout control. If unset, use simple dropout */ |
| /* control. Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. See */ |
| /* below for more information. */ |
| /* */ |
| /* FT_OUTLINE_INCLUDE_STUBS :: */ |
| /* If set, turn pixels on for `stubs', otherwise exclude them. */ |
| /* Ignored if @FT_OUTLINE_IGNORE_DROPOUTS is set. See below for */ |
| /* more information. */ |
| /* */ |
| /* FT_OUTLINE_HIGH_PRECISION :: */ |
| /* This flag indicates that the scan-line converter should try to */ |
| /* convert this outline to bitmaps with the highest possible */ |
| /* quality. It is typically set for small character sizes. Note */ |
| /* that this is only a hint that might be completely ignored by a */ |
| /* given scan-converter. */ |
| /* */ |
| /* FT_OUTLINE_SINGLE_PASS :: */ |
| /* This flag is set to force a given scan-converter to only use a */ |
| /* single pass over the outline to render a bitmap glyph image. */ |
| /* Normally, it is set for very large character sizes. It is only */ |
| /* a hint that might be completely ignored by a given */ |
| /* scan-converter. */ |
| /* */ |
| /* <Note> */ |
| /* The flags @FT_OUTLINE_IGNORE_DROPOUTS, @FT_OUTLINE_SMART_DROPOUTS, */ |
| /* and @FT_OUTLINE_INCLUDE_STUBS are ignored by the smooth */ |
| /* rasterizer. */ |
| /* */ |
| /* There exists a second mechanism to pass the drop-out mode to the */ |
| /* B/W rasterizer; see the `tags' field in @FT_Outline. */ |
| /* */ |
| /* Please refer to the description of the `SCANTYPE' instruction in */ |
| /* the OpenType specification (in file `ttinst1.doc') how simple */ |
| /* drop-outs, smart drop-outs, and stubs are defined. */ |
| /* */ |
| #define FT_OUTLINE_NONE 0x0 |
| #define FT_OUTLINE_OWNER 0x1 |
| #define FT_OUTLINE_EVEN_ODD_FILL 0x2 |
| #define FT_OUTLINE_REVERSE_FILL 0x4 |
| #define FT_OUTLINE_IGNORE_DROPOUTS 0x8 |
| #define FT_OUTLINE_SMART_DROPOUTS 0x10 |
| #define FT_OUTLINE_INCLUDE_STUBS 0x20 |
| |
| #define FT_OUTLINE_HIGH_PRECISION 0x100 |
| #define FT_OUTLINE_SINGLE_PASS 0x200 |
| |
| |
| /************************************************************************* |
| * |
| * @enum: |
| * ft_outline_flags |
| * |
| * @description: |
| * These constants are deprecated. Please use the corresponding |
| * @FT_OUTLINE_FLAGS values. |
| * |
| * @values: |
| * ft_outline_none :: See @FT_OUTLINE_NONE. |
| * ft_outline_owner :: See @FT_OUTLINE_OWNER. |
| * ft_outline_even_odd_fill :: See @FT_OUTLINE_EVEN_ODD_FILL. |
| * ft_outline_reverse_fill :: See @FT_OUTLINE_REVERSE_FILL. |
| * ft_outline_ignore_dropouts :: See @FT_OUTLINE_IGNORE_DROPOUTS. |
| * ft_outline_high_precision :: See @FT_OUTLINE_HIGH_PRECISION. |
| * ft_outline_single_pass :: See @FT_OUTLINE_SINGLE_PASS. |
| */ |
| #define ft_outline_none FT_OUTLINE_NONE |
| #define ft_outline_owner FT_OUTLINE_OWNER |
| #define ft_outline_even_odd_fill FT_OUTLINE_EVEN_ODD_FILL |
| #define ft_outline_reverse_fill FT_OUTLINE_REVERSE_FILL |
| #define ft_outline_ignore_dropouts FT_OUTLINE_IGNORE_DROPOUTS |
| #define ft_outline_high_precision FT_OUTLINE_HIGH_PRECISION |
| #define ft_outline_single_pass FT_OUTLINE_SINGLE_PASS |
| |
| /* */ |
| |
| #define FT_CURVE_TAG( flag ) ( flag & 3 ) |
| |
| #define FT_CURVE_TAG_ON 1 |
| #define FT_CURVE_TAG_CONIC 0 |