XFA: merge patch from CL 815103002
[pdfium.git] / third_party / freetype / src / base / ftglyph.c
1 /***************************************************************************/
2 /*                                                                         */
3 /*  ftglyph.c                                                              */
4 /*                                                                         */
5 /*    FreeType convenience functions to handle glyphs (body).              */
6 /*                                                                         */
7 /*  Copyright 1996-2005, 2007, 2008, 2010, 2012-2014 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   /*                                                                       */
20   /*  This file contains the definition of several convenience functions   */
21   /*  that can be used by client applications to easily retrieve glyph     */
22   /*  bitmaps and outlines from a given face.                              */
23   /*                                                                       */
24   /*  These functions should be optional if you are writing a font server  */
25   /*  or text layout engine on top of FreeType.  However, they are pretty  */
26   /*  handy for many other simple uses of the library.                     */
27   /*                                                                       */
28   /*************************************************************************/
29
30
31 #include <ft2build.h>
32 #include FT_INTERNAL_DEBUG_H
33
34 #include FT_GLYPH_H
35 #include FT_OUTLINE_H
36 #include FT_BITMAP_H
37 #include FT_INTERNAL_OBJECTS_H
38
39 #include "basepic.h"
40
41   /*************************************************************************/
42   /*                                                                       */
43   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
44   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
45   /* messages during execution.                                            */
46   /*                                                                       */
47 #undef  FT_COMPONENT
48 #define FT_COMPONENT  trace_glyph
49
50
51   /*************************************************************************/
52   /*************************************************************************/
53   /****                                                                 ****/
54   /****   FT_BitmapGlyph support                                        ****/
55   /****                                                                 ****/
56   /*************************************************************************/
57   /*************************************************************************/
58
59   FT_CALLBACK_DEF( FT_Error )
60   ft_bitmap_glyph_init( FT_Glyph      bitmap_glyph,
61                         FT_GlyphSlot  slot )
62   {
63     FT_BitmapGlyph  glyph   = (FT_BitmapGlyph)bitmap_glyph;
64     FT_Error        error   = FT_Err_Ok;
65     FT_Library      library = FT_GLYPH( glyph )->library;
66
67
68     if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
69     {
70       error = FT_THROW( Invalid_Glyph_Format );
71       goto Exit;
72     }
73
74     glyph->left = slot->bitmap_left;
75     glyph->top  = slot->bitmap_top;
76
77     /* do lazy copying whenever possible */
78     if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
79     {
80       glyph->bitmap = slot->bitmap;
81       slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
82     }
83     else
84     {
85       FT_Bitmap_New( &glyph->bitmap );
86       error = FT_Bitmap_Copy( library, &slot->bitmap, &glyph->bitmap );
87     }
88
89   Exit:
90     return error;
91   }
92
93
94   FT_CALLBACK_DEF( FT_Error )
95   ft_bitmap_glyph_copy( FT_Glyph  bitmap_source,
96                         FT_Glyph  bitmap_target )
97   {
98     FT_Library      library = bitmap_source->library;
99     FT_BitmapGlyph  source  = (FT_BitmapGlyph)bitmap_source;
100     FT_BitmapGlyph  target  = (FT_BitmapGlyph)bitmap_target;
101
102
103     target->left = source->left;
104     target->top  = source->top;
105
106     return FT_Bitmap_Copy( library, &source->bitmap, &target->bitmap );
107   }
108
109
110   FT_CALLBACK_DEF( void )
111   ft_bitmap_glyph_done( FT_Glyph  bitmap_glyph )
112   {
113     FT_BitmapGlyph  glyph   = (FT_BitmapGlyph)bitmap_glyph;
114     FT_Library      library = FT_GLYPH( glyph )->library;
115
116
117     FT_Bitmap_Done( library, &glyph->bitmap );
118   }
119
120
121   FT_CALLBACK_DEF( void )
122   ft_bitmap_glyph_bbox( FT_Glyph  bitmap_glyph,
123                         FT_BBox*  cbox )
124   {
125     FT_BitmapGlyph  glyph = (FT_BitmapGlyph)bitmap_glyph;
126
127
128     cbox->xMin = glyph->left << 6;
129     cbox->xMax = cbox->xMin + ( glyph->bitmap.width << 6 );
130     cbox->yMax = glyph->top << 6;
131     cbox->yMin = cbox->yMax - ( glyph->bitmap.rows << 6 );
132   }
133
134
135   FT_DEFINE_GLYPH(ft_bitmap_glyph_class,
136     sizeof ( FT_BitmapGlyphRec ),
137     FT_GLYPH_FORMAT_BITMAP,
138
139     ft_bitmap_glyph_init,
140     ft_bitmap_glyph_done,
141     ft_bitmap_glyph_copy,
142     0,                          /* FT_Glyph_TransformFunc */
143     ft_bitmap_glyph_bbox,
144     0                           /* FT_Glyph_PrepareFunc   */
145   )
146
147
148   /*************************************************************************/
149   /*************************************************************************/
150   /****                                                                 ****/
151   /****   FT_OutlineGlyph support                                       ****/
152   /****                                                                 ****/
153   /*************************************************************************/
154   /*************************************************************************/
155
156
157   FT_CALLBACK_DEF( FT_Error )
158   ft_outline_glyph_init( FT_Glyph      outline_glyph,
159                          FT_GlyphSlot  slot )
160   {
161     FT_OutlineGlyph  glyph   = (FT_OutlineGlyph)outline_glyph;
162     FT_Error         error   = FT_Err_Ok;
163     FT_Library       library = FT_GLYPH( glyph )->library;
164     FT_Outline*      source  = &slot->outline;
165     FT_Outline*      target  = &glyph->outline;
166
167
168     /* check format in glyph slot */
169     if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )
170     {
171       error = FT_THROW( Invalid_Glyph_Format );
172       goto Exit;
173     }
174
175     /* allocate new outline */
176     error = FT_Outline_New( library, source->n_points, source->n_contours,
177                             &glyph->outline );
178     if ( error )
179       goto Exit;
180
181     FT_Outline_Copy( source, target );
182
183   Exit:
184     return error;
185   }
186
187
188   FT_CALLBACK_DEF( void )
189   ft_outline_glyph_done( FT_Glyph  outline_glyph )
190   {
191     FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
192
193
194     FT_Outline_Done( FT_GLYPH( glyph )->library, &glyph->outline );
195   }
196
197
198   FT_CALLBACK_DEF( FT_Error )
199   ft_outline_glyph_copy( FT_Glyph  outline_source,
200                          FT_Glyph  outline_target )
201   {
202     FT_OutlineGlyph  source  = (FT_OutlineGlyph)outline_source;
203     FT_OutlineGlyph  target  = (FT_OutlineGlyph)outline_target;
204     FT_Error         error;
205     FT_Library       library = FT_GLYPH( source )->library;
206
207
208     error = FT_Outline_New( library, source->outline.n_points,
209                             source->outline.n_contours, &target->outline );
210     if ( !error )
211       FT_Outline_Copy( &source->outline, &target->outline );
212
213     return error;
214   }
215
216
217   FT_CALLBACK_DEF( void )
218   ft_outline_glyph_transform( FT_Glyph          outline_glyph,
219                               const FT_Matrix*  matrix,
220                               const FT_Vector*  delta )
221   {
222     FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
223
224
225     if ( matrix )
226       FT_Outline_Transform( &glyph->outline, matrix );
227
228     if ( delta )
229       FT_Outline_Translate( &glyph->outline, delta->x, delta->y );
230   }
231
232
233   FT_CALLBACK_DEF( void )
234   ft_outline_glyph_bbox( FT_Glyph  outline_glyph,
235                          FT_BBox*  bbox )
236   {
237     FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
238
239
240     FT_Outline_Get_CBox( &glyph->outline, bbox );
241   }
242
243
244   FT_CALLBACK_DEF( FT_Error )
245   ft_outline_glyph_prepare( FT_Glyph      outline_glyph,
246                             FT_GlyphSlot  slot )
247   {
248     FT_OutlineGlyph  glyph = (FT_OutlineGlyph)outline_glyph;
249
250
251     slot->format         = FT_GLYPH_FORMAT_OUTLINE;
252     slot->outline        = glyph->outline;
253     slot->outline.flags &= ~FT_OUTLINE_OWNER;
254
255     return FT_Err_Ok;
256   }
257
258
259   FT_DEFINE_GLYPH( ft_outline_glyph_class,
260     sizeof ( FT_OutlineGlyphRec ),
261     FT_GLYPH_FORMAT_OUTLINE,
262
263     ft_outline_glyph_init,
264     ft_outline_glyph_done,
265     ft_outline_glyph_copy,
266     ft_outline_glyph_transform,
267     ft_outline_glyph_bbox,
268     ft_outline_glyph_prepare
269   )
270
271
272   /*************************************************************************/
273   /*************************************************************************/
274   /****                                                                 ****/
275   /****   FT_Glyph class and API                                        ****/
276   /****                                                                 ****/
277   /*************************************************************************/
278   /*************************************************************************/
279
280    static FT_Error
281    ft_new_glyph( FT_Library             library,
282                  const FT_Glyph_Class*  clazz,
283                  FT_Glyph*              aglyph )
284    {
285      FT_Memory  memory = library->memory;
286      FT_Error   error;
287      FT_Glyph   glyph  = NULL;
288
289
290      *aglyph = 0;
291
292      if ( !FT_ALLOC( glyph, clazz->glyph_size ) )
293      {
294        glyph->library = library;
295        glyph->clazz   = clazz;
296        glyph->format  = clazz->glyph_format;
297
298        *aglyph = glyph;
299      }
300
301      return error;
302    }
303
304
305   /* documentation is in ftglyph.h */
306
307   FT_EXPORT_DEF( FT_Error )
308   FT_Glyph_Copy( FT_Glyph   source,
309                  FT_Glyph  *target )
310   {
311     FT_Glyph               copy;
312     FT_Error               error;
313     const FT_Glyph_Class*  clazz;
314
315
316     /* check arguments */
317     if ( !target || !source || !source->clazz )
318     {
319       error = FT_THROW( Invalid_Argument );
320       goto Exit;
321     }
322
323     *target = NULL;
324
325     if ( !source || !source->clazz )
326     {
327       error = FT_THROW( Invalid_Argument );
328       goto Exit;
329     }
330
331     clazz = source->clazz;
332     error = ft_new_glyph( source->library, clazz, &copy );
333     if ( error )
334       goto Exit;
335
336     copy->advance = source->advance;
337     copy->format  = source->format;
338
339     if ( clazz->glyph_copy )
340       error = clazz->glyph_copy( source, copy );
341
342     if ( error )
343       FT_Done_Glyph( copy );
344     else
345       *target = copy;
346
347   Exit:
348     return error;
349   }
350
351
352   /* documentation is in ftglyph.h */
353
354   FT_EXPORT_DEF( FT_Error )
355   FT_Get_Glyph( FT_GlyphSlot  slot,
356                 FT_Glyph     *aglyph )
357   {
358     FT_Library  library;
359     FT_Error    error;
360     FT_Glyph    glyph;
361
362     const FT_Glyph_Class*  clazz = NULL;
363
364
365     if ( !slot )
366       return FT_THROW( Invalid_Slot_Handle );
367
368     library = slot->library;
369
370     if ( !aglyph )
371       return FT_THROW( Invalid_Argument );
372
373     /* if it is a bitmap, that's easy :-) */
374     if ( slot->format == FT_GLYPH_FORMAT_BITMAP )
375       clazz = FT_BITMAP_GLYPH_CLASS_GET;
376
377     /* if it is an outline */
378     else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
379       clazz = FT_OUTLINE_GLYPH_CLASS_GET;
380
381     else
382     {
383       /* try to find a renderer that supports the glyph image format */
384       FT_Renderer  render = FT_Lookup_Renderer( library, slot->format, 0 );
385
386
387       if ( render )
388         clazz = &render->glyph_class;
389     }
390
391     if ( !clazz )
392     {
393       error = FT_THROW( Invalid_Glyph_Format );
394       goto Exit;
395     }
396
397     /* create FT_Glyph object */
398     error = ft_new_glyph( library, clazz, &glyph );
399     if ( error )
400       goto Exit;
401
402     /* copy advance while converting it to 16.16 format */
403     glyph->advance.x = slot->advance.x << 10;
404     glyph->advance.y = slot->advance.y << 10;
405
406     /* now import the image from the glyph slot */
407     error = clazz->glyph_init( glyph, slot );
408
409     /* if an error occurred, destroy the glyph */
410     if ( error )
411       FT_Done_Glyph( glyph );
412     else
413       *aglyph = glyph;
414
415   Exit:
416     return error;
417   }
418
419
420   /* documentation is in ftglyph.h */
421
422   FT_EXPORT_DEF( FT_Error )
423   FT_Glyph_Transform( FT_Glyph    glyph,
424                       FT_Matrix*  matrix,
425                       FT_Vector*  delta )
426   {
427     FT_Error  error = FT_Err_Ok;
428
429
430     if ( !glyph || !glyph->clazz )
431       error = FT_THROW( Invalid_Argument );
432     else
433     {
434       const FT_Glyph_Class*  clazz = glyph->clazz;
435
436
437       if ( clazz->glyph_transform )
438       {
439         /* transform glyph image */
440         clazz->glyph_transform( glyph, matrix, delta );
441
442         /* transform advance vector */
443         if ( matrix )
444           FT_Vector_Transform( &glyph->advance, matrix );
445       }
446       else
447         error = FT_THROW( Invalid_Glyph_Format );
448     }
449     return error;
450   }
451
452
453   /* documentation is in ftglyph.h */
454
455   FT_EXPORT_DEF( void )
456   FT_Glyph_Get_CBox( FT_Glyph  glyph,
457                      FT_UInt   bbox_mode,
458                      FT_BBox  *acbox )
459   {
460     const FT_Glyph_Class*  clazz;
461
462
463     if ( !acbox )
464       return;
465
466     acbox->xMin = acbox->yMin = acbox->xMax = acbox->yMax = 0;
467
468     if ( !glyph || !glyph->clazz )
469       return;
470
471     clazz = glyph->clazz;
472     if ( !clazz->glyph_bbox )
473       return;
474
475     /* retrieve bbox in 26.6 coordinates */
476     clazz->glyph_bbox( glyph, acbox );
477
478     /* perform grid fitting if needed */
479     if ( bbox_mode == FT_GLYPH_BBOX_GRIDFIT ||
480          bbox_mode == FT_GLYPH_BBOX_PIXELS  )
481     {
482       acbox->xMin = FT_PIX_FLOOR( acbox->xMin );
483       acbox->yMin = FT_PIX_FLOOR( acbox->yMin );
484       acbox->xMax = FT_PIX_CEIL( acbox->xMax );
485       acbox->yMax = FT_PIX_CEIL( acbox->yMax );
486     }
487
488     /* convert to integer pixels if needed */
489     if ( bbox_mode == FT_GLYPH_BBOX_TRUNCATE ||
490          bbox_mode == FT_GLYPH_BBOX_PIXELS   )
491     {
492       acbox->xMin >>= 6;
493       acbox->yMin >>= 6;
494       acbox->xMax >>= 6;
495       acbox->yMax >>= 6;
496     }
497   }
498
499
500   /* documentation is in ftglyph.h */
501
502   FT_EXPORT_DEF( FT_Error )
503   FT_Glyph_To_Bitmap( FT_Glyph*       the_glyph,
504                       FT_Render_Mode  render_mode,
505                       FT_Vector*      origin,
506                       FT_Bool         destroy )
507   {
508     FT_GlyphSlotRec           dummy;
509     FT_GlyphSlot_InternalRec  dummy_internal;
510     FT_Error                  error = FT_Err_Ok;
511     FT_Glyph                  b, glyph;
512     FT_BitmapGlyph            bitmap = NULL;
513     const FT_Glyph_Class*     clazz;
514
515     /* FT_BITMAP_GLYPH_CLASS_GET dereferences `library' in PIC mode */
516     FT_Library                library;
517
518
519     /* check argument */
520     if ( !the_glyph )
521       goto Bad;
522     glyph = *the_glyph;
523     if ( !glyph )
524       goto Bad;
525
526     clazz   = glyph->clazz;
527     library = glyph->library;
528     if ( !library || !clazz )
529       goto Bad;
530
531     /* when called with a bitmap glyph, do nothing and return successfully */
532     if ( clazz == FT_BITMAP_GLYPH_CLASS_GET )
533       goto Exit;
534
535     if ( !clazz->glyph_prepare )
536       goto Bad;
537
538     /* we render the glyph into a glyph bitmap using a `dummy' glyph slot */
539     /* then calling FT_Render_Glyph_Internal()                            */
540
541     FT_MEM_ZERO( &dummy, sizeof ( dummy ) );
542     FT_MEM_ZERO( &dummy_internal, sizeof ( dummy_internal ) );
543     dummy.internal = &dummy_internal;
544     dummy.library  = library;
545     dummy.format   = clazz->glyph_format;
546
547     /* create result bitmap glyph */
548     error = ft_new_glyph( library, FT_BITMAP_GLYPH_CLASS_GET, &b );
549     if ( error )
550       goto Exit;
551     bitmap = (FT_BitmapGlyph)b;
552
553 #if 1
554     /* if `origin' is set, translate the glyph image */
555     if ( origin )
556       FT_Glyph_Transform( glyph, 0, origin );
557 #else
558     FT_UNUSED( origin );
559 #endif
560
561     /* prepare dummy slot for rendering */
562     error = clazz->glyph_prepare( glyph, &dummy );
563     if ( !error )
564       error = FT_Render_Glyph_Internal( glyph->library, &dummy, render_mode );
565
566 #if 1
567     if ( !destroy && origin )
568     {
569       FT_Vector  v;
570
571
572       v.x = -origin->x;
573       v.y = -origin->y;
574       FT_Glyph_Transform( glyph, 0, &v );
575     }
576 #endif
577
578     if ( error )
579       goto Exit;
580
581     /* in case of success, copy the bitmap to the glyph bitmap */
582     error = ft_bitmap_glyph_init( (FT_Glyph)bitmap, &dummy );
583     if ( error )
584       goto Exit;
585
586     /* copy advance */
587     bitmap->root.advance = glyph->advance;
588
589     if ( destroy )
590       FT_Done_Glyph( glyph );
591
592     *the_glyph = FT_GLYPH( bitmap );
593
594   Exit:
595     if ( error && bitmap )
596       FT_Done_Glyph( FT_GLYPH( bitmap ) );
597
598     return error;
599
600   Bad:
601     error = FT_THROW( Invalid_Argument );
602     goto Exit;
603   }
604
605
606   /* documentation is in ftglyph.h */
607
608   FT_EXPORT_DEF( void )
609   FT_Done_Glyph( FT_Glyph  glyph )
610   {
611     if ( glyph )
612     {
613       FT_Memory              memory = glyph->library->memory;
614       const FT_Glyph_Class*  clazz  = glyph->clazz;
615
616
617       if ( clazz->glyph_done )
618         clazz->glyph_done( glyph );
619
620       FT_FREE( glyph );
621     }
622   }
623
624
625 /* END */