src/smooth/ftsmooth.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftsmooth.c                                                             */
   4 /*                                                                         */
   5 /*    Anti-aliasing renderer interface (body).                             */
   6 /*                                                                         */
   7 /*  Copyright 2000-2006, 2009-2012 by                                      */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 #include <ft2build.h>
  20 #include FT_INTERNAL_DEBUG_H
  21 #include FT_INTERNAL_OBJECTS_H
  22 #include FT_OUTLINE_H
  23 #include "ftsmooth.h"
  24 #include "ftgrays.h"
  25 #include "ftspic.h"
  26
  27 #include "ftsmerrs.h"
  28
  29
  30   /* initialize renderer -- init its raster */
  31   static FT_Error
  32   ft_smooth_init( FT_Renderer  render )
  33   {
  34     FT_Library  library = FT_MODULE_LIBRARY( render );
  35
  36
  37     render->clazz->raster_class->raster_reset( render->raster,
  38                                                library->raster_pool,
  39                                                library->raster_pool_size );
  40
  41     return 0;
  42   }
  43
  44
  45   /* sets render-specific mode */
  46   static FT_Error
  47   ft_smooth_set_mode( FT_Renderer  render,
  48                       FT_ULong     mode_tag,
  49                       FT_Pointer   data )
  50   {
  51     /* we simply pass it to the raster */
  52     return render->clazz->raster_class->raster_set_mode( render->raster,
  53                                                          mode_tag,
  54                                                          data );
  55   }
  56
  57   /* transform a given glyph image */
  58   static FT_Error
  59   ft_smooth_transform( FT_Renderer       render,
  60                        FT_GlyphSlot      slot,
  61                        const FT_Matrix*  matrix,
  62                        const FT_Vector*  delta )
  63   {
  64     FT_Error  error = Smooth_Err_Ok;
  65
  66
  67     if ( slot->format != render->glyph_format )
  68     {
  69       error = Smooth_Err_Invalid_Argument;
  70       goto Exit;
  71     }
  72
  73     if ( matrix )
  74       FT_Outline_Transform( &slot->outline, matrix );
  75
  76     if ( delta )
  77       FT_Outline_Translate( &slot->outline, delta->x, delta->y );
  78
  79   Exit:
  80     return error;
  81   }
  82
  83
  84   /* return the glyph's control box */
  85   static void
  86   ft_smooth_get_cbox( FT_Renderer   render,
  87                       FT_GlyphSlot  slot,
  88                       FT_BBox*      cbox )
  89   {
  90     FT_MEM_ZERO( cbox, sizeof ( *cbox ) );
  91
  92     if ( slot->format == render->glyph_format )
  93       FT_Outline_Get_CBox( &slot->outline, cbox );
  94   }
  95
  96
  97   /* convert a slot's glyph image into a bitmap */
  98   static FT_Error
  99   ft_smooth_render_generic( FT_Renderer       render,
 100                             FT_GlyphSlot      slot,
 101                             FT_Render_Mode    mode,
 102                             const FT_Vector*  origin,
 103                             FT_Render_Mode    required_mode )
 104   {
 105     FT_Error     error;
 106     FT_Outline*  outline = NULL;
 107     FT_BBox      cbox;
 108     FT_Pos       width, height, pitch;
 109 #ifndef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
 110     FT_Pos       height_org, width_org;
 111 #endif
 112     FT_Bitmap*   bitmap;
 113     FT_Memory    memory;
 114     FT_Int       hmul = mode == FT_RENDER_MODE_LCD;
 115     FT_Int       vmul = mode == FT_RENDER_MODE_LCD_V;
 116     FT_Pos       x_shift, y_shift, x_left, y_top;
 117
 118     FT_Raster_Params  params;
 119
 120
 121     /* check glyph image format */
 122     if ( slot->format != render->glyph_format )
 123     {
 124       error = Smooth_Err_Invalid_Argument;
 125       goto Exit;
 126     }
 127
 128     /* check mode */
 129     if ( mode != required_mode )
 130       return Smooth_Err_Cannot_Render_Glyph;
 131
 132     outline = &slot->outline;
 133
 134     /* translate the outline to the new origin if needed */
 135     if ( origin )
 136       FT_Outline_Translate( outline, origin->x, origin->y );
 137
 138     /* compute the control box, and grid fit it */
 139     FT_Outline_Get_CBox( outline, &cbox );
 140
 141     cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
 142     cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
 143     cbox.xMax = FT_PIX_CEIL( cbox.xMax );
 144     cbox.yMax = FT_PIX_CEIL( cbox.yMax );
 145
 146     if ( cbox.xMin < 0 && cbox.xMax > FT_INT_MAX + cbox.xMin )
 147     {
 148       FT_ERROR(( "ft_smooth_render_generic: glyph too large:"
 149                  " xMin = %d, xMax = %d\n",
 150                  cbox.xMin >> 6, cbox.xMax >> 6 ));
 151       return Smooth_Err_Raster_Overflow;
 152     }
 153     else
 154       width  = ( cbox.xMax - cbox.xMin ) >> 6;
 155
 156     if ( cbox.yMin < 0 && cbox.yMax > FT_INT_MAX + cbox.yMin )
 157     {
 158       FT_ERROR(( "ft_smooth_render_generic: glyph too large:"
 159                  " yMin = %d, yMax = %d\n",
 160                  cbox.yMin >> 6, cbox.yMax >> 6 ));
 161       return Smooth_Err_Raster_Overflow;
 162     }
 163     else
 164       height = ( cbox.yMax - cbox.yMin ) >> 6;
 165
 166     bitmap = &slot->bitmap;
 167     memory = render->root.memory;
 168
 169 #ifndef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
 170     width_org  = width;
 171     height_org = height;
 172 #endif
 173
 174     /* release old bitmap buffer */
 175     if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
 176     {
 177       FT_FREE( bitmap->buffer );
 178       slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
 179     }
 180
 181     /* allocate new one */
 182     pitch = width;
 183     if ( hmul )
 184     {
 185       width = width * 3;
 186       pitch = FT_PAD_CEIL( width, 4 );
 187     }
 188
 189     if ( vmul )
 190       height *= 3;
 191
 192     x_shift = (FT_Int) cbox.xMin;
 193     y_shift = (FT_Int) cbox.yMin;
 194     x_left  = (FT_Int)( cbox.xMin >> 6 );
 195     y_top   = (FT_Int)( cbox.yMax >> 6 );
 196
 197 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
 198
 199     if ( slot->library->lcd_filter_func )
 200     {
 201       FT_Int  extra = slot->library->lcd_extra;
 202
 203
 204       if ( hmul )
 205       {
 206         x_shift -= 64 * ( extra >> 1 );
 207         width   += 3 * extra;
 208         pitch    = FT_PAD_CEIL( width, 4 );
 209         x_left  -= extra >> 1;
 210       }
 211
 212       if ( vmul )
 213       {
 214         y_shift -= 64 * ( extra >> 1 );
 215         height  += 3 * extra;
 216         y_top   += extra >> 1;
 217       }
 218     }
 219
 220 #endif
 221
 222 #if FT_UINT_MAX > 0xFFFFU
 223
 224     /* Required check is ( pitch * height < FT_ULONG_MAX ),     */
 225     /* but we care realistic cases only. Always pitch <= width. */
 226     if ( width > 0x7FFF || height > 0x7FFF )
 227     {
 228       FT_ERROR(( "ft_smooth_render_generic: glyph too large: %u x %u\n",
 229                  width, height ));
 230       return Smooth_Err_Raster_Overflow;
 231     }
 232
 233 #endif
 234
 235     bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
 236     bitmap->num_grays  = 256;
 237     bitmap->width      = width;
 238     bitmap->rows       = height;
 239     bitmap->pitch      = pitch;
 240
 241     /* translate outline to render it into the bitmap */
 242     FT_Outline_Translate( outline, -x_shift, -y_shift );
 243
 244     if ( FT_ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
 245       goto Exit;
 246
 247     slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
 248
 249     /* set up parameters */
 250     params.target = bitmap;
 251     params.source = outline;
 252     params.flags  = FT_RASTER_FLAG_AA;
 253
 254 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
 255
 256     /* implode outline if needed */
 257     {
 258       FT_Vector*  points     = outline->points;
 259       FT_Vector*  points_end = points + outline->n_points;
 260       FT_Vector*  vec;
 261
 262
 263       if ( hmul )
 264         for ( vec = points; vec < points_end; vec++ )
 265           vec->x *= 3;
 266
 267       if ( vmul )
 268         for ( vec = points; vec < points_end; vec++ )
 269           vec->y *= 3;
 270     }
 271
 272     /* render outline into the bitmap */
 273     error = render->raster_render( render->raster, &params );
 274
 275     /* deflate outline if needed */
 276     {
 277       FT_Vector*  points     = outline->points;
 278       FT_Vector*  points_end = points + outline->n_points;
 279       FT_Vector*  vec;
 280
 281
 282       if ( hmul )
 283         for ( vec = points; vec < points_end; vec++ )
 284           vec->x /= 3;
 285
 286       if ( vmul )
 287         for ( vec = points; vec < points_end; vec++ )
 288           vec->y /= 3;
 289     }
 290
 291     if ( slot->library->lcd_filter_func )
 292       slot->library->lcd_filter_func( bitmap, mode, slot->library );
 293
 294 #else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
 295
 296     /* render outline into bitmap */
 297     error = render->raster_render( render->raster, &params );
 298
 299     /* expand it horizontally */
 300     if ( hmul )
 301     {
 302       FT_Byte*  line = bitmap->buffer;
 303       FT_UInt   hh;
 304
 305
 306       for ( hh = height_org; hh > 0; hh--, line += pitch )
 307       {
 308         FT_UInt   xx;
 309         FT_Byte*  end = line + width;
 310
 311
 312         for ( xx = width_org; xx > 0; xx-- )
 313         {
 314           FT_UInt  pixel = line[xx-1];
 315
 316
 317           end[-3] = (FT_Byte)pixel;
 318           end[-2] = (FT_Byte)pixel;
 319           end[-1] = (FT_Byte)pixel;
 320           end    -= 3;
 321         }
 322       }
 323     }
 324
 325     /* expand it vertically */
 326     if ( vmul )
 327     {
 328       FT_Byte*  read  = bitmap->buffer + ( height - height_org ) * pitch;
 329       FT_Byte*  write = bitmap->buffer;
 330       FT_UInt   hh;
 331
 332
 333       for ( hh = height_org; hh > 0; hh-- )
 334       {
 335         ft_memcpy( write, read, pitch );
 336         write += pitch;
 337
 338         ft_memcpy( write, read, pitch );
 339         write += pitch;
 340
 341         ft_memcpy( write, read, pitch );
 342         write += pitch;
 343         read  += pitch;
 344       }
 345     }
 346
 347 #endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
 348
 349     FT_Outline_Translate( outline, x_shift, y_shift );
 350
 351     /*
 352      * XXX: on 16bit system, we return an error for huge bitmap
 353      * to prevent an overflow.
 354      */
 355     if ( x_left > FT_INT_MAX || y_top > FT_INT_MAX )
 356       return Smooth_Err_Invalid_Pixel_Size;
 357
 358     if ( error )
 359       goto Exit;
 360
 361     slot->format      = FT_GLYPH_FORMAT_BITMAP;
 362     slot->bitmap_left = (FT_Int)x_left;
 363     slot->bitmap_top  = (FT_Int)y_top;
 364
 365   Exit:
 366     if ( outline && origin )
 367       FT_Outline_Translate( outline, -origin->x, -origin->y );
 368
 369     return error;
 370   }
 371
 372
 373   /* convert a slot's glyph image into a bitmap */
 374   static FT_Error
 375   ft_smooth_render( FT_Renderer       render,
 376                     FT_GlyphSlot      slot,
 377                     FT_Render_Mode    mode,
 378                     const FT_Vector*  origin )
 379   {
 380     if ( mode == FT_RENDER_MODE_LIGHT )
 381       mode = FT_RENDER_MODE_NORMAL;
 382
 383     return ft_smooth_render_generic( render, slot, mode, origin,
 384                                      FT_RENDER_MODE_NORMAL );
 385   }
 386
 387
 388   /* convert a slot's glyph image into a horizontal LCD bitmap */
 389   static FT_Error
 390   ft_smooth_render_lcd( FT_Renderer       render,
 391                         FT_GlyphSlot      slot,
 392                         FT_Render_Mode    mode,
 393                         const FT_Vector*  origin )
 394   {
 395     FT_Error  error;
 396
 397     error = ft_smooth_render_generic( render, slot, mode, origin,
 398                                       FT_RENDER_MODE_LCD );
 399     if ( !error )
 400       slot->bitmap.pixel_mode = FT_PIXEL_MODE_LCD;
 401
 402     return error;
 403   }
 404
 405
 406   /* convert a slot's glyph image into a vertical LCD bitmap */
 407   static FT_Error
 408   ft_smooth_render_lcd_v( FT_Renderer       render,
 409                           FT_GlyphSlot      slot,
 410                           FT_Render_Mode    mode,
 411                           const FT_Vector*  origin )
 412   {
 413     FT_Error  error;
 414
 415     error = ft_smooth_render_generic( render, slot, mode, origin,
 416                                       FT_RENDER_MODE_LCD_V );
 417     if ( !error )
 418       slot->bitmap.pixel_mode = FT_PIXEL_MODE_LCD_V;
 419
 420     return error;
 421   }
 422
 423
 424   FT_DEFINE_RENDERER( ft_smooth_renderer_class,
 425
 426       FT_MODULE_RENDERER,
 427       sizeof ( FT_RendererRec ),
 428
 429       "smooth",
 430       0x10000L,
 431       0x20000L,
 432
 433       0,    /* module specific interface */
 434
 435       (FT_Module_Constructor)ft_smooth_init,
 436       (FT_Module_Destructor) 0,
 437       (FT_Module_Requester)  0
 438     ,
 439
 440     FT_GLYPH_FORMAT_OUTLINE,
 441
 442     (FT_Renderer_RenderFunc)   ft_smooth_render,
 443     (FT_Renderer_TransformFunc)ft_smooth_transform,
 444     (FT_Renderer_GetCBoxFunc)  ft_smooth_get_cbox,
 445     (FT_Renderer_SetModeFunc)  ft_smooth_set_mode,
 446
 447     (FT_Raster_Funcs*)    &FT_GRAYS_RASTER_GET
 448   )
 449
 450
 451   FT_DEFINE_RENDERER( ft_smooth_lcd_renderer_class,
 452
 453       FT_MODULE_RENDERER,
 454       sizeof ( FT_RendererRec ),
 455
 456       "smooth-lcd",
 457       0x10000L,
 458       0x20000L,
 459
 460       0,    /* module specific interface */
 461
 462       (FT_Module_Constructor)ft_smooth_init,
 463       (FT_Module_Destructor) 0,
 464       (FT_Module_Requester)  0
 465     ,
 466
 467     FT_GLYPH_FORMAT_OUTLINE,
 468
 469     (FT_Renderer_RenderFunc)   ft_smooth_render_lcd,
 470     (FT_Renderer_TransformFunc)ft_smooth_transform,
 471     (FT_Renderer_GetCBoxFunc)  ft_smooth_get_cbox,
 472     (FT_Renderer_SetModeFunc)  ft_smooth_set_mode,
 473
 474     (FT_Raster_Funcs*)    &FT_GRAYS_RASTER_GET
 475   )
 476
 477   FT_DEFINE_RENDERER( ft_smooth_lcdv_renderer_class,
 478
 479       FT_MODULE_RENDERER,
 480       sizeof ( FT_RendererRec ),
 481
 482       "smooth-lcdv",
 483       0x10000L,
 484       0x20000L,
 485
 486       0,    /* module specific interface */
 487
 488       (FT_Module_Constructor)ft_smooth_init,
 489       (FT_Module_Destructor) 0,
 490       (FT_Module_Requester)  0
 491     ,
 492
 493     FT_GLYPH_FORMAT_OUTLINE,
 494
 495     (FT_Renderer_RenderFunc)   ft_smooth_render_lcd_v,
 496     (FT_Renderer_TransformFunc)ft_smooth_transform,
 497     (FT_Renderer_GetCBoxFunc)  ft_smooth_get_cbox,
 498     (FT_Renderer_SetModeFunc)  ft_smooth_set_mode,
 499
 500     (FT_Raster_Funcs*)    &FT_GRAYS_RASTER_GET
 501   )
 502
 503
 504 /* END */