1/***************************************************************************/ 2/* */ 3/* ftsmooth.c */ 4/* */ 5/* Anti-aliasing renderer interface (body). */ 6/* */ 7/* Copyright 2000-2006, 2009-2013 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 = FT_Err_Ok; 65 66 67 if ( slot->format != render->glyph_format ) 68 { 69 error = FT_THROW( 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 = &slot->bitmap; 113 FT_Memory memory = render->root.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 = 0; 117 FT_Pos y_shift = 0; 118 FT_Pos x_left, y_top; 119 120 FT_Raster_Params params; 121 122 FT_Bool have_translated_origin = FALSE; 123 FT_Bool have_outline_shifted = FALSE; 124 FT_Bool have_buffer = FALSE; 125 126 127 /* check glyph image format */ 128 if ( slot->format != render->glyph_format ) 129 { 130 error = FT_THROW( Invalid_Argument ); 131 goto Exit; 132 } 133 134 /* check mode */ 135 if ( mode != required_mode ) 136 { 137 error = FT_THROW( Cannot_Render_Glyph ); 138 goto Exit; 139 } 140 141 outline = &slot->outline; 142 143 /* translate the outline to the new origin if needed */ 144 if ( origin ) 145 { 146 FT_Outline_Translate( outline, origin->x, origin->y ); 147 have_translated_origin = TRUE; 148 } 149 150 /* compute the control box, and grid fit it */ 151 FT_Outline_Get_CBox( outline, &cbox ); 152 153 cbox.xMin = FT_PIX_FLOOR( cbox.xMin ); 154 cbox.yMin = FT_PIX_FLOOR( cbox.yMin ); 155 cbox.xMax = FT_PIX_CEIL( cbox.xMax ); 156 cbox.yMax = FT_PIX_CEIL( cbox.yMax ); 157 158 if ( cbox.xMin < 0 && cbox.xMax > FT_INT_MAX + cbox.xMin ) 159 { 160 FT_ERROR(( "ft_smooth_render_generic: glyph too large:" 161 " xMin = %d, xMax = %d\n", 162 cbox.xMin >> 6, cbox.xMax >> 6 )); 163 error = FT_THROW( Raster_Overflow ); 164 goto Exit; 165 } 166 else 167 width = ( cbox.xMax - cbox.xMin ) >> 6; 168 169 if ( cbox.yMin < 0 && cbox.yMax > FT_INT_MAX + cbox.yMin ) 170 { 171 FT_ERROR(( "ft_smooth_render_generic: glyph too large:" 172 " yMin = %d, yMax = %d\n", 173 cbox.yMin >> 6, cbox.yMax >> 6 )); 174 error = FT_THROW( Raster_Overflow ); 175 goto Exit; 176 } 177 else 178 height = ( cbox.yMax - cbox.yMin ) >> 6; 179 180#ifndef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 181 width_org = width; 182 height_org = height; 183#endif 184 185 /* release old bitmap buffer */ 186 if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) 187 { 188 FT_FREE( bitmap->buffer ); 189 slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP; 190 } 191 192 /* allocate new one */ 193 pitch = width; 194 if ( hmul ) 195 { 196 width = width * 3; 197 pitch = FT_PAD_CEIL( width, 4 ); 198 } 199 200 if ( vmul ) 201 height *= 3; 202 203 x_shift = (FT_Int) cbox.xMin; 204 y_shift = (FT_Int) cbox.yMin; 205 x_left = (FT_Int)( cbox.xMin >> 6 ); 206 y_top = (FT_Int)( cbox.yMax >> 6 ); 207 208#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 209 210 if ( slot->library->lcd_filter_func ) 211 { 212 FT_Int extra = slot->library->lcd_extra; 213 214 215 if ( hmul ) 216 { 217 x_shift -= 64 * ( extra >> 1 ); 218 width += 3 * extra; 219 pitch = FT_PAD_CEIL( width, 4 ); 220 x_left -= extra >> 1; 221 } 222 223 if ( vmul ) 224 { 225 y_shift -= 64 * ( extra >> 1 ); 226 height += 3 * extra; 227 y_top += extra >> 1; 228 } 229 } 230 231#endif 232 233#if FT_UINT_MAX > 0xFFFFU 234 235 /* Required check is (pitch * height < FT_ULONG_MAX), */ 236 /* but we care realistic cases only. Always pitch <= width. */ 237 if ( width > 0x7FFF || height > 0x7FFF ) 238 { 239 FT_ERROR(( "ft_smooth_render_generic: glyph too large: %u x %u\n", 240 width, height )); 241 error = FT_THROW( Raster_Overflow ); 242 goto Exit; 243 } 244 245#endif 246 247 bitmap->pixel_mode = FT_PIXEL_MODE_GRAY; 248 bitmap->num_grays = 256; 249 bitmap->width = width; 250 bitmap->rows = height; 251 bitmap->pitch = pitch; 252 253 /* translate outline to render it into the bitmap */ 254 FT_Outline_Translate( outline, -x_shift, -y_shift ); 255 have_outline_shifted = TRUE; 256 257 if ( FT_ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) ) 258 goto Exit; 259 else 260 have_buffer = TRUE; 261 262 slot->internal->flags |= FT_GLYPH_OWN_BITMAP; 263 264 /* set up parameters */ 265 params.target = bitmap; 266 params.source = outline; 267 params.flags = FT_RASTER_FLAG_AA; 268 269#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 270 271 /* implode outline if needed */ 272 { 273 FT_Vector* points = outline->points; 274 FT_Vector* points_end = points + outline->n_points; 275 FT_Vector* vec; 276 277 278 if ( hmul ) 279 for ( vec = points; vec < points_end; vec++ ) 280 vec->x *= 3; 281 282 if ( vmul ) 283 for ( vec = points; vec < points_end; vec++ ) 284 vec->y *= 3; 285 } 286 287 /* render outline into the bitmap */ 288 error = render->raster_render( render->raster, ¶ms ); 289 290 /* deflate outline if needed */ 291 { 292 FT_Vector* points = outline->points; 293 FT_Vector* points_end = points + outline->n_points; 294 FT_Vector* vec; 295 296 297 if ( hmul ) 298 for ( vec = points; vec < points_end; vec++ ) 299 vec->x /= 3; 300 301 if ( vmul ) 302 for ( vec = points; vec < points_end; vec++ ) 303 vec->y /= 3; 304 } 305 306 if ( error ) 307 goto Exit; 308 309 if ( slot->library->lcd_filter_func ) 310 slot->library->lcd_filter_func( bitmap, mode, slot->library ); 311 312#else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */ 313 314 /* render outline into bitmap */ 315 error = render->raster_render( render->raster, ¶ms ); 316 if ( error ) 317 goto Exit; 318 319 /* expand it horizontally */ 320 if ( hmul ) 321 { 322 FT_Byte* line = bitmap->buffer; 323 FT_UInt hh; 324 325 326 for ( hh = height_org; hh > 0; hh--, line += pitch ) 327 { 328 FT_UInt xx; 329 FT_Byte* end = line + width; 330 331 332 for ( xx = width_org; xx > 0; xx-- ) 333 { 334 FT_UInt pixel = line[xx-1]; 335 336 337 end[-3] = (FT_Byte)pixel; 338 end[-2] = (FT_Byte)pixel; 339 end[-1] = (FT_Byte)pixel; 340 end -= 3; 341 } 342 } 343 } 344 345 /* expand it vertically */ 346 if ( vmul ) 347 { 348 FT_Byte* read = bitmap->buffer + ( height - height_org ) * pitch; 349 FT_Byte* write = bitmap->buffer; 350 FT_UInt hh; 351 352 353 for ( hh = height_org; hh > 0; hh-- ) 354 { 355 ft_memcpy( write, read, pitch ); 356 write += pitch; 357 358 ft_memcpy( write, read, pitch ); 359 write += pitch; 360 361 ft_memcpy( write, read, pitch ); 362 write += pitch; 363 read += pitch; 364 } 365 } 366 367#endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */ 368 369 /* 370 * XXX: on 16bit system, we return an error for huge bitmap 371 * to prevent an overflow. 372 */ 373 if ( x_left > FT_INT_MAX || y_top > FT_INT_MAX ) 374 { 375 error = FT_THROW( Invalid_Pixel_Size ); 376 goto Exit; 377 } 378 379 slot->format = FT_GLYPH_FORMAT_BITMAP; 380 slot->bitmap_left = (FT_Int)x_left; 381 slot->bitmap_top = (FT_Int)y_top; 382 383 /* everything is fine; don't deallocate buffer */ 384 have_buffer = FALSE; 385 386 error = FT_Err_Ok; 387 388 Exit: 389 if ( have_outline_shifted ) 390 FT_Outline_Translate( outline, x_shift, y_shift ); 391 if ( have_translated_origin ) 392 FT_Outline_Translate( outline, -origin->x, -origin->y ); 393 if ( have_buffer ) 394 { 395 FT_FREE( bitmap->buffer ); 396 slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP; 397 } 398 399 return error; 400 } 401 402 403 /* convert a slot's glyph image into a bitmap */ 404 static FT_Error 405 ft_smooth_render( FT_Renderer render, 406 FT_GlyphSlot slot, 407 FT_Render_Mode mode, 408 const FT_Vector* origin ) 409 { 410 if ( mode == FT_RENDER_MODE_LIGHT ) 411 mode = FT_RENDER_MODE_NORMAL; 412 413 return ft_smooth_render_generic( render, slot, mode, origin, 414 FT_RENDER_MODE_NORMAL ); 415 } 416 417 418 /* convert a slot's glyph image into a horizontal LCD bitmap */ 419 static FT_Error 420 ft_smooth_render_lcd( FT_Renderer render, 421 FT_GlyphSlot slot, 422 FT_Render_Mode mode, 423 const FT_Vector* origin ) 424 { 425 FT_Error error; 426 427 error = ft_smooth_render_generic( render, slot, mode, origin, 428 FT_RENDER_MODE_LCD ); 429 if ( !error ) 430 slot->bitmap.pixel_mode = FT_PIXEL_MODE_LCD; 431 432 return error; 433 } 434 435 436 /* convert a slot's glyph image into a vertical LCD bitmap */ 437 static FT_Error 438 ft_smooth_render_lcd_v( FT_Renderer render, 439 FT_GlyphSlot slot, 440 FT_Render_Mode mode, 441 const FT_Vector* origin ) 442 { 443 FT_Error error; 444 445 error = ft_smooth_render_generic( render, slot, mode, origin, 446 FT_RENDER_MODE_LCD_V ); 447 if ( !error ) 448 slot->bitmap.pixel_mode = FT_PIXEL_MODE_LCD_V; 449 450 return error; 451 } 452 453 454 FT_DEFINE_RENDERER( ft_smooth_renderer_class, 455 456 FT_MODULE_RENDERER, 457 sizeof ( FT_RendererRec ), 458 459 "smooth", 460 0x10000L, 461 0x20000L, 462 463 0, /* module specific interface */ 464 465 (FT_Module_Constructor)ft_smooth_init, 466 (FT_Module_Destructor) 0, 467 (FT_Module_Requester) 0 468 , 469 470 FT_GLYPH_FORMAT_OUTLINE, 471 472 (FT_Renderer_RenderFunc) ft_smooth_render, 473 (FT_Renderer_TransformFunc)ft_smooth_transform, 474 (FT_Renderer_GetCBoxFunc) ft_smooth_get_cbox, 475 (FT_Renderer_SetModeFunc) ft_smooth_set_mode, 476 477 (FT_Raster_Funcs*) &FT_GRAYS_RASTER_GET 478 ) 479 480 481 FT_DEFINE_RENDERER( ft_smooth_lcd_renderer_class, 482 483 FT_MODULE_RENDERER, 484 sizeof ( FT_RendererRec ), 485 486 "smooth-lcd", 487 0x10000L, 488 0x20000L, 489 490 0, /* module specific interface */ 491 492 (FT_Module_Constructor)ft_smooth_init, 493 (FT_Module_Destructor) 0, 494 (FT_Module_Requester) 0 495 , 496 497 FT_GLYPH_FORMAT_OUTLINE, 498 499 (FT_Renderer_RenderFunc) ft_smooth_render_lcd, 500 (FT_Renderer_TransformFunc)ft_smooth_transform, 501 (FT_Renderer_GetCBoxFunc) ft_smooth_get_cbox, 502 (FT_Renderer_SetModeFunc) ft_smooth_set_mode, 503 504 (FT_Raster_Funcs*) &FT_GRAYS_RASTER_GET 505 ) 506 507 FT_DEFINE_RENDERER( ft_smooth_lcdv_renderer_class, 508 509 FT_MODULE_RENDERER, 510 sizeof ( FT_RendererRec ), 511 512 "smooth-lcdv", 513 0x10000L, 514 0x20000L, 515 516 0, /* module specific interface */ 517 518 (FT_Module_Constructor)ft_smooth_init, 519 (FT_Module_Destructor) 0, 520 (FT_Module_Requester) 0 521 , 522 523 FT_GLYPH_FORMAT_OUTLINE, 524 525 (FT_Renderer_RenderFunc) ft_smooth_render_lcd_v, 526 (FT_Renderer_TransformFunc)ft_smooth_transform, 527 (FT_Renderer_GetCBoxFunc) ft_smooth_get_cbox, 528 (FT_Renderer_SetModeFunc) ft_smooth_set_mode, 529 530 (FT_Raster_Funcs*) &FT_GRAYS_RASTER_GET 531 ) 532 533 534/* END */ 535