?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Suggestion from "mgh".
[open-ps2-loader.git] / thirdparty / freetype-2.3.12 / src / smooth / ftsmooth.c
blobeed63531572b4798e7baec300a76c1aef6b409d3
1 /***************************************************************************/
2 /* */
3 /* ftsmooth.c */
4 /* */
5 /* Anti-aliasing renderer interface (body). */
6 /* */
7 /* Copyright 2000-2001, 2002, 2003, 2004, 2005, 2006, 2009 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_UInt width, height, height_org, width_org, pitch;
109 FT_Bitmap* bitmap;
110 FT_Memory memory;
111 FT_Int hmul = mode == FT_RENDER_MODE_LCD;
112 FT_Int vmul = mode == FT_RENDER_MODE_LCD_V;
113 FT_Pos x_shift, y_shift, x_left, y_top;
114
115 FT_Raster_Params params;
116
117
118 /* check glyph image format */
119 if ( slot->format != render->glyph_format )
120 {
121 error = Smooth_Err_Invalid_Argument;
122 goto Exit;
123 }
124
125 /* check mode */
126 if ( mode != required_mode )
127 return Smooth_Err_Cannot_Render_Glyph;
128
129 outline = &slot->outline;
130
131 /* translate the outline to the new origin if needed */
132 if ( origin )
133 FT_Outline_Translate( outline, origin->x, origin->y );
134
135 /* compute the control box, and grid fit it */
136 FT_Outline_Get_CBox( outline, &cbox );
137
138 cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
139 cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
140 cbox.xMax = FT_PIX_CEIL( cbox.xMax );
141 cbox.yMax = FT_PIX_CEIL( cbox.yMax );
142
143 width = (FT_UInt)( ( cbox.xMax - cbox.xMin ) >> 6 );
144 height = (FT_UInt)( ( cbox.yMax - cbox.yMin ) >> 6 );
145 bitmap = &slot->bitmap;
146 memory = render->root.memory;
147
148 width_org = width;
149 height_org = height;
150
151 /* release old bitmap buffer */
152 if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
153 {
154 FT_FREE( bitmap->buffer );
155 slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
156 }
157
158 /* allocate new one */
159 pitch = width;
160 if ( hmul )
161 {
162 width = width * 3;
163 pitch = FT_PAD_CEIL( width, 4 );
164 }
165
166 if ( vmul )
167 height *= 3;
168
169 x_shift = (FT_Int) cbox.xMin;
170 y_shift = (FT_Int) cbox.yMin;
171 x_left = (FT_Int)( cbox.xMin >> 6 );
172 y_top = (FT_Int)( cbox.yMax >> 6 );
173
174 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
175
176 if ( slot->library->lcd_filter_func )
177 {
178 FT_Int extra = slot->library->lcd_extra;
179
180
181 if ( hmul )
182 {
183 x_shift -= 64 * ( extra >> 1 );
184 width += 3 * extra;
185 pitch = FT_PAD_CEIL( width, 4 );
186 x_left -= extra >> 1;
187 }
188
189 if ( vmul )
190 {
191 y_shift -= 64 * ( extra >> 1 );
192 height += 3 * extra;
193 y_top += extra >> 1;
194 }
195 }
196
197 #endif
198
199 #if FT_UINT_MAX > 0xFFFFU
200
201 /* Required check is ( pitch * height < FT_ULONG_MAX ), */
202 /* but we care realistic cases only. Always pitch <= width. */
203 if ( width > 0xFFFFU || height > 0xFFFFU )
204 {
205 FT_ERROR(( "ft_smooth_render_generic: glyph too large: %d x %d\n",
206 width, height ));
207 return Smooth_Err_Raster_Overflow;
208 }
209
210 #endif
211
212 bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
213 bitmap->num_grays = 256;
214 bitmap->width = width;
215 bitmap->rows = height;
216 bitmap->pitch = pitch;
217
218 /* translate outline to render it into the bitmap */
219 FT_Outline_Translate( outline, -x_shift, -y_shift );
220
221 if ( FT_ALLOC( bitmap->buffer, (FT_ULong)pitch * height ) )
222 goto Exit;
223
224 slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
225
226 /* set up parameters */
227 params.target = bitmap;
228 params.source = outline;
229 params.flags = FT_RASTER_FLAG_AA;
230
231 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
232
233 /* implode outline if needed */
234 {
235 FT_Vector* points = outline->points;
236 FT_Vector* points_end = points + outline->n_points;
237 FT_Vector* vec;
238
239
240 if ( hmul )
241 for ( vec = points; vec < points_end; vec++ )
242 vec->x *= 3;
243
244 if ( vmul )
245 for ( vec = points; vec < points_end; vec++ )
246 vec->y *= 3;
247 }
248
249 /* render outline into the bitmap */
250 error = render->raster_render( render->raster, &params );
251
252 /* deflate outline if needed */
253 {
254 FT_Vector* points = outline->points;
255 FT_Vector* points_end = points + outline->n_points;
256 FT_Vector* vec;
257
258
259 if ( hmul )
260 for ( vec = points; vec < points_end; vec++ )
261 vec->x /= 3;
262
263 if ( vmul )
264 for ( vec = points; vec < points_end; vec++ )
265 vec->y /= 3;
266 }
267
268 if ( slot->library->lcd_filter_func )
269 slot->library->lcd_filter_func( bitmap, mode, slot->library );
270
271 #else /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
272
273 /* render outline into bitmap */
274 error = render->raster_render( render->raster, &params );
275
276 /* expand it horizontally */
277 if ( hmul )
278 {
279 FT_Byte* line = bitmap->buffer;
280 FT_UInt hh;
281
282
283 for ( hh = height_org; hh > 0; hh--, line += pitch )
284 {
285 FT_UInt xx;
286 FT_Byte* end = line + width;
287
288
289 for ( xx = width_org; xx > 0; xx-- )
290 {
291 FT_UInt pixel = line[xx-1];
292
293
294 end[-3] = (FT_Byte)pixel;
295 end[-2] = (FT_Byte)pixel;
296 end[-1] = (FT_Byte)pixel;
297 end -= 3;
298 }
299 }
300 }
301
302 /* expand it vertically */
303 if ( vmul )
304 {
305 FT_Byte* read = bitmap->buffer + ( height - height_org ) * pitch;
306 FT_Byte* write = bitmap->buffer;
307 FT_UInt hh;
308
309
310 for ( hh = height_org; hh > 0; hh-- )
311 {
312 ft_memcpy( write, read, pitch );
313 write += pitch;
314
315 ft_memcpy( write, read, pitch );
316 write += pitch;
317
318 ft_memcpy( write, read, pitch );
319 write += pitch;
320 read += pitch;
321 }
322 }
323
324 #endif /* !FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
325
326 FT_Outline_Translate( outline, x_shift, y_shift );
327
328 /*
329 * XXX: on 16bit system, we return an error for huge bitmap
330 * to prevent an overflow.
331 */
332 if ( x_left > FT_INT_MAX || y_top > FT_INT_MAX )
333 return Smooth_Err_Invalid_Pixel_Size;
334
335 if ( error )
336 goto Exit;
337
338 slot->format = FT_GLYPH_FORMAT_BITMAP;
339 slot->bitmap_left = (FT_Int)x_left;
340 slot->bitmap_top = (FT_Int)y_top;
341
342 Exit:
343 if ( outline && origin )
344 FT_Outline_Translate( outline, -origin->x, -origin->y );
345
346 return error;
347 }
348
349
350 /* convert a slot's glyph image into a bitmap */
351 static FT_Error
352 ft_smooth_render( FT_Renderer render,
353 FT_GlyphSlot slot,
354 FT_Render_Mode mode,
355 const FT_Vector* origin )
356 {
357 if ( mode == FT_RENDER_MODE_LIGHT )
358 mode = FT_RENDER_MODE_NORMAL;
359
360 return ft_smooth_render_generic( render, slot, mode, origin,
361 FT_RENDER_MODE_NORMAL );
362 }
363
364
365 /* convert a slot's glyph image into a horizontal LCD bitmap */
366 static FT_Error
367 ft_smooth_render_lcd( FT_Renderer render,
368 FT_GlyphSlot slot,
369 FT_Render_Mode mode,
370 const FT_Vector* origin )
371 {
372 FT_Error error;
373
374 error = ft_smooth_render_generic( render, slot, mode, origin,
375 FT_RENDER_MODE_LCD );
376 if ( !error )
377 slot->bitmap.pixel_mode = FT_PIXEL_MODE_LCD;
378
379 return error;
380 }
381
382
383 /* convert a slot's glyph image into a vertical LCD bitmap */
384 static FT_Error
385 ft_smooth_render_lcd_v( FT_Renderer render,
386 FT_GlyphSlot slot,
387 FT_Render_Mode mode,
388 const FT_Vector* origin )
389 {
390 FT_Error error;
391
392 error = ft_smooth_render_generic( render, slot, mode, origin,
393 FT_RENDER_MODE_LCD_V );
394 if ( !error )
395 slot->bitmap.pixel_mode = FT_PIXEL_MODE_LCD_V;
396
397 return error;
398 }
399
400
401 FT_DEFINE_RENDERER(ft_smooth_renderer_class,
402
403 FT_MODULE_RENDERER,
404 sizeof( FT_RendererRec ),
405
406 "smooth",
407 0x10000L,
408 0x20000L,
409
410 0, /* module specific interface */
411
412 (FT_Module_Constructor)ft_smooth_init,
413 (FT_Module_Destructor) 0,
414 (FT_Module_Requester) 0
415 ,
416
417 FT_GLYPH_FORMAT_OUTLINE,
418
419 (FT_Renderer_RenderFunc) ft_smooth_render,
420 (FT_Renderer_TransformFunc)ft_smooth_transform,
421 (FT_Renderer_GetCBoxFunc) ft_smooth_get_cbox,
422 (FT_Renderer_SetModeFunc) ft_smooth_set_mode,
423
424 (FT_Raster_Funcs*) &FT_GRAYS_RASTER_GET
425 )
426
427
428 FT_DEFINE_RENDERER(ft_smooth_lcd_renderer_class,
429
430 FT_MODULE_RENDERER,
431 sizeof( FT_RendererRec ),
432
433 "smooth-lcd",
434 0x10000L,
435 0x20000L,
436
437 0, /* module specific interface */
438
439 (FT_Module_Constructor)ft_smooth_init,
440 (FT_Module_Destructor) 0,
441 (FT_Module_Requester) 0
442 ,
443
444 FT_GLYPH_FORMAT_OUTLINE,
445
446 (FT_Renderer_RenderFunc) ft_smooth_render_lcd,
447 (FT_Renderer_TransformFunc)ft_smooth_transform,
448 (FT_Renderer_GetCBoxFunc) ft_smooth_get_cbox,
449 (FT_Renderer_SetModeFunc) ft_smooth_set_mode,
450
451 (FT_Raster_Funcs*) &FT_GRAYS_RASTER_GET
452 )
453
454 FT_DEFINE_RENDERER(ft_smooth_lcdv_renderer_class,
455
456 FT_MODULE_RENDERER,
457 sizeof( FT_RendererRec ),
458
459 "smooth-lcdv",
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_lcd_v,
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 /* END */
Open USB/SMB/HDD Game Loader for PS2/PS3