/***************************************************************************/
/*                                                                         */
/*  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 */