added new renderer module

src/raster1/ftraster.h

+/***************************************************************************/
+/*                                                                         */
+/*  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 <freetype/ftimage.h>
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* 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(FT_Raster_Funcs)  ft_standard_raster;
+
+#ifdef __cplusplus
+  }
+#endif
+
+#endif /* FTRASTER_H */
+
+
+/* END */

src/raster1/ftrend1.c

+#include <freetype/internal/ftobjs.h>
+#include <raster1.h>
+#include <ftraster.h>
+
+ /* initialise 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 0;
+  }
+  
+
+
+ /* sets 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_antialias )
+    {
+      /* 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_antialias )
+    {
+      /* 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, &params );
+    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;
+  }
+
+
+  const FT_Renderer_Class   ft_raster1_renderer_class =
+  {
+    {
+      ft_module_renderer,
+      sizeof( FT_RendererRec ),
+      
+      "raster1",
+      0x10000,
+      0x20000,
+      
+      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'll need */
+ /* to register it by hand in your application. It should only be   */
+ /* used for backwards-compatibility with FT 1.x anyway..           */
+  const FT_Renderer_Class  ft_raster5_renderer_class =
+  {
+    {
+      ft_module_renderer,
+      sizeof( FT_RendererRec ),
+      
+      "raster5",
+      0x10000,
+      0x20000,
+      
+      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
+  };
+
+

src/raster1/ftrend1.h

+#ifndef FTREND1_H
+#define FTREND1_H
+
+#include <freetype/ftrender.h>
+
+  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;
+
+#endif /* FTREND1_H */

src/raster1/module.mk

+make_module_list: add_raster1_module
+
+add_raster1_module:
+	$(OPEN_DRIVER)ft_raster1_renderer_class$(CLOSE_DRIVER)
+	$(ECHO_DRIVER)raster1   $(ECHO_DRIVER_DESC)monochrome bitmap renderer$(ECHO_DRIVER_DONE)
+
+# EOF

src/raster1/raster1.c

+#define FT_MAKE_OPTION_SINGLE_OBJECT
+#include <ftraster.c>
+#include <ftrend1.c>
+

src/raster1/raster1.h

+#ifndef RASTER1_H
+#define RASTER1_H
+
+#include <freetype/ftrender.h>
+
+  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;
+
+#endif /* RASTER1_H */

src/raster1/rules.mk

+#
+# FreeType 2 renderer module build rules
+#
+
+
+# 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.
+
+
+# renderer driver directory
+#
+RAS1_DIR  := $(SRC_)raster1
+RAS1_DIR_ := $(RAS1_DIR)$(SEP)
+
+
+# additional include flags used when compiling the driver
+#
+RAS1_INCLUDE := $(RAS1_DIR)
+
+# compilation flags for the driver
+#
+RAS1_CFLAGS  := $(RAS1_INCLUDE:%=$I%)
+RAS1_COMPILE := $(FT_COMPILE) $(RAS1_CFLAGS)
+
+
+# RASTER1 driver sources (i.e., C files)
+#
+RAS1_DRV_SRC := $(RAS1_DIR_)ftraster.c  \
+                $(RAS1_DIR_)ftrend1.c
+
+# RASTER1 driver headers
+#
+RAS1_DRV_H := $(RAS1_DRV_SRC:%c=%h)
+
+
+# RASTER1 driver object(s)
+#
+#   RAS1_DRV_OBJ_M is used during `multi' builds.
+#   RAS1_DRV_OBJ_S is used during `single' builds.
+#
+RAS1_DRV_OBJ_M := $(RAS1_DRV_SRC:$(RAS1_DIR_)%.c=$(OBJ_)%.$O)
+RAS1_DRV_OBJ_S := $(OBJ_)raster1.$O
+
+# RASTER1 driver source file for single build
+#
+RAS1_DRV_SRC_S := $(RAS1_DIR_)raster1.c
+
+
+# RASTER1 driver - single object
+#
+$(RAS1_DRV_OBJ_S): $(RAS1_DRV_SRC_S) $(RAS1_DRV_SRC) \
+                   $(FREETYPE_H) $(RAS1_DRV_H)
+	$(RAS1_COMPILE) $T$@ $(RAS1_DRV_SRC_S)
+
+
+# RASTER1 driver - multiple objects
+#
+$(OBJ_)%.$O: $(RAS1_DIR_)%.c $(FREETYPE_H) $(RAS1_DRV_H)
+	$(RAS1_COMPILE) $T$@ $<
+
+
+# update main driver object lists
+#
+DRV_OBJS_S += $(RAS1_DRV_OBJ_S)
+DRV_OBJS_M += $(RAS1_DRV_OBJ_M)
+
+
+# EOF

src/smooth/ftgrays.h

+/***************************************************************************/
+/*                                                                         */
+/*  ftgrays.h                                                              */
+/*                                                                         */
+/*    FreeType smooth renderer declaration                                 */
+/*                                                                         */
+/*  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 FTGRAYS_H
+#define FTGRAYS_H
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+#ifdef _STANDALONE_
+#include "ftimage.h"
+#else
+#include <freetype/ftimage.h>
+#endif
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* To make ftgrays.h independent from configuration files we check       */
+  /* whether FT_EXPORT_DEF has been defined already.                          */
+  /*                                                                       */
+  /* On some systems and compilers (Win32 mostly), an extra keyword is     */
+  /* necessary to compile the library as a DLL.                            */
+  /*                                                                       */
+#ifndef FT_EXPORT_VAR
+#define FT_EXPORT_VAR(x)  extern  x
+#endif
+
+  FT_EXPORT_VAR(FT_Raster_Funcs)  ft_grays_raster;
+
+  #ifdef __cplusplus
+  }
+  #endif
+
+#endif

src/smooth/ftsmooth.c

+#include <freetype/internal/ftobjs.h>
+#include <ftsmooth.h>
+#include <ftgrays.h>
+
+ /* initialise renderer - init its raster */
+  static FT_Error ft_smooth_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 0;
+  }
+  
+
+
+ /* sets render-specific mode */
+  static  FT_Error  ft_smooth_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_smooth_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_smooth_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_smooth_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 mode */
+    if ( !(mode & ft_render_mode_antialias) )
+      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 = slot->face->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 */
+    pitch = width;
+    bitmap->pixel_mode = ft_pixel_mode_grays;
+    bitmap->num_grays  = 256;
+    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  = ft_raster_flag_aa;
+
+    /* render outline into the bitmap */
+    error = render->raster_render( render->raster, &params );
+    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;
+  }
+
+
+  const FT_Renderer_Class  ft_smooth_renderer_class =
+  {
+    {
+      ft_module_renderer,
+      sizeof( FT_RendererRec ),
+      
+      "smooth",
+      0x10000,
+      0x20000,
+      
+      0,    /* module specific interface */
+      
+      (FT_Module_Constructor)  ft_smooth_init,
+      (FT_Module_Destructor)   0,
+      (FT_Module_Requester)    0
+    },
+
+    ft_glyph_format_outline,
+    
+    (FTRenderer_render)       ft_smooth_render,
+    (FTRenderer_transform)    ft_smooth_transform,
+    (FTRenderer_getCBox)      ft_smooth_get_cbox,
+    (FTRenderer_setMode)      ft_smooth_set_mode,
+    
+    (FT_Raster_Funcs*)        &ft_grays_raster
+  };
+