#include <ft2build.h>
#include "ftsmooth.h"
#include "ftgrays.h"
#include "ftspic.h"
#include "ftsmerrs.h"

Include dependency graph for ftsmooth.c:

This graph shows which files directly or indirectly include this file:

Functions
static FT_Error	ft_smooth_init (FT_Renderer render)

static FT_Error	ft_smooth_set_mode (FT_Renderer render, FT_ULong mode_tag, FT_Pointer data)

static FT_Error	ft_smooth_transform (FT_Renderer render, FT_GlyphSlot slot, const FT_Matrix matrix, const FT_Vector delta)

static void	ft_smooth_get_cbox (FT_Renderer render, FT_GlyphSlot slot, FT_BBox *cbox)

static FT_Error	ft_smooth_render_generic (FT_Renderer render, FT_GlyphSlot slot, FT_Render_Mode mode, const FT_Vector *origin, FT_Render_Mode required_mode)

static FT_Error	ft_smooth_render (FT_Renderer render, FT_GlyphSlot slot, FT_Render_Mode mode, const FT_Vector *origin)

static FT_Error	ft_smooth_render_lcd (FT_Renderer render, FT_GlyphSlot slot, FT_Render_Mode mode, const FT_Vector *origin)

static FT_Error	ft_smooth_render_lcd_v (FT_Renderer render, FT_GlyphSlot slot, FT_Render_Mode mode, const FT_Vector *origin)

	FT_DEFINE_RENDERER (ft_smooth_renderer_class, FT_MODULE_RENDERER, sizeof(FT_RendererRec),"smooth", 0x10000L, 0x20000L, NULL,(FT_Module_Constructor) ft_smooth_init,(FT_Module_Destructor) NULL,(FT_Module_Requester) NULL, FT_GLYPH_FORMAT_OUTLINE,(FT_Renderer_RenderFunc) ft_smooth_render,(FT_Renderer_TransformFunc) ft_smooth_transform,(FT_Renderer_GetCBoxFunc) ft_smooth_get_cbox,(FT_Renderer_SetModeFunc) ft_smooth_set_mode,(FT_Raster_Funcs *)&FT_GRAYS_RASTER_GET) FT_DEFINE_RENDERER(ft_smooth_lcd_renderer_class

	sizeof (FT_RendererRec)

Variables
	FT_MODULE_RENDERER

smooth	lcd

smooth	NULL

smooth FT_Module_Constructor	ft_smooth_init

smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester	FT_GLYPH_FORMAT_OUTLINE

smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_Renderer_RenderFunc	ft_smooth_render_lcd

smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_Renderer_RenderFunc FT_Renderer_TransformFunc	ft_smooth_transform

smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_Renderer_RenderFunc FT_Renderer_TransformFunc FT_Renderer_GetCBoxFunc	ft_smooth_get_cbox

smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_Renderer_RenderFunc FT_Renderer_TransformFunc FT_Renderer_GetCBoxFunc FT_Renderer_SetModeFunc	ft_smooth_set_mode

Function Documentation

FT_DEFINE_RENDERER	(	ft_smooth_renderer_class	,
		FT_MODULE_RENDERER	,
		sizeof(FT_RendererRec)	,
		"smooth"	,
		0x10000L	,
		0x20000L	,
		NULL	,
		(FT_Module_Constructor)	ft_smooth_init,
		(FT_Module_Destructor)	NULL,
		(FT_Module_Requester)	NULL,
		FT_GLYPH_FORMAT_OUTLINE	,
		(FT_Renderer_RenderFunc)	ft_smooth_render,
		(FT_Renderer_TransformFunc)	ft_smooth_transform,
		(FT_Renderer_GetCBoxFunc)	ft_smooth_get_cbox,
		(FT_Renderer_SetModeFunc)	ft_smooth_set_mode,
		(FT_Raster_Funcs *)&	FT_GRAYS_RASTER_GET
	)

static void ft_smooth_get_cbox	(	FT_Renderer	render,
		FT_GlyphSlot	slot,
		FT_BBox *	cbox
	)

static

Definition at line 81 of file ftsmooth.c.

   {
     FT_ZERO( cbox );
 
     if ( slot->format == render->glyph_format )
       FT_Outline_Get_CBox( &slot->outline, cbox );
   }

static FT_Error ft_smooth_init ( FT_Renderer render )

static

Definition at line 32 of file ftsmooth.c.

   {
     render->clazz->raster_class->raster_reset( render->raster, NULL, 0 );
 
     return 0;
   }

static FT_Error ft_smooth_render	(	FT_Renderer	render,
		FT_GlyphSlot	slot,
		FT_Render_Mode	mode,
		const FT_Vector *	origin
	)

static

Definition at line 346 of file ftsmooth.c.

   {
     if ( mode == FT_RENDER_MODE_LIGHT )
       mode = FT_RENDER_MODE_NORMAL;
 
     return ft_smooth_render_generic( render, slot, mode, origin,
                                      FT_RENDER_MODE_NORMAL );
   }

static FT_Error ft_smooth_render_generic	(	FT_Renderer	render,
		FT_GlyphSlot	slot,
		FT_Render_Mode	mode,
		const FT_Vector *	origin,
		FT_Render_Mode	required_mode
	)

static

Definition at line 94 of file ftsmooth.c.

Referenced by ft_smooth_render(), ft_smooth_render_lcd(), and ft_smooth_render_lcd_v().

   {
     FT_Error     error   = FT_Err_Ok;
     FT_Outline*  outline = &slot->outline;
     FT_Bitmap*   bitmap  = &slot->bitmap;
     FT_Memory    memory  = render->root.memory;
     FT_Pos       x_shift = 0;
     FT_Pos       y_shift = 0;
     FT_Int       hmul    = ( mode == FT_RENDER_MODE_LCD );
     FT_Int       vmul    = ( mode == FT_RENDER_MODE_LCD_V );
 
     FT_Raster_Params  params;
 
 
     /* check glyph image format */
     if ( slot->format != render->glyph_format )
     {
       error = FT_THROW( Invalid_Argument );
       goto Exit;
     }
 
     /* check mode */
     if ( mode != required_mode )
     {
       error = FT_THROW( Cannot_Render_Glyph );
       goto Exit;
     }
 
     /* release old bitmap buffer */
     if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
     {
       FT_FREE( bitmap->buffer );
       slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
     }
 
     ft_glyphslot_preset_bitmap( slot, mode, origin );
 
     /* allocate new one */
     if ( FT_ALLOC_MULT( bitmap->buffer, bitmap->rows, bitmap->pitch ) )
       goto Exit;
 
     slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
 
     x_shift = 64 * -slot->bitmap_left;
     y_shift = 64 * -slot->bitmap_top;
     if ( bitmap->pixel_mode == FT_PIXEL_MODE_LCD_V )
       y_shift += 64 * (FT_Int)bitmap->rows / 3;
     else
       y_shift += 64 * (FT_Int)bitmap->rows;
 
     if ( origin )
     {
       x_shift += origin->x;
       y_shift += origin->y;
     }
 
     /* translate outline to render it into the bitmap */
     if ( x_shift || y_shift )
       FT_Outline_Translate( outline, x_shift, y_shift );
 
     /* set up parameters */
     params.target = bitmap;
     params.source = outline;
     params.flags  = FT_RASTER_FLAG_AA;
 
 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
 
     /* implode outline if needed */
     {
       FT_Vector*  points     = outline->points;
       FT_Vector*  points_end = points + outline->n_points;
       FT_Vector*  vec;
 
 
       if ( hmul )
         for ( vec = points; vec < points_end; vec++ )
           vec->x *= 3;
 
       if ( vmul )
         for ( vec = points; vec < points_end; vec++ )
           vec->y *= 3;
     }
 
     /* render outline into the bitmap */
     error = render->raster_render( render->raster, &params );
 
     /* deflate outline if needed */
     {
       FT_Vector*  points     = outline->points;
       FT_Vector*  points_end = points + outline->n_points;
       FT_Vector*  vec;
 
 
       if ( hmul )
         for ( vec = points; vec < points_end; vec++ )
           vec->x /= 3;
 
       if ( vmul )
         for ( vec = points; vec < points_end; vec++ )
           vec->y /= 3;
     }
 
     if ( error )
       goto Exit;
 
     /* finally apply filtering */
     if ( hmul || vmul )
     {
       FT_Byte*                 lcd_weights;
       FT_Bitmap_LcdFilterFunc  lcd_filter_func;
 
 
       /* Per-face LCD filtering takes priority if set up. */
       if ( slot->face && slot->face->internal->lcd_filter_func )
       {
         lcd_weights     = slot->face->internal->lcd_weights;
         lcd_filter_func = slot->face->internal->lcd_filter_func;
       }
       else
       {
         lcd_weights     = slot->library->lcd_weights;
         lcd_filter_func = slot->library->lcd_filter_func;
       }
 
       if ( lcd_filter_func )
         lcd_filter_func( bitmap, mode, lcd_weights );
     }
 
 #else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
 
     if ( hmul )  /* lcd */
     {
       FT_Byte*  line;
       FT_Byte*  temp = NULL;
       FT_UInt   i, j;
 
       unsigned int  height = bitmap->rows;
       unsigned int  width  = bitmap->width;
       int           pitch  = bitmap->pitch;
 
 
       /* Render 3 separate monochrome bitmaps, shifting the outline  */
       /* by 1/3 pixel.                                               */
       width /= 3;
 
       bitmap->buffer += width;
 
       error = render->raster_render( render->raster, &params );
       if ( error )
         goto Exit;
 
       FT_Outline_Translate( outline, -21, 0 );
       x_shift        -= 21;
       bitmap->buffer += width;
 
       error = render->raster_render( render->raster, &params );
       if ( error )
         goto Exit;
 
       FT_Outline_Translate( outline,  42, 0 );
       x_shift        += 42;
       bitmap->buffer -= 2 * width;
 
       error = render->raster_render( render->raster, &params );
       if ( error )
         goto Exit;
 
       /* XXX: Rearrange the bytes according to FT_PIXEL_MODE_LCD.    */
       /* XXX: It is more efficient to render every third byte above. */
 
       if ( FT_ALLOC( temp, (FT_ULong)pitch ) )
         goto Exit;
 
       for ( i = 0; i < height; i++ )
       {
         line = bitmap->buffer + i * (FT_ULong)pitch;
         for ( j = 0; j < width; j++ )
         {
           temp[3 * j    ] = line[j];
           temp[3 * j + 1] = line[j + width];
           temp[3 * j + 2] = line[j + width + width];
         }
         FT_MEM_COPY( line, temp, pitch );
       }
 
       FT_FREE( temp );
     }
     else if ( vmul )  /* lcd_v */
     {
       int  pitch  = bitmap->pitch;
 
 
       /* Render 3 separate monochrome bitmaps, shifting the outline  */
       /* by 1/3 pixel. Triple the pitch to render on each third row. */
       bitmap->pitch *= 3;
       bitmap->rows  /= 3;
 
       bitmap->buffer += pitch;
 
       error = render->raster_render( render->raster, &params );
       if ( error )
         goto Exit;
 
       FT_Outline_Translate( outline, 0,  21 );
       y_shift        += 21;
       bitmap->buffer += pitch;
 
       error = render->raster_render( render->raster, &params );
       if ( error )
         goto Exit;
 
       FT_Outline_Translate( outline, 0, -42 );
       y_shift        -= 42;
       bitmap->buffer -= 2 * pitch;
 
       error = render->raster_render( render->raster, &params );
       if ( error )
         goto Exit;
 
       bitmap->pitch /= 3;
       bitmap->rows  *= 3;
     }
     else  /* grayscale */
       error = render->raster_render( render->raster, &params );
 
 #endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
 
   Exit:
     if ( !error )
     {
       /* everything is fine; the glyph is now officially a bitmap */
       slot->format = FT_GLYPH_FORMAT_BITMAP;
     }
     else if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
     {
       FT_FREE( bitmap->buffer );
       slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
     }
 
     if ( x_shift || y_shift )
       FT_Outline_Translate( outline, -x_shift, -y_shift );
 
     return error;
   }

static FT_Error ft_smooth_render_lcd	(	FT_Renderer	render,
		FT_GlyphSlot	slot,
		FT_Render_Mode	mode,
		const FT_Vector *	origin
	)

static

Definition at line 361 of file ftsmooth.c.

   {
     return ft_smooth_render_generic( render, slot, mode, origin,
                                      FT_RENDER_MODE_LCD );
   }

static FT_Error ft_smooth_render_lcd_v	(	FT_Renderer	render,
		FT_GlyphSlot	slot,
		FT_Render_Mode	mode,
		const FT_Vector *	origin
	)

static

Definition at line 373 of file ftsmooth.c.

   {
     return ft_smooth_render_generic( render, slot, mode, origin,
                                      FT_RENDER_MODE_LCD_V );
   }

static FT_Error ft_smooth_set_mode	(	FT_Renderer	render,
		FT_ULong	mode_tag,
		FT_Pointer	data
	)

static

Definition at line 42 of file ftsmooth.c.

   {
     /* we simply pass it to the raster */
     return render->clazz->raster_class->raster_set_mode( render->raster,
                                                          mode_tag,
                                                          data );
   }

static FT_Error ft_smooth_transform	(	FT_Renderer	render,
		FT_GlyphSlot	slot,
		const FT_Matrix *	matrix,
		const FT_Vector *	delta
	)

static

Definition at line 54 of file ftsmooth.c.

   {
     FT_Error  error = FT_Err_Ok;
 
 
     if ( slot->format != render->glyph_format )
     {
       error = FT_THROW( 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;
   }