1 /***************************************************************************/
2 /* */
3 /* ftobjs.c */
4 /* */
5 /* The FreeType private base classes (body). */
6 /* */
7 /* Copyright 1996-2018 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_LIST_H
21 #include FT_OUTLINE_H
22 #include FT_FONT_FORMATS_H
23
24 #include FT_INTERNAL_VALIDATE_H
25 #include FT_INTERNAL_OBJECTS_H
26 #include FT_INTERNAL_DEBUG_H
27 #include FT_INTERNAL_RFORK_H
28 #include FT_INTERNAL_STREAM_H
29 #include FT_INTERNAL_SFNT_H /* for SFNT_Load_Table_Func */
30 #include FT_INTERNAL_POSTSCRIPT_AUX_H /* for PS_Driver */
31
32 #include FT_TRUETYPE_TABLES_H
33 #include FT_TRUETYPE_TAGS_H
34 #include FT_TRUETYPE_IDS_H
35
36 #include FT_SERVICE_PROPERTIES_H
37 #include FT_SERVICE_SFNT_H
38 #include FT_SERVICE_POSTSCRIPT_NAME_H
39 #include FT_SERVICE_GLYPH_DICT_H
40 #include FT_SERVICE_TT_CMAP_H
41 #include FT_SERVICE_KERNING_H
42 #include FT_SERVICE_TRUETYPE_ENGINE_H
43
44 #include FT_DRIVER_H
45
46 #ifdef FT_CONFIG_OPTION_MAC_FONTS
47 #include "ftbase.h"
48 #endif
49
50
51 #ifdef FT_DEBUG_LEVEL_TRACE
52
53 #include FT_BITMAP_H
54
55 #if defined( _MSC_VER ) /* Visual C++ (and Intel C++) */
56 /* We disable the warning `conversion from XXX to YYY, */
57 /* possible loss of data' in order to compile cleanly with */
58 /* the maximum level of warnings: `md5.c' is non-FreeType */
59 /* code, and it gets used during development builds only. */
60 #pragma warning( push )
61 #pragma warning( disable : 4244 )
62 #endif /* _MSC_VER */
63
64 /* It's easiest to include `md5.c' directly. However, since OpenSSL */
65 /* also provides the same functions, there might be conflicts if */
66 /* both FreeType and OpenSSL are built as static libraries. For */
67 /* this reason, we put the MD5 stuff into the `FT_' namespace. */
68 #define MD5_u32plus FT_MD5_u32plus
69 #define MD5_CTX FT_MD5_CTX
70 #define MD5_Init FT_MD5_Init
71 #define MD5_Update FT_MD5_Update
72 #define MD5_Final FT_MD5_Final
73
74 #undef HAVE_OPENSSL
75
76 #include "md5.c"
77
78 #if defined( _MSC_VER )
79 #pragma warning( pop )
80 #endif
81
82 #endif /* FT_DEBUG_LEVEL_TRACE */
83
84
85 #define GRID_FIT_METRICS
86
87
88 /* forward declaration */
89 static FT_Error
90 ft_open_face_internal( FT_Library library,
91 const FT_Open_Args* args,
92 FT_Long face_index,
93 FT_Face *aface,
94 FT_Bool test_mac_fonts );
95
96
97 FT_BASE_DEF( FT_Pointer )
98 ft_service_list_lookup( FT_ServiceDesc service_descriptors,
99 const char* service_id )
100 {
101 FT_Pointer result = NULL;
102 FT_ServiceDesc desc = service_descriptors;
103
104
105 if ( desc && service_id )
106 {
107 for ( ; desc->serv_id != NULL; desc++ )
108 {
109 if ( ft_strcmp( desc->serv_id, service_id ) == 0 )
110 {
111 result = (FT_Pointer)desc->serv_data;
112 break;
113 }
114 }
115 }
116
117 return result;
118 }
119
120
121 FT_BASE_DEF( void )
122 ft_validator_init( FT_Validator valid,
123 const FT_Byte* base,
124 const FT_Byte* limit,
125 FT_ValidationLevel level )
126 {
127 valid->base = base;
128 valid->limit = limit;
129 valid->level = level;
130 valid->error = FT_Err_Ok;
131 }
132
133
134 FT_BASE_DEF( FT_Int )
135 ft_validator_run( FT_Validator valid )
136 {
137 /* This function doesn't work! None should call it. */
138 FT_UNUSED( valid );
139
140 return -1;
141 }
142
143
144 FT_BASE_DEF( void )
145 ft_validator_error( FT_Validator valid,
146 FT_Error error )
147 {
148 /* since the cast below also disables the compiler's */
149 /* type check, we introduce a dummy variable, which */
150 /* will be optimized away */
151 volatile ft_jmp_buf* jump_buffer = &valid->jump_buffer;
152
153
154 valid->error = error;
155
156 /* throw away volatileness; use `jump_buffer' or the */
157 /* compiler may warn about an unused local variable */
158 ft_longjmp( *(ft_jmp_buf*) jump_buffer, 1 );
159 }
160
161
162 /*************************************************************************/
163 /*************************************************************************/
164 /*************************************************************************/
165 /**** ****/
166 /**** ****/
167 /**** S T R E A M ****/
168 /**** ****/
169 /**** ****/
170 /*************************************************************************/
171 /*************************************************************************/
172 /*************************************************************************/
173
174
175 /* create a new input stream from an FT_Open_Args structure */
176 /* */
177 FT_BASE_DEF( FT_Error )
178 FT_Stream_New( FT_Library library,
179 const FT_Open_Args* args,
180 FT_Stream *astream )
181 {
182 FT_Error error;
183 FT_Memory memory;
184 FT_Stream stream = NULL;
185
186
187 *astream = NULL;
188
189 if ( !library )
190 return FT_THROW( Invalid_Library_Handle );
191
192 if ( !args )
193 return FT_THROW( Invalid_Argument );
194
195 memory = library->memory;
196
197 if ( FT_NEW( stream ) )
198 goto Exit;
199
200 stream->memory = memory;
201
202 if ( args->flags & FT_OPEN_MEMORY )
203 {
204 /* create a memory-based stream */
205 FT_Stream_OpenMemory( stream,
206 (const FT_Byte*)args->memory_base,
207 (FT_ULong)args->memory_size );
208 }
209
210 #ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT
211
212 else if ( args->flags & FT_OPEN_PATHNAME )
213 {
214 /* create a normal system stream */
215 error = FT_Stream_Open( stream, args->pathname );
216 stream->pathname.pointer = args->pathname;
217 }
218 else if ( ( args->flags & FT_OPEN_STREAM ) && args->stream )
219 {
220 /* use an existing, user-provided stream */
221
222 /* in this case, we do not need to allocate a new stream object */
223 /* since the caller is responsible for closing it himself */
224 FT_FREE( stream );
225 stream = args->stream;
226 }
227
228 #endif
229
230 else
231 error = FT_THROW( Invalid_Argument );
232
233 if ( error )
234 FT_FREE( stream );
235 else
236 stream->memory = memory; /* just to be certain */
237
238 *astream = stream;
239
240 Exit:
241 return error;
242 }
243
244
245 FT_BASE_DEF( void )
246 FT_Stream_Free( FT_Stream stream,
247 FT_Int external )
248 {
249 if ( stream )
250 {
251 FT_Memory memory = stream->memory;
252
253
254 FT_Stream_Close( stream );
255
256 if ( !external )
257 FT_FREE( stream );
258 }
259 }
260
261
262 /*************************************************************************/
263 /* */
264 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
265 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
266 /* messages during execution. */
267 /* */
268 #undef FT_COMPONENT
269 #define FT_COMPONENT trace_objs
270
271
272 /*************************************************************************/
273 /*************************************************************************/
274 /*************************************************************************/
275 /**** ****/
276 /**** ****/
277 /**** FACE, SIZE & GLYPH SLOT OBJECTS ****/
278 /**** ****/
279 /**** ****/
280 /*************************************************************************/
281 /*************************************************************************/
282 /*************************************************************************/
283
284
285 static FT_Error
286 ft_glyphslot_init( FT_GlyphSlot slot )
287 {
288 FT_Driver driver = slot->face->driver;
289 FT_Driver_Class clazz = driver->clazz;
290 FT_Memory memory = driver->root.memory;
291 FT_Error error = FT_Err_Ok;
292 FT_Slot_Internal internal = NULL;
293
294
295 slot->library = driver->root.library;
296
297 if ( FT_NEW( internal ) )
298 goto Exit;
299
300 slot->internal = internal;
301
302 if ( FT_DRIVER_USES_OUTLINES( driver ) )
303 error = FT_GlyphLoader_New( memory, &internal->loader );
304
305 if ( !error && clazz->init_slot )
306 error = clazz->init_slot( slot );
307
308 Exit:
309 return error;
310 }
311
312
313 FT_BASE_DEF( void )
314 ft_glyphslot_free_bitmap( FT_GlyphSlot slot )
315 {
316 if ( slot->internal && ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
317 {
318 FT_Memory memory = FT_FACE_MEMORY( slot->face );
319
320
321 FT_FREE( slot->bitmap.buffer );
322 slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
323 }
324 else
325 {
326 /* assume that the bitmap buffer was stolen or not */
327 /* allocated from the heap */
328 slot->bitmap.buffer = NULL;
329 }
330 }
331
332
333 FT_BASE_DEF( void )
334 ft_glyphslot_preset_bitmap( FT_GlyphSlot slot,
335 FT_Render_Mode mode,
336 const FT_Vector* origin )
337 {
338 FT_Outline* outline = &slot->outline;
339 FT_Bitmap* bitmap = &slot->bitmap;
340
341 FT_Pixel_Mode pixel_mode;
342
343 FT_BBox cbox;
344 FT_Pos x_shift = 0;
345 FT_Pos y_shift = 0;
346 FT_Pos x_left, y_top;
347 FT_Pos width, height, pitch;
348
349
350 if ( slot->internal && ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
351 return;
352
353 if ( origin )
354 {
355 x_shift = origin->x;
356 y_shift = origin->y;
357 }
358
359 /* compute the control box, and grid-fit it, */
360 /* taking into account the origin shift */
361 FT_Outline_Get_CBox( outline, &cbox );
362
363 cbox.xMin += x_shift;
364 cbox.yMin += y_shift;
365 cbox.xMax += x_shift;
366 cbox.yMax += y_shift;
367
368 switch ( mode )
369 {
370 case FT_RENDER_MODE_MONO:
371 pixel_mode = FT_PIXEL_MODE_MONO;
372 #if 1
373 /* undocumented but confirmed: bbox values get rounded */
374 /* unless the rounded box can collapse for a narrow glyph */
375 if ( cbox.xMax - cbox.xMin < 64 )
376 {
377 cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
378 cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax );
379 }
380 else
381 {
382 cbox.xMin = FT_PIX_ROUND_LONG( cbox.xMin );
383 cbox.xMax = FT_PIX_ROUND_LONG( cbox.xMax );
384 }
385
386 if ( cbox.yMax - cbox.yMin < 64 )
387 {
388 cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
389 cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax );
390 }
391 else
392 {
393 cbox.yMin = FT_PIX_ROUND_LONG( cbox.yMin );
394 cbox.yMax = FT_PIX_ROUND_LONG( cbox.yMax );
395 }
396 #else
397 cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
398 cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
399 cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax );
400 cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax );
401 #endif
402 break;
403
404 case FT_RENDER_MODE_LCD:
405 pixel_mode = FT_PIXEL_MODE_LCD;
406 ft_lcd_padding( &cbox.xMin, &cbox.xMax, slot );
407 goto Round;
408
409 case FT_RENDER_MODE_LCD_V:
410 pixel_mode = FT_PIXEL_MODE_LCD_V;
411 ft_lcd_padding( &cbox.yMin, &cbox.yMax, slot );
412 goto Round;
413
414 case FT_RENDER_MODE_NORMAL:
415 case FT_RENDER_MODE_LIGHT:
416 default:
417 pixel_mode = FT_PIXEL_MODE_GRAY;
418 Round:
419 cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
420 cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
421 cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax );
422 cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax );
423 }
424
425 x_shift = SUB_LONG( x_shift, cbox.xMin );
426 y_shift = SUB_LONG( y_shift, cbox.yMin );
427
428 x_left = cbox.xMin >> 6;
429 y_top = cbox.yMax >> 6;
430
431 width = ( (FT_ULong)cbox.xMax - (FT_ULong)cbox.xMin ) >> 6;
432 height = ( (FT_ULong)cbox.yMax - (FT_ULong)cbox.yMin ) >> 6;
433
434 switch ( pixel_mode )
435 {
436 case FT_PIXEL_MODE_MONO:
437 pitch = ( ( width + 15 ) >> 4 ) << 1;
438 break;
439
440 case FT_PIXEL_MODE_LCD:
441 width *= 3;
442 pitch = FT_PAD_CEIL( width, 4 );
443 break;
444
445 case FT_PIXEL_MODE_LCD_V:
446 height *= 3;
447 /* fall through */
448
449 case FT_PIXEL_MODE_GRAY:
450 default:
451 pitch = width;
452 }
453
454 slot->bitmap_left = (FT_Int)x_left;
455 slot->bitmap_top = (FT_Int)y_top;
456
457 bitmap->pixel_mode = (unsigned char)pixel_mode;
458 bitmap->num_grays = 256;
459 bitmap->width = (unsigned int)width;
460 bitmap->rows = (unsigned int)height;
461 bitmap->pitch = pitch;
462 }
463
464
465 FT_BASE_DEF( void )
466 ft_glyphslot_set_bitmap( FT_GlyphSlot slot,
467 FT_Byte* buffer )
468 {
469 ft_glyphslot_free_bitmap( slot );
470
471 slot->bitmap.buffer = buffer;
472
473 FT_ASSERT( (slot->internal->flags & FT_GLYPH_OWN_BITMAP) == 0 );
474 }
475
476
477 FT_BASE_DEF( FT_Error )
478 ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot,
479 FT_ULong size )
480 {
481 FT_Memory memory = FT_FACE_MEMORY( slot->face );
482 FT_Error error;
483
484
485 if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP )
486 FT_FREE( slot->bitmap.buffer );
487 else
488 slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
489
490 (void)FT_ALLOC( slot->bitmap.buffer, size );
491 return error;
492 }
493
494
495 static void
496 ft_glyphslot_clear( FT_GlyphSlot slot )
497 {
498 /* free bitmap if needed */
499 ft_glyphslot_free_bitmap( slot );
500
501 /* clear all public fields in the glyph slot */
502 FT_ZERO( &slot->metrics );
503 FT_ZERO( &slot->outline );
504
505 slot->bitmap.width = 0;
506 slot->bitmap.rows = 0;
507 slot->bitmap.pitch = 0;
508 slot->bitmap.pixel_mode = 0;
509 /* `slot->bitmap.buffer' has been handled by ft_glyphslot_free_bitmap */
510
511 slot->bitmap_left = 0;
512 slot->bitmap_top = 0;
513 slot->num_subglyphs = 0;
514 slot->subglyphs = NULL;
515 slot->control_data = NULL;
516 slot->control_len = 0;
517 slot->other = NULL;
518 slot->format = FT_GLYPH_FORMAT_NONE;
519
520 slot->linearHoriAdvance = 0;
521 slot->linearVertAdvance = 0;
522 slot->lsb_delta = 0;
523 slot->rsb_delta = 0;
524 }
525
526
527 static void
528 ft_glyphslot_done( FT_GlyphSlot slot )
529 {
530 FT_Driver driver = slot->face->driver;
531 FT_Driver_Class clazz = driver->clazz;
532 FT_Memory memory = driver->root.memory;
533
534
535 if ( clazz->done_slot )
536 clazz->done_slot( slot );
537
538 /* free bitmap buffer if needed */
539 ft_glyphslot_free_bitmap( slot );
540
541 /* slot->internal might be NULL in out-of-memory situations */
542 if ( slot->internal )
543 {
544 /* free glyph loader */
545 if ( FT_DRIVER_USES_OUTLINES( driver ) )
546 {
547 FT_GlyphLoader_Done( slot->internal->loader );
548 slot->internal->loader = NULL;
549 }
550
551 FT_FREE( slot->internal );
552 }
553 }
554
555
556 /* documentation is in ftobjs.h */
557
558 FT_BASE_DEF( FT_Error )
559 FT_New_GlyphSlot( FT_Face face,
560 FT_GlyphSlot *aslot )
561 {
562 FT_Error error;
563 FT_Driver driver;
564 FT_Driver_Class clazz;
565 FT_Memory memory;
566 FT_GlyphSlot slot = NULL;
567
568
569 if ( !face )
570 return FT_THROW( Invalid_Face_Handle );
571
572 if ( !face->driver )
573 return FT_THROW( Invalid_Argument );
574
575 driver = face->driver;
576 clazz = driver->clazz;
577 memory = driver->root.memory;
578
579 FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" ));
580 if ( !FT_ALLOC( slot, clazz->slot_object_size ) )
581 {
582 slot->face = face;
583
584 error = ft_glyphslot_init( slot );
585 if ( error )
586 {
587 ft_glyphslot_done( slot );
588 FT_FREE( slot );
589 goto Exit;
590 }
591
592 slot->next = face->glyph;
593 face->glyph = slot;
594
595 if ( aslot )
596 *aslot = slot;
597 }
598 else if ( aslot )
599 *aslot = NULL;
600
601
602 Exit:
603 FT_TRACE4(( "FT_New_GlyphSlot: Return 0x%x\n", error ));
604
605 return error;
606 }
607
608
609 /* documentation is in ftobjs.h */
610
611 FT_BASE_DEF( void )
612 FT_Done_GlyphSlot( FT_GlyphSlot slot )
613 {
614 if ( slot )
615 {
616 FT_Driver driver = slot->face->driver;
617 FT_Memory memory = driver->root.memory;
618 FT_GlyphSlot prev;
619 FT_GlyphSlot cur;
620
621
622 /* Remove slot from its parent face's list */
623 prev = NULL;
624 cur = slot->face->glyph;
625
626 while ( cur )
627 {
628 if ( cur == slot )
629 {
630 if ( !prev )
631 slot->face->glyph = cur->next;
632 else
633 prev->next = cur->next;
634
635 /* finalize client-specific data */
636 if ( slot->generic.finalizer )
637 slot->generic.finalizer( slot );
638
639 ft_glyphslot_done( slot );
640 FT_FREE( slot );
641 break;
642 }
643 prev = cur;
644 cur = cur->next;
645 }
646 }
647 }
648
649
650 /* documentation is in freetype.h */
651
652 FT_EXPORT_DEF( void )
653 FT_Set_Transform( FT_Face face,
654 FT_Matrix* matrix,
655 FT_Vector* delta )
656 {
657 FT_Face_Internal internal;
658
659
660 if ( !face )
661 return;
662
663 internal = face->internal;
664
665 internal->transform_flags = 0;
666
667 if ( !matrix )
668 {
669 internal->transform_matrix.xx = 0x10000L;
670 internal->transform_matrix.xy = 0;
671 internal->transform_matrix.yx = 0;
672 internal->transform_matrix.yy = 0x10000L;
673
674 matrix = &internal->transform_matrix;
675 }
676 else
677 internal->transform_matrix = *matrix;
678
679 /* set transform_flags bit flag 0 if `matrix' isn't the identity */
680 if ( ( matrix->xy | matrix->yx ) ||
681 matrix->xx != 0x10000L ||
682 matrix->yy != 0x10000L )
683 internal->transform_flags |= 1;
684
685 if ( !delta )
686 {
687 internal->transform_delta.x = 0;
688 internal->transform_delta.y = 0;
689
690 delta = &internal->transform_delta;
691 }
692 else
693 internal->transform_delta = *delta;
694
695 /* set transform_flags bit flag 1 if `delta' isn't the null vector */
696 if ( delta->x | delta->y )
697 internal->transform_flags |= 2;
698 }
699
700
701 static FT_Renderer
702 ft_lookup_glyph_renderer( FT_GlyphSlot slot );
703
704
705 #ifdef GRID_FIT_METRICS
706 static void
707 ft_glyphslot_grid_fit_metrics( FT_GlyphSlot slot,
708 FT_Bool vertical )
709 {
710 FT_Glyph_Metrics* metrics = &slot->metrics;
711 FT_Pos right, bottom;
712
713
714 if ( vertical )
715 {
716 metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX );
717 metrics->horiBearingY = FT_PIX_CEIL_LONG( metrics->horiBearingY );
718
719 right = FT_PIX_CEIL_LONG( ADD_LONG( metrics->vertBearingX,
720 metrics->width ) );
721 bottom = FT_PIX_CEIL_LONG( ADD_LONG( metrics->vertBearingY,
722 metrics->height ) );
723
724 metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX );
725 metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY );
726
727 metrics->width = SUB_LONG( right,
728 metrics->vertBearingX );
729 metrics->height = SUB_LONG( bottom,
730 metrics->vertBearingY );
731 }
732 else
733 {
734 metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX );
735 metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY );
736
737 right = FT_PIX_CEIL_LONG( ADD_LONG( metrics->horiBearingX,
738 metrics->width ) );
739 bottom = FT_PIX_FLOOR( SUB_LONG( metrics->horiBearingY,
740 metrics->height ) );
741
742 metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX );
743 metrics->horiBearingY = FT_PIX_CEIL_LONG( metrics->horiBearingY );
744
745 metrics->width = SUB_LONG( right,
746 metrics->horiBearingX );
747 metrics->height = SUB_LONG( metrics->horiBearingY,
748 bottom );
749 }
750
751 metrics->horiAdvance = FT_PIX_ROUND_LONG( metrics->horiAdvance );
752 metrics->vertAdvance = FT_PIX_ROUND_LONG( metrics->vertAdvance );
753 }
754 #endif /* GRID_FIT_METRICS */
755
756
757 /* documentation is in freetype.h */
758
759 FT_EXPORT_DEF( FT_Error )
760 FT_Load_Glyph( FT_Face face,
761 FT_UInt glyph_index,
762 FT_Int32 load_flags )
763 {
764 FT_Error error;
765 FT_Driver driver;
766 FT_GlyphSlot slot;
767 FT_Library library;
768 FT_Bool autohint = FALSE;
769 FT_Module hinter;
770 TT_Face ttface = (TT_Face)face;
771
772
773 if ( !face || !face->size || !face->glyph )
774 return FT_THROW( Invalid_Face_Handle );
775
776 /* The validity test for `glyph_index' is performed by the */
777 /* font drivers. */
778
779 slot = face->glyph;
780 ft_glyphslot_clear( slot );
781
782 driver = face->driver;
783 library = driver->root.library;
784 hinter = library->auto_hinter;
785
786 /* resolve load flags dependencies */
787
788 if ( load_flags & FT_LOAD_NO_RECURSE )
789 load_flags |= FT_LOAD_NO_SCALE |
790 FT_LOAD_IGNORE_TRANSFORM;
791
792 if ( load_flags & FT_LOAD_NO_SCALE )
793 {
794 load_flags |= FT_LOAD_NO_HINTING |
795 FT_LOAD_NO_BITMAP;
796
797 load_flags &= ~FT_LOAD_RENDER;
798 }
799
800 if ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY )
801 load_flags &= ~FT_LOAD_RENDER;
802
803 /*
804 * Determine whether we need to auto-hint or not.
805 * The general rules are:
806 *
807 * - Do only auto-hinting if we have
808 *
809 * - a hinter module,
810 * - a scalable font format dealing with outlines,
811 * - not a tricky font, and
812 * - no transforms except simple slants and/or rotations by
813 * integer multiples of 90 degrees.
814 *
815 * - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't
816 * have a native font hinter.
817 *
818 * - Otherwise, auto-hint for LIGHT hinting mode or if there isn't
819 * any hinting bytecode in the TrueType/OpenType font.
820 *
821 * - Exception: The font is `tricky' and requires the native hinter to
822 * load properly.
823 */
824
825 if ( hinter &&
826 !( load_flags & FT_LOAD_NO_HINTING ) &&
827 !( load_flags & FT_LOAD_NO_AUTOHINT ) &&
828 FT_DRIVER_IS_SCALABLE( driver ) &&
829 FT_DRIVER_USES_OUTLINES( driver ) &&
830 !FT_IS_TRICKY( face ) &&
831 ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) ||
832 ( face->internal->transform_matrix.yx == 0 &&
833 face->internal->transform_matrix.xx != 0 ) ||
834 ( face->internal->transform_matrix.xx == 0 &&
835 face->internal->transform_matrix.yx != 0 ) ) )
836 {
837 if ( ( load_flags & FT_LOAD_FORCE_AUTOHINT ) ||
838 !FT_DRIVER_HAS_HINTER( driver ) )
839 autohint = TRUE;
840 else
841 {
842 FT_Render_Mode mode = FT_LOAD_TARGET_MODE( load_flags );
843 FT_Bool is_light_type1;
844
845
846 /* only the new Adobe engine (for both CFF and Type 1) is `light'; */
847 /* we use `strstr' to catch both `Type 1' and `CID Type 1' */
848 is_light_type1 =
849 ft_strstr( FT_Get_Font_Format( face ), "Type 1" ) != NULL &&
850 ((PS_Driver)driver)->hinting_engine == FT_HINTING_ADOBE;
851
852 /* the check for `num_locations' assures that we actually */
853 /* test for instructions in a TTF and not in a CFF-based OTF */
854 /* */
855 /* since `maxSizeOfInstructions' might be unreliable, we */
856 /* check the size of the `fpgm' and `prep' tables, too -- */
857 /* the assumption is that there don't exist real TTFs where */
858 /* both `fpgm' and `prep' tables are missing */
859 if ( ( mode == FT_RENDER_MODE_LIGHT &&
860 ( !FT_DRIVER_HINTS_LIGHTLY( driver ) &&
861 !is_light_type1 ) ) ||
862 ( FT_IS_SFNT( face ) &&
863 ttface->num_locations &&
864 ttface->max_profile.maxSizeOfInstructions == 0 &&
865 ttface->font_program_size == 0 &&
866 ttface->cvt_program_size == 0 ) )
867 autohint = TRUE;
868 }
869 }
870
871 if ( autohint )
872 {
873 FT_AutoHinter_Interface hinting;
874
875
876 /* try to load embedded bitmaps first if available */
877 /* */
878 /* XXX: This is really a temporary hack that should disappear */
879 /* promptly with FreeType 2.1! */
880 /* */
881 if ( FT_HAS_FIXED_SIZES( face ) &&
882 ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
883 {
884 error = driver->clazz->load_glyph( slot, face->size,
885 glyph_index,
886 load_flags | FT_LOAD_SBITS_ONLY );
887
888 if ( !error && slot->format == FT_GLYPH_FORMAT_BITMAP )
889 goto Load_Ok;
890 }
891
892 {
893 FT_Face_Internal internal = face->internal;
894 FT_Int transform_flags = internal->transform_flags;
895
896
897 /* since the auto-hinter calls FT_Load_Glyph by itself, */
898 /* make sure that glyphs aren't transformed */
899 internal->transform_flags = 0;
900
901 /* load auto-hinted outline */
902 hinting = (FT_AutoHinter_Interface)hinter->clazz->module_interface;
903
904 error = hinting->load_glyph( (FT_AutoHinter)hinter,
905 slot, face->size,
906 glyph_index, load_flags );
907
908 internal->transform_flags = transform_flags;
909 }
910 }
911 else
912 {
913 error = driver->clazz->load_glyph( slot,
914 face->size,
915 glyph_index,
916 load_flags );
917 if ( error )
918 goto Exit;
919
920 if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
921 {
922 /* check that the loaded outline is correct */
923 error = FT_Outline_Check( &slot->outline );
924 if ( error )
925 goto Exit;
926
927 #ifdef GRID_FIT_METRICS
928 if ( !( load_flags & FT_LOAD_NO_HINTING ) )
929 ft_glyphslot_grid_fit_metrics( slot,
930 FT_BOOL( load_flags & FT_LOAD_VERTICAL_LAYOUT ) );
931 #endif
932 }
933 }
934
935 Load_Ok:
936 /* compute the advance */
937 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
938 {
939 slot->advance.x = 0;
940 slot->advance.y = slot->metrics.vertAdvance;
941 }
942 else
943 {
944 slot->advance.x = slot->metrics.horiAdvance;
945 slot->advance.y = 0;
946 }
947
948 /* compute the linear advance in 16.16 pixels */
949 if ( ( load_flags & FT_LOAD_LINEAR_DESIGN ) == 0 &&
950 FT_IS_SCALABLE( face ) )
951 {
952 FT_Size_Metrics* metrics = &face->size->metrics;
953
954
955 /* it's tricky! */
956 slot->linearHoriAdvance = FT_MulDiv( slot->linearHoriAdvance,
957 metrics->x_scale, 64 );
958
959 slot->linearVertAdvance = FT_MulDiv( slot->linearVertAdvance,
960 metrics->y_scale, 64 );
961 }
962
963 if ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) == 0 )
964 {
965 FT_Face_Internal internal = face->internal;
966
967
968 /* now, transform the glyph image if needed */
969 if ( internal->transform_flags )
970 {
971 /* get renderer */
972 FT_Renderer renderer = ft_lookup_glyph_renderer( slot );
973
974
975 if ( renderer )
976 error = renderer->clazz->transform_glyph(
977 renderer, slot,
978 &internal->transform_matrix,
979 &internal->transform_delta );
980 else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
981 {
982 /* apply `standard' transformation if no renderer is available */
983 if ( internal->transform_flags & 1 )
984 FT_Outline_Transform( &slot->outline,
985 &internal->transform_matrix );
986
987 if ( internal->transform_flags & 2 )
988 FT_Outline_Translate( &slot->outline,
989 internal->transform_delta.x,
990 internal->transform_delta.y );
991 }
992
993 /* transform advance */
994 FT_Vector_Transform( &slot->advance, &internal->transform_matrix );
995 }
996 }
997
998 /* do we need to render the image or preset the bitmap now? */
999 if ( !error &&
1000 ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
1001 slot->format != FT_GLYPH_FORMAT_BITMAP &&
1002 slot->format != FT_GLYPH_FORMAT_COMPOSITE )
1003 {
1004 FT_Render_Mode mode = FT_LOAD_TARGET_MODE( load_flags );
1005
1006
1007 if ( mode == FT_RENDER_MODE_NORMAL &&
1008 load_flags & FT_LOAD_MONOCHROME )
1009 mode = FT_RENDER_MODE_MONO;
1010
1011 if ( load_flags & FT_LOAD_RENDER )
1012 error = FT_Render_Glyph( slot, mode );
1013 else
1014 ft_glyphslot_preset_bitmap( slot, mode, NULL );
1015 }
1016
1017 FT_TRACE5(( "FT_Load_Glyph: index %d, flags %x\n",
1018 glyph_index, load_flags ));
1019 FT_TRACE5(( " x advance: %f\n", slot->advance.x / 64.0 ));
1020 FT_TRACE5(( " y advance: %f\n", slot->advance.y / 64.0 ));
1021 FT_TRACE5(( " linear x advance: %f\n",
1022 slot->linearHoriAdvance / 65536.0 ));
1023 FT_TRACE5(( " linear y advance: %f\n",
1024 slot->linearVertAdvance / 65536.0 ));
1025 FT_TRACE5(( " bitmap %dx%d, mode %d\n",
1026 slot->bitmap.width, slot->bitmap.rows,
1027 slot->bitmap.pixel_mode ));
1028
1029 Exit:
1030 return error;
1031 }
1032
1033
1034 /* documentation is in freetype.h */
1035
1036 FT_EXPORT_DEF( FT_Error )
1037 FT_Load_Char( FT_Face face,
1038 FT_ULong char_code,
1039 FT_Int32 load_flags )
1040 {
1041 FT_UInt glyph_index;
1042
1043
1044 if ( !face )
1045 return FT_THROW( Invalid_Face_Handle );
1046
1047 glyph_index = (FT_UInt)char_code;
1048 if ( face->charmap )
1049 glyph_index = FT_Get_Char_Index( face, char_code );
1050
1051 return FT_Load_Glyph( face, glyph_index, load_flags );
1052 }
1053
1054
1055 /* destructor for sizes list */
1056 static void
1057 destroy_size( FT_Memory memory,
1058 FT_Size size,
1059 FT_Driver driver )
1060 {
1061 /* finalize client-specific data */
1062 if ( size->generic.finalizer )
1063 size->generic.finalizer( size );
1064
1065 /* finalize format-specific stuff */
1066 if ( driver->clazz->done_size )
1067 driver->clazz->done_size( size );
1068
1069 FT_FREE( size->internal );
1070 FT_FREE( size );
1071 }
1072
1073
1074 static void
1075 ft_cmap_done_internal( FT_CMap cmap );
1076
1077
1078 static void
1079 destroy_charmaps( FT_Face face,
1080 FT_Memory memory )
1081 {
1082 FT_Int n;
1083
1084
1085 if ( !face )
1086 return;
1087
1088 for ( n = 0; n < face->num_charmaps; n++ )
1089 {
1090 FT_CMap cmap = FT_CMAP( face->charmaps[n] );
1091
1092
1093 ft_cmap_done_internal( cmap );
1094
1095 face->charmaps[n] = NULL;
1096 }
1097
1098 FT_FREE( face->charmaps );
1099 face->num_charmaps = 0;
1100 }
1101
1102
1103 /* destructor for faces list */
1104 static void
1105 destroy_face( FT_Memory memory,
1106 FT_Face face,
1107 FT_Driver driver )
1108 {
1109 FT_Driver_Class clazz = driver->clazz;
1110
1111
1112 /* discard auto-hinting data */
1113 if ( face->autohint.finalizer )
1114 face->autohint.finalizer( face->autohint.data );
1115
1116 /* Discard glyph slots for this face. */
1117 /* Beware! FT_Done_GlyphSlot() changes the field `face->glyph' */
1118 while ( face->glyph )
1119 FT_Done_GlyphSlot( face->glyph );
1120
1121 /* discard all sizes for this face */
1122 FT_List_Finalize( &face->sizes_list,
1123 (FT_List_Destructor)destroy_size,
1124 memory,
1125 driver );
1126 face->size = NULL;
1127
1128 /* now discard client data */
1129 if ( face->generic.finalizer )
1130 face->generic.finalizer( face );
1131
1132 /* discard charmaps */
1133 destroy_charmaps( face, memory );
1134
1135 /* finalize format-specific stuff */
1136 if ( clazz->done_face )
1137 clazz->done_face( face );
1138
1139 /* close the stream for this face if needed */
1140 FT_Stream_Free(
1141 face->stream,
1142 ( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );
1143
1144 face->stream = NULL;
1145
1146 /* get rid of it */
1147 if ( face->internal )
1148 {
1149 FT_FREE( face->internal );
1150 }
1151 FT_FREE( face );
1152 }
1153
1154
1155 static void
1156 Destroy_Driver( FT_Driver driver )
1157 {
1158 FT_List_Finalize( &driver->faces_list,
1159 (FT_List_Destructor)destroy_face,
1160 driver->root.memory,
1161 driver );
1162 }
1163
1164
1165 /*************************************************************************/
1166 /* */
1167 /* <Function> */
1168 /* find_unicode_charmap */
1169 /* */
1170 /* <Description> */
1171 /* This function finds a Unicode charmap, if there is one. */
1172 /* And if there is more than one, it tries to favour the more */
1173 /* extensive one, i.e., one that supports UCS-4 against those which */
1174 /* are limited to the BMP (said UCS-2 encoding.) */
1175 /* */
1176 /* This function is called from open_face() (just below), and also */
1177 /* from FT_Select_Charmap( ..., FT_ENCODING_UNICODE ). */
1178 /* */
1179 static FT_Error
1180 find_unicode_charmap( FT_Face face )
1181 {
1182 FT_CharMap* first;
1183 FT_CharMap* cur;
1184
1185
1186 /* caller should have already checked that `face' is valid */
1187 FT_ASSERT( face );
1188
1189 first = face->charmaps;
1190
1191 if ( !first )
1192 return FT_THROW( Invalid_CharMap_Handle );
1193
1194 /*
1195 * The original TrueType specification(s) only specified charmap
1196 * formats that are capable of mapping 8 or 16 bit character codes to
1197 * glyph indices.
1198 *
1199 * However, recent updates to the Apple and OpenType specifications
1200 * introduced new formats that are capable of mapping 32-bit character
1201 * codes as well. And these are already used on some fonts, mainly to
1202 * map non-BMP Asian ideographs as defined in Unicode.
1203 *
1204 * For compatibility purposes, these fonts generally come with
1205 * *several* Unicode charmaps:
1206 *
1207 * - One of them in the "old" 16-bit format, that cannot access
1208 * all glyphs in the font.
1209 *
1210 * - Another one in the "new" 32-bit format, that can access all
1211 * the glyphs.
1212 *
1213 * This function has been written to always favor a 32-bit charmap
1214 * when found. Otherwise, a 16-bit one is returned when found.
1215 */
1216
1217 /* Since the `interesting' table, with IDs (3,10), is normally the */
1218 /* last one, we loop backwards. This loses with type1 fonts with */
1219 /* non-BMP characters (<.0001%), this wins with .ttf with non-BMP */
1220 /* chars (.01% ?), and this is the same about 99.99% of the time! */
1221
1222 cur = first + face->num_charmaps; /* points after the last one */
1223
1224 for ( ; --cur >= first; )
1225 {
1226 if ( cur[0]->encoding == FT_ENCODING_UNICODE )
1227 {
1228 /* XXX If some new encodings to represent UCS-4 are added, */
1229 /* they should be added here. */
1230 if ( ( cur[0]->platform_id == TT_PLATFORM_MICROSOFT &&
1231 cur[0]->encoding_id == TT_MS_ID_UCS_4 ) ||
1232 ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE &&
1233 cur[0]->encoding_id == TT_APPLE_ID_UNICODE_32 ) )
1234 {
1235 face->charmap = cur[0];
1236 return FT_Err_Ok;
1237 }
1238 }
1239 }
1240
1241 /* We do not have any UCS-4 charmap. */
1242 /* Do the loop again and search for UCS-2 charmaps. */
1243 cur = first + face->num_charmaps;
1244
1245 for ( ; --cur >= first; )
1246 {
1247 if ( cur[0]->encoding == FT_ENCODING_UNICODE )
1248 {
1249 face->charmap = cur[0];
1250 return FT_Err_Ok;
1251 }
1252 }
1253
1254 return FT_THROW( Invalid_CharMap_Handle );
1255 }
1256
1257
1258 /*************************************************************************/
1259 /* */
1260 /* <Function> */
1261 /* find_variant_selector_charmap */
1262 /* */
1263 /* <Description> */
1264 /* This function finds the variant selector charmap, if there is one. */
1265 /* There can only be one (platform=0, specific=5, format=14). */
1266 /* */
1267 static FT_CharMap
1268 find_variant_selector_charmap( FT_Face face )
1269 {
1270 FT_CharMap* first;
1271 FT_CharMap* end;
1272 FT_CharMap* cur;
1273
1274
1275 /* caller should have already checked that `face' is valid */
1276 FT_ASSERT( face );
1277
1278 first = face->charmaps;
1279
1280 if ( !first )
1281 return NULL;
1282
1283 end = first + face->num_charmaps; /* points after the last one */
1284
1285 for ( cur = first; cur < end; cur++ )
1286 {
1287 if ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE &&
1288 cur[0]->encoding_id == TT_APPLE_ID_VARIANT_SELECTOR &&
1289 FT_Get_CMap_Format( cur[0] ) == 14 )
1290 return cur[0];
1291 }
1292
1293 return NULL;
1294 }
1295
1296
1297 /*************************************************************************/
1298 /* */
1299 /* <Function> */
1300 /* open_face */
1301 /* */
1302 /* <Description> */
1303 /* This function does some work for FT_Open_Face(). */
1304 /* */
1305 static FT_Error
1306 open_face( FT_Driver driver,
1307 FT_Stream *astream,
1308 FT_Bool external_stream,
1309 FT_Long face_index,
1310 FT_Int num_params,
1311 FT_Parameter* params,
1312 FT_Face *aface )
1313 {
1314 FT_Memory memory;
1315 FT_Driver_Class clazz;
1316 FT_Face face = NULL;
1317 FT_Face_Internal internal = NULL;
1318
1319 FT_Error error, error2;
1320
1321
1322 clazz = driver->clazz;
1323 memory = driver->root.memory;
1324
1325 /* allocate the face object and perform basic initialization */
1326 if ( FT_ALLOC( face, clazz->face_object_size ) )
1327 goto Fail;
1328
1329 face->driver = driver;
1330 face->memory = memory;
1331 face->stream = *astream;
1332
1333 /* set the FT_FACE_FLAG_EXTERNAL_STREAM bit for FT_Done_Face */
1334 if ( external_stream )
1335 face->face_flags |= FT_FACE_FLAG_EXTERNAL_STREAM;
1336
1337 if ( FT_NEW( internal ) )
1338 goto Fail;
1339
1340 face->internal = internal;
1341
1342 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1343 {
1344 int i;
1345
1346
1347 face->internal->incremental_interface = NULL;
1348 for ( i = 0; i < num_params && !face->internal->incremental_interface;
1349 i++ )
1350 if ( params[i].tag == FT_PARAM_TAG_INCREMENTAL )
1351 face->internal->incremental_interface =
1352 (FT_Incremental_Interface)params[i].data;
1353 }
1354 #endif
1355
1356 face->internal->random_seed = -1;
1357
1358 if ( clazz->init_face )
1359 error = clazz->init_face( *astream,
1360 face,
1361 (FT_Int)face_index,
1362 num_params,
1363 params );
1364 *astream = face->stream; /* Stream may have been changed. */
1365 if ( error )
1366 goto Fail;
1367
1368 /* select Unicode charmap by default */
1369 error2 = find_unicode_charmap( face );
1370
1371 /* if no Unicode charmap can be found, FT_Err_Invalid_CharMap_Handle */
1372 /* is returned. */
1373
1374 /* no error should happen, but we want to play safe */
1375 if ( error2 && FT_ERR_NEQ( error2, Invalid_CharMap_Handle ) )
1376 {
1377 error = error2;
1378 goto Fail;
1379 }
1380
1381 *aface = face;
1382
1383 Fail:
1384 if ( error )
1385 {
1386 destroy_charmaps( face, memory );
1387 if ( clazz->done_face )
1388 clazz->done_face( face );
1389 FT_FREE( internal );
1390 FT_FREE( face );
1391 *aface = NULL;
1392 }
1393
1394 return error;
1395 }
1396
1397
1398 /* there's a Mac-specific extended implementation of FT_New_Face() */
1399 /* in src/base/ftmac.c */
1400
1401 #ifndef FT_MACINTOSH
1402
1403 /* documentation is in freetype.h */
1404
1405 FT_EXPORT_DEF( FT_Error )
1406 FT_New_Face( FT_Library library,
1407 const char* pathname,
1408 FT_Long face_index,
1409 FT_Face *aface )
1410 {
1411 FT_Open_Args args;
1412
1413
1414 /* test for valid `library' and `aface' delayed to `FT_Open_Face' */
1415 if ( !pathname )
1416 return FT_THROW( Invalid_Argument );
1417
1418 args.flags = FT_OPEN_PATHNAME;
1419 args.pathname = (char*)pathname;
1420 args.stream = NULL;
1421
1422 return ft_open_face_internal( library, &args, face_index, aface, 1 );
1423 }
1424
1425 #endif
1426
1427
1428 /* documentation is in freetype.h */
1429
1430 FT_EXPORT_DEF( FT_Error )
1431 FT_New_Memory_Face( FT_Library library,
1432 const FT_Byte* file_base,
1433 FT_Long file_size,
1434 FT_Long face_index,
1435 FT_Face *aface )
1436 {
1437 FT_Open_Args args;
1438
1439
1440 /* test for valid `library' and `face' delayed to `FT_Open_Face' */
1441 if ( !file_base )
1442 return FT_THROW( Invalid_Argument );
1443
1444 args.flags = FT_OPEN_MEMORY;
1445 args.memory_base = file_base;
1446 args.memory_size = file_size;
1447 args.stream = NULL;
1448
1449 return ft_open_face_internal( library, &args, face_index, aface, 1 );
1450 }
1451
1452
1453 #ifdef FT_CONFIG_OPTION_MAC_FONTS
1454
1455 /* The behavior here is very similar to that in base/ftmac.c, but it */
1456 /* is designed to work on non-mac systems, so no mac specific calls. */
1457 /* */
1458 /* We look at the file and determine if it is a mac dfont file or a mac */
1459 /* resource file, or a macbinary file containing a mac resource file. */
1460 /* */
1461 /* Unlike ftmac I'm not going to look at a `FOND'. I don't really see */
1462 /* the point, especially since there may be multiple `FOND' resources. */
1463 /* Instead I'll just look for `sfnt' and `POST' resources, ordered as */
1464 /* they occur in the file. */
1465 /* */
1466 /* Note that multiple `POST' resources do not mean multiple postscript */
1467 /* fonts; they all get jammed together to make what is essentially a */
1468 /* pfb file. */
1469 /* */
1470 /* We aren't interested in `NFNT' or `FONT' bitmap resources. */
1471 /* */
1472 /* As soon as we get an `sfnt' load it into memory and pass it off to */
1473 /* FT_Open_Face. */
1474 /* */
1475 /* If we have a (set of) `POST' resources, massage them into a (memory) */
1476 /* pfb file and pass that to FT_Open_Face. (As with ftmac.c I'm not */
1477 /* going to try to save the kerning info. After all that lives in the */
1478 /* `FOND' which isn't in the file containing the `POST' resources so */
1479 /* we don't really have access to it. */
1480
1481
1482 /* Finalizer for a memory stream; gets called by FT_Done_Face(). */
1483 /* It frees the memory it uses. */
1484 /* From `ftmac.c'. */
1485 static void
1486 memory_stream_close( FT_Stream stream )
1487 {
1488 FT_Memory memory = stream->memory;
1489
1490
1491 FT_FREE( stream->base );
1492
1493 stream->size = 0;
1494 stream->base = NULL;
1495 stream->close = NULL;
1496 }
1497
1498
1499 /* Create a new memory stream from a buffer and a size. */
1500 /* From `ftmac.c'. */
1501 static FT_Error
1502 new_memory_stream( FT_Library library,
1503 FT_Byte* base,
1504 FT_ULong size,
1505 FT_Stream_CloseFunc close,
1506 FT_Stream *astream )
1507 {
1508 FT_Error error;
1509 FT_Memory memory;
1510 FT_Stream stream = NULL;
1511
1512
1513 if ( !library )
1514 return FT_THROW( Invalid_Library_Handle );
1515
1516 if ( !base )
1517 return FT_THROW( Invalid_Argument );
1518
1519 *astream = NULL;
1520 memory = library->memory;
1521 if ( FT_NEW( stream ) )
1522 goto Exit;
1523
1524 FT_Stream_OpenMemory( stream, base, size );
1525
1526 stream->close = close;
1527
1528 *astream = stream;
1529
1530 Exit:
1531 return error;
1532 }
1533
1534
1535 /* Create a new FT_Face given a buffer and a driver name. */
1536 /* From `ftmac.c'. */
1537 FT_LOCAL_DEF( FT_Error )
1538 open_face_from_buffer( FT_Library library,
1539 FT_Byte* base,
1540 FT_ULong size,
1541 FT_Long face_index,
1542 const char* driver_name,
1543 FT_Face *aface )
1544 {
1545 FT_Open_Args args;
1546 FT_Error error;
1547 FT_Stream stream = NULL;
1548 FT_Memory memory = library->memory;
1549
1550
1551 error = new_memory_stream( library,
1552 base,
1553 size,
1554 memory_stream_close,
1555 &stream );
1556 if ( error )
1557 {
1558 FT_FREE( base );
1559 return error;
1560 }
1561
1562 args.flags = FT_OPEN_STREAM;
1563 args.stream = stream;
1564 if ( driver_name )
1565 {
1566 args.flags = args.flags | FT_OPEN_DRIVER;
1567 args.driver = FT_Get_Module( library, driver_name );
1568 }
1569
1570 #ifdef FT_MACINTOSH
1571 /* At this point, the face index has served its purpose; */
1572 /* whoever calls this function has already used it to */
1573 /* locate the correct font data. We should not propagate */
1574 /* this index to FT_Open_Face() (unless it is negative). */
1575
1576 if ( face_index > 0 )
1577 face_index &= 0x7FFF0000L; /* retain GX data */
1578 #endif
1579
1580 error = ft_open_face_internal( library, &args, face_index, aface, 0 );
1581
1582 if ( !error )
1583 (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
1584 else
1585 #ifdef FT_MACINTOSH
1586 FT_Stream_Free( stream, 0 );
1587 #else
1588 {
1589 FT_Stream_Close( stream );
1590 FT_FREE( stream );
1591 }
1592 #endif
1593
1594 return error;
1595 }
1596
1597
1598 /* Look up `TYP1' or `CID ' table from sfnt table directory. */
1599 /* `offset' and `length' must exclude the binary header in tables. */
1600
1601 /* Type 1 and CID-keyed font drivers should recognize sfnt-wrapped */
1602 /* format too. Here, since we can't expect that the TrueType font */
1603 /* driver is loaded unconditionally, we must parse the font by */
1604 /* ourselves. We are only interested in the name of the table and */
1605 /* the offset. */
1606
1607 static FT_Error
1608 ft_lookup_PS_in_sfnt_stream( FT_Stream stream,
1609 FT_Long face_index,
1610 FT_ULong* offset,
1611 FT_ULong* length,
1612 FT_Bool* is_sfnt_cid )
1613 {
1614 FT_Error error;
1615 FT_UShort numTables;
1616 FT_Long pstable_index;
1617 FT_ULong tag;
1618 int i;
1619
1620
1621 *offset = 0;
1622 *length = 0;
1623 *is_sfnt_cid = FALSE;
1624
1625 /* TODO: support for sfnt-wrapped PS/CID in TTC format */
1626
1627 /* version check for 'typ1' (should be ignored?) */
1628 if ( FT_READ_ULONG( tag ) )
1629 return error;
1630 if ( tag != TTAG_typ1 )
1631 return FT_THROW( Unknown_File_Format );
1632
1633 if ( FT_READ_USHORT( numTables ) )
1634 return error;
1635 if ( FT_STREAM_SKIP( 2 * 3 ) ) /* skip binary search header */
1636 return error;
1637
1638 pstable_index = -1;
1639 *is_sfnt_cid = FALSE;
1640
1641 for ( i = 0; i < numTables; i++ )
1642 {
1643 if ( FT_READ_ULONG( tag ) || FT_STREAM_SKIP( 4 ) ||
1644 FT_READ_ULONG( *offset ) || FT_READ_ULONG( *length ) )
1645 return error;
1646
1647 if ( tag == TTAG_CID )
1648 {
1649 pstable_index++;
1650 *offset += 22;
1651 *length -= 22;
1652 *is_sfnt_cid = TRUE;
1653 if ( face_index < 0 )
1654 return FT_Err_Ok;
1655 }
1656 else if ( tag == TTAG_TYP1 )
1657 {
1658 pstable_index++;
1659 *offset += 24;
1660 *length -= 24;
1661 *is_sfnt_cid = FALSE;
1662 if ( face_index < 0 )
1663 return FT_Err_Ok;
1664 }
1665 if ( face_index >= 0 && pstable_index == face_index )
1666 return FT_Err_Ok;
1667 }
1668
1669 return FT_THROW( Table_Missing );
1670 }
1671
1672
1673 FT_LOCAL_DEF( FT_Error )
1674 open_face_PS_from_sfnt_stream( FT_Library library,
1675 FT_Stream stream,
1676 FT_Long face_index,
1677 FT_Int num_params,
1678 FT_Parameter *params,
1679 FT_Face *aface )
1680 {
1681 FT_Error error;
1682 FT_Memory memory = library->memory;
1683 FT_ULong offset, length;
1684 FT_ULong pos;
1685 FT_Bool is_sfnt_cid;
1686 FT_Byte* sfnt_ps = NULL;
1687
1688 FT_UNUSED( num_params );
1689 FT_UNUSED( params );
1690
1691
1692 /* ignore GX stuff */
1693 if ( face_index > 0 )
1694 face_index &= 0xFFFFL;
1695
1696 pos = FT_STREAM_POS();
1697
1698 error = ft_lookup_PS_in_sfnt_stream( stream,
1699 face_index,
1700 &offset,
1701 &length,
1702 &is_sfnt_cid );
1703 if ( error )
1704 goto Exit;
1705
1706 if ( offset > stream->size )
1707 {
1708 FT_TRACE2(( "open_face_PS_from_sfnt_stream: invalid table offset\n" ));
1709 error = FT_THROW( Invalid_Table );
1710 goto Exit;
1711 }
1712 else if ( length > stream->size - offset )
1713 {
1714 FT_TRACE2(( "open_face_PS_from_sfnt_stream: invalid table length\n" ));
1715 error = FT_THROW( Invalid_Table );
1716 goto Exit;
1717 }
1718
1719 error = FT_Stream_Seek( stream, pos + offset );
1720 if ( error )
1721 goto Exit;
1722
1723 if ( FT_ALLOC( sfnt_ps, (FT_Long)length ) )
1724 goto Exit;
1725
1726 error = FT_Stream_Read( stream, (FT_Byte *)sfnt_ps, length );
1727 if ( error )
1728 {
1729 FT_FREE( sfnt_ps );
1730 goto Exit;
1731 }
1732
1733 error = open_face_from_buffer( library,
1734 sfnt_ps,
1735 length,
1736 FT_MIN( face_index, 0 ),
1737 is_sfnt_cid ? "cid" : "type1",
1738 aface );
1739 Exit:
1740 {
1741 FT_Error error1;
1742
1743
1744 if ( FT_ERR_EQ( error, Unknown_File_Format ) )
1745 {
1746 error1 = FT_Stream_Seek( stream, pos );
1747 if ( error1 )
1748 return error1;
1749 }
1750
1751 return error;
1752 }
1753 }
1754
1755
1756 #ifndef FT_MACINTOSH
1757
1758 /* The resource header says we've got resource_cnt `POST' (type1) */
1759 /* resources in this file. They all need to be coalesced into */
1760 /* one lump which gets passed on to the type1 driver. */
1761 /* Here can be only one PostScript font in a file so face_index */
1762 /* must be 0 (or -1). */
1763 /* */
1764 static FT_Error
1765 Mac_Read_POST_Resource( FT_Library library,
1766 FT_Stream stream,
1767 FT_Long *offsets,
1768 FT_Long resource_cnt,
1769 FT_Long face_index,
1770 FT_Face *aface )
1771 {
1772 FT_Error error = FT_ERR( Cannot_Open_Resource );
1773 FT_Memory memory = library->memory;
1774
1775 FT_Byte* pfb_data = NULL;
1776 int i, type, flags;
1777 FT_ULong len;
1778 FT_ULong pfb_len, pfb_pos, pfb_lenpos;
1779 FT_ULong rlen, temp;
1780
1781
1782 if ( face_index == -1 )
1783 face_index = 0;
1784 if ( face_index != 0 )
1785 return error;
1786
1787 /* Find the length of all the POST resources, concatenated. Assume */
1788 /* worst case (each resource in its own section). */
1789 pfb_len = 0;
1790 for ( i = 0; i < resource_cnt; i++ )
1791 {
1792 error = FT_Stream_Seek( stream, (FT_ULong)offsets[i] );
1793 if ( error )
1794 goto Exit;
1795 if ( FT_READ_ULONG( temp ) ) /* actually LONG */
1796 goto Exit;
1797
1798 /* FT2 allocator takes signed long buffer length,
1799 * too large value causing overflow should be checked
1800 */
1801 FT_TRACE4(( " POST fragment #%d: length=0x%08x"
1802 " total pfb_len=0x%08x\n",
1803 i, temp, pfb_len + temp + 6 ));
1804
1805 if ( FT_MAC_RFORK_MAX_LEN < temp ||
1806 FT_MAC_RFORK_MAX_LEN - temp < pfb_len + 6 )
1807 {
1808 FT_TRACE2(( " MacOS resource length cannot exceed"
1809 " 0x%08x\n",
1810 FT_MAC_RFORK_MAX_LEN ));
1811
1812 error = FT_THROW( Invalid_Offset );
1813 goto Exit;
1814 }
1815
1816 pfb_len += temp + 6;
1817 }
1818
1819 FT_TRACE2(( " total buffer size to concatenate"
1820 " %d POST fragments: 0x%08x\n",
1821 resource_cnt, pfb_len + 2 ));
1822
1823 if ( pfb_len + 2 < 6 )
1824 {
1825 FT_TRACE2(( " too long fragment length makes"
1826 " pfb_len confused: pfb_len=0x%08x\n",
1827 pfb_len ));
1828
1829 error = FT_THROW( Array_Too_Large );
1830 goto Exit;
1831 }
1832
1833 if ( FT_ALLOC( pfb_data, (FT_Long)pfb_len + 2 ) )
1834 goto Exit;
1835
1836 pfb_data[0] = 0x80;
1837 pfb_data[1] = 1; /* Ascii section */
1838 pfb_data[2] = 0; /* 4-byte length, fill in later */
1839 pfb_data[3] = 0;
1840 pfb_data[4] = 0;
1841 pfb_data[5] = 0;
1842 pfb_pos = 6;
1843 pfb_lenpos = 2;
1844
1845 len = 0;
1846 type = 1;
1847
1848 for ( i = 0; i < resource_cnt; i++ )
1849 {
1850 error = FT_Stream_Seek( stream, (FT_ULong)offsets[i] );
1851 if ( error )
1852 goto Exit2;
1853 if ( FT_READ_ULONG( rlen ) )
1854 goto Exit2;
1855
1856 /* FT2 allocator takes signed long buffer length,
1857 * too large fragment length causing overflow should be checked
1858 */
1859 if ( 0x7FFFFFFFUL < rlen )
1860 {
1861 error = FT_THROW( Invalid_Offset );
1862 goto Exit2;
1863 }
1864
1865 if ( FT_READ_USHORT( flags ) )
1866 goto Exit2;
1867
1868 FT_TRACE3(( "POST fragment[%d]:"
1869 " offsets=0x%08x, rlen=0x%08x, flags=0x%04x\n",
1870 i, offsets[i], rlen, flags ));
1871
1872 error = FT_ERR( Array_Too_Large );
1873
1874 /* postpone the check of `rlen longer than buffer' */
1875 /* until `FT_Stream_Read' */
1876
1877 if ( ( flags >> 8 ) == 0 ) /* Comment, should not be loaded */
1878 {
1879 FT_TRACE3(( " Skip POST fragment #%d because it is a comment\n",
1880 i ));
1881 continue;
1882 }
1883
1884 /* the flags are part of the resource, so rlen >= 2, */
1885 /* but some fonts declare rlen = 0 for empty fragment */
1886 if ( rlen > 2 )
1887 rlen -= 2;
1888 else
1889 rlen = 0;
1890
1891 if ( ( flags >> 8 ) == type )
1892 len += rlen;
1893 else
1894 {
1895 FT_TRACE3(( " Write POST fragment #%d header (4-byte) to buffer"
1896 " %p + 0x%08x\n",
1897 i, pfb_data, pfb_lenpos ));
1898
1899 if ( pfb_lenpos + 3 > pfb_len + 2 )
1900 goto Exit2;
1901
1902 pfb_data[pfb_lenpos ] = (FT_Byte)( len );
1903 pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 );
1904 pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 );
1905 pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 );
1906
1907 if ( ( flags >> 8 ) == 5 ) /* End of font mark */
1908 break;
1909
1910 FT_TRACE3(( " Write POST fragment #%d header (6-byte) to buffer"
1911 " %p + 0x%08x\n",
1912 i, pfb_data, pfb_pos ));
1913
1914 if ( pfb_pos + 6 > pfb_len + 2 )
1915 goto Exit2;
1916
1917 pfb_data[pfb_pos++] = 0x80;
1918
1919 type = flags >> 8;
1920 len = rlen;
1921
1922 pfb_data[pfb_pos++] = (FT_Byte)type;
1923 pfb_lenpos = pfb_pos;
1924 pfb_data[pfb_pos++] = 0; /* 4-byte length, fill in later */
1925 pfb_data[pfb_pos++] = 0;
1926 pfb_data[pfb_pos++] = 0;
1927 pfb_data[pfb_pos++] = 0;
1928 }
1929
1930 if ( pfb_pos > pfb_len || pfb_pos + rlen > pfb_len )
1931 goto Exit2;
1932
1933 FT_TRACE3(( " Load POST fragment #%d (%d byte) to buffer"
1934 " %p + 0x%08x\n",
1935 i, rlen, pfb_data, pfb_pos ));
1936
1937 error = FT_Stream_Read( stream, (FT_Byte *)pfb_data + pfb_pos, rlen );
1938 if ( error )
1939 goto Exit2;
1940
1941 pfb_pos += rlen;
1942 }
1943
1944 error = FT_ERR( Array_Too_Large );
1945
1946 if ( pfb_pos + 2 > pfb_len + 2 )
1947 goto Exit2;
1948 pfb_data[pfb_pos++] = 0x80;
1949 pfb_data[pfb_pos++] = 3;
1950
1951 if ( pfb_lenpos + 3 > pfb_len + 2 )
1952 goto Exit2;
1953 pfb_data[pfb_lenpos ] = (FT_Byte)( len );
1954 pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 );
1955 pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 );
1956 pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 );
1957
1958 return open_face_from_buffer( library,
1959 pfb_data,
1960 pfb_pos,
1961 face_index,
1962 "type1",
1963 aface );
1964
1965 Exit2:
1966 if ( FT_ERR_EQ( error, Array_Too_Large ) )
1967 FT_TRACE2(( " Abort due to too-short buffer to store"
1968 " all POST fragments\n" ));
1969 else if ( FT_ERR_EQ( error, Invalid_Offset ) )
1970 FT_TRACE2(( " Abort due to invalid offset in a POST fragment\n" ));
1971
1972 if ( error )
1973 error = FT_ERR( Cannot_Open_Resource );
1974 FT_FREE( pfb_data );
1975
1976 Exit:
1977 return error;
1978 }
1979
1980
1981 /* The resource header says we've got resource_cnt `sfnt' */
1982 /* (TrueType/OpenType) resources in this file. Look through */
1983 /* them for the one indicated by face_index, load it into mem, */
1984 /* pass it on to the truetype driver, and return it. */
1985 /* */
1986 static FT_Error
1987 Mac_Read_sfnt_Resource( FT_Library library,
1988 FT_Stream stream,
1989 FT_Long *offsets,
1990 FT_Long resource_cnt,
1991 FT_Long face_index,
1992 FT_Face *aface )
1993 {
1994 FT_Memory memory = library->memory;
1995 FT_Byte* sfnt_data = NULL;
1996 FT_Error error;
1997 FT_ULong flag_offset;
1998 FT_Long rlen;
1999 int is_cff;
2000 FT_Long face_index_in_resource = 0;
2001
2002
2003 if ( face_index < 0 )
2004 face_index = -face_index - 1;
2005 if ( face_index >= resource_cnt )
2006 return FT_THROW( Cannot_Open_Resource );
2007
2008 flag_offset = (FT_ULong)offsets[face_index];
2009 error = FT_Stream_Seek( stream, flag_offset );
2010 if ( error )
2011 goto Exit;
2012
2013 if ( FT_READ_LONG( rlen ) )
2014 goto Exit;
2015 if ( rlen < 1 )
2016 return FT_THROW( Cannot_Open_Resource );
2017 if ( (FT_ULong)rlen > FT_MAC_RFORK_MAX_LEN )
2018 return FT_THROW( Invalid_Offset );
2019
2020 error = open_face_PS_from_sfnt_stream( library,
2021 stream,
2022 face_index,
2023 0, NULL,
2024 aface );
2025 if ( !error )
2026 goto Exit;
2027
2028 /* rewind sfnt stream before open_face_PS_from_sfnt_stream() */
2029 error = FT_Stream_Seek( stream, flag_offset + 4 );
2030 if ( error )
2031 goto Exit;
2032
2033 if ( FT_ALLOC( sfnt_data, rlen ) )
2034 return error;
2035 error = FT_Stream_Read( stream, (FT_Byte *)sfnt_data, (FT_ULong)rlen );
2036 if ( error ) {
2037 FT_FREE( sfnt_data );
2038 goto Exit;
2039 }
2040
2041 is_cff = rlen > 4 && !ft_memcmp( sfnt_data, "OTTO", 4 );
2042 error = open_face_from_buffer( library,
2043 sfnt_data,
2044 (FT_ULong)rlen,
2045 face_index_in_resource,
2046 is_cff ? "cff" : "truetype",
2047 aface );
2048
2049 Exit:
2050 return error;
2051 }
2052
2053
2054 /* Check for a valid resource fork header, or a valid dfont */
2055 /* header. In a resource fork the first 16 bytes are repeated */
2056 /* at the location specified by bytes 4-7. In a dfont bytes */
2057 /* 4-7 point to 16 bytes of zeroes instead. */
2058 /* */
2059 static FT_Error
2060 IsMacResource( FT_Library library,
2061 FT_Stream stream,
2062 FT_Long resource_offset,
2063 FT_Long face_index,
2064 FT_Face *aface )
2065 {
2066 FT_Memory memory = library->memory;
2067 FT_Error error;
2068 FT_Long map_offset, rdata_pos;
2069 FT_Long *data_offsets;
2070 FT_Long count;
2071
2072
2073 error = FT_Raccess_Get_HeaderInfo( library, stream, resource_offset,
2074 &map_offset, &rdata_pos );
2075 if ( error )
2076 return error;
2077
2078 /* POST resources must be sorted to concatenate properly */
2079 error = FT_Raccess_Get_DataOffsets( library, stream,
2080 map_offset, rdata_pos,
2081 TTAG_POST, TRUE,
2082 &data_offsets, &count );
2083 if ( !error )
2084 {
2085 error = Mac_Read_POST_Resource( library, stream, data_offsets, count,
2086 face_index, aface );
2087 FT_FREE( data_offsets );
2088 /* POST exists in an LWFN providing a single face */
2089 if ( !error )
2090 (*aface)->num_faces = 1;
2091 return error;
2092 }
2093
2094 /* sfnt resources should not be sorted to preserve the face order by
2095 QuickDraw API */
2096 error = FT_Raccess_Get_DataOffsets( library, stream,
2097 map_offset, rdata_pos,
2098 TTAG_sfnt, FALSE,
2099 &data_offsets, &count );
2100 if ( !error )
2101 {
2102 FT_Long face_index_internal = face_index % count;
2103
2104
2105 error = Mac_Read_sfnt_Resource( library, stream, data_offsets, count,
2106 face_index_internal, aface );
2107 FT_FREE( data_offsets );
2108 if ( !error )
2109 (*aface)->num_faces = count;
2110 }
2111
2112 return error;
2113 }
2114
2115
2116 /* Check for a valid macbinary header, and if we find one */
2117 /* check that the (flattened) resource fork in it is valid. */
2118 /* */
2119 static FT_Error
2120 IsMacBinary( FT_Library library,
2121 FT_Stream stream,
2122 FT_Long face_index,
2123 FT_Face *aface )
2124 {
2125 unsigned char header[128];
2126 FT_Error error;
2127 FT_Long dlen, offset;
2128
2129
2130 if ( !stream )
2131 return FT_THROW( Invalid_Stream_Operation );
2132
2133 error = FT_Stream_Seek( stream, 0 );
2134 if ( error )
2135 goto Exit;
2136
2137 error = FT_Stream_Read( stream, (FT_Byte*)header, 128 );
2138 if ( error )
2139 goto Exit;
2140
2141 if ( header[ 0] != 0 ||
2142 header[74] != 0 ||
2143 header[82] != 0 ||
2144 header[ 1] == 0 ||
2145 header[ 1] > 33 ||
2146 header[63] != 0 ||
2147 header[2 + header[1]] != 0 ||
2148 header[0x53] > 0x7F )
2149 return FT_THROW( Unknown_File_Format );
2150
2151 dlen = ( header[0x53] << 24 ) |
2152 ( header[0x54] << 16 ) |
2153 ( header[0x55] << 8 ) |
2154 header[0x56];
2155 #if 0
2156 rlen = ( header[0x57] << 24 ) |
2157 ( header[0x58] << 16 ) |
2158 ( header[0x59] << 8 ) |
2159 header[0x5A];
2160 #endif /* 0 */
2161 offset = 128 + ( ( dlen + 127 ) & ~127 );
2162
2163 return IsMacResource( library, stream, offset, face_index, aface );
2164
2165 Exit:
2166 return error;
2167 }
2168
2169
2170 static FT_Error
2171 load_face_in_embedded_rfork( FT_Library library,
2172 FT_Stream stream,
2173 FT_Long face_index,
2174 FT_Face *aface,
2175 const FT_Open_Args *args )
2176 {
2177
2178 #undef FT_COMPONENT
2179 #define FT_COMPONENT trace_raccess
2180
2181 FT_Memory memory = library->memory;
2182 FT_Error error = FT_ERR( Unknown_File_Format );
2183 FT_UInt i;
2184
2185 char * file_names[FT_RACCESS_N_RULES];
2186 FT_Long offsets[FT_RACCESS_N_RULES];
2187 FT_Error errors[FT_RACCESS_N_RULES];
2188 FT_Bool is_darwin_vfs, vfs_rfork_has_no_font = FALSE; /* not tested */
2189
2190 FT_Open_Args args2;
2191 FT_Stream stream2 = NULL;
2192
2193
2194 FT_Raccess_Guess( library, stream,
2195 args->pathname, file_names, offsets, errors );
2196
2197 for ( i = 0; i < FT_RACCESS_N_RULES; i++ )
2198 {
2199 is_darwin_vfs = ft_raccess_rule_by_darwin_vfs( library, i );
2200 if ( is_darwin_vfs && vfs_rfork_has_no_font )
2201 {
2202 FT_TRACE3(( "Skip rule %d: darwin vfs resource fork"
2203 " is already checked and"
2204 " no font is found\n",
2205 i ));
2206 continue;
2207 }
2208
2209 if ( errors[i] )
2210 {
2211 FT_TRACE3(( "Error 0x%x has occurred in rule %d\n",
2212 errors[i], i ));
2213 continue;
2214 }
2215
2216 args2.flags = FT_OPEN_PATHNAME;
2217 args2.pathname = file_names[i] ? file_names[i] : args->pathname;
2218
2219 FT_TRACE3(( "Try rule %d: %s (offset=%d) ...",
2220 i, args2.pathname, offsets[i] ));
2221
2222 error = FT_Stream_New( library, &args2, &stream2 );
2223 if ( is_darwin_vfs && FT_ERR_EQ( error, Cannot_Open_Stream ) )
2224 vfs_rfork_has_no_font = TRUE;
2225
2226 if ( error )
2227 {
2228 FT_TRACE3(( "failed\n" ));
2229 continue;
2230 }
2231
2232 error = IsMacResource( library, stream2, offsets[i],
2233 face_index, aface );
2234 FT_Stream_Free( stream2, 0 );
2235
2236 FT_TRACE3(( "%s\n", error ? "failed": "successful" ));
2237
2238 if ( !error )
2239 break;
2240 else if ( is_darwin_vfs )
2241 vfs_rfork_has_no_font = TRUE;
2242 }
2243
2244 for (i = 0; i < FT_RACCESS_N_RULES; i++)
2245 {
2246 if ( file_names[i] )
2247 FT_FREE( file_names[i] );
2248 }
2249
2250 /* Caller (load_mac_face) requires FT_Err_Unknown_File_Format. */
2251 if ( error )
2252 error = FT_ERR( Unknown_File_Format );
2253
2254 return error;
2255
2256 #undef FT_COMPONENT
2257 #define FT_COMPONENT trace_objs
2258
2259 }
2260
2261
2262 /* Check for some macintosh formats without Carbon framework. */
2263 /* Is this a macbinary file? If so look at the resource fork. */
2264 /* Is this a mac dfont file? */
2265 /* Is this an old style resource fork? (in data) */
2266 /* Else call load_face_in_embedded_rfork to try extra rules */
2267 /* (defined in `ftrfork.c'). */
2268 /* */
2269 static FT_Error
2270 load_mac_face( FT_Library library,
2271 FT_Stream stream,
2272 FT_Long face_index,
2273 FT_Face *aface,
2274 const FT_Open_Args *args )
2275 {
2276 FT_Error error;
2277 FT_UNUSED( args );
2278
2279
2280 error = IsMacBinary( library, stream, face_index, aface );
2281 if ( FT_ERR_EQ( error, Unknown_File_Format ) )
2282 {
2283
2284 #undef FT_COMPONENT
2285 #define FT_COMPONENT trace_raccess
2286
2287 #ifdef FT_DEBUG_LEVEL_TRACE
2288 FT_TRACE3(( "Try as dfont: " ));
2289 if ( !( args->flags & FT_OPEN_MEMORY ) )
2290 FT_TRACE3(( "%s ...", args->pathname ));
2291 #endif
2292
2293 error = IsMacResource( library, stream, 0, face_index, aface );
2294
2295 FT_TRACE3(( "%s\n", error ? "failed" : "successful" ));
2296
2297 #undef FT_COMPONENT
2298 #define FT_COMPONENT trace_objs
2299
2300 }
2301
2302 if ( ( FT_ERR_EQ( error, Unknown_File_Format ) ||
2303 FT_ERR_EQ( error, Invalid_Stream_Operation ) ) &&
2304 ( args->flags & FT_OPEN_PATHNAME ) )
2305 error = load_face_in_embedded_rfork( library, stream,
2306 face_index, aface, args );
2307 return error;
2308 }
2309 #endif
2310
2311 #endif /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */
2312
2313
2314 /* documentation is in freetype.h */
2315
2316 FT_EXPORT_DEF( FT_Error )
2317 FT_Open_Face( FT_Library library,
2318 const FT_Open_Args* args,
2319 FT_Long face_index,
2320 FT_Face *aface )
2321 {
2322 return ft_open_face_internal( library, args, face_index, aface, 1 );
2323 }
2324
2325
2326 static FT_Error
2327 ft_open_face_internal( FT_Library library,
2328 const FT_Open_Args* args,
2329 FT_Long face_index,
2330 FT_Face *aface,
2331 FT_Bool test_mac_fonts )
2332 {
2333 FT_Error error;
2334 FT_Driver driver = NULL;
2335 FT_Memory memory = NULL;
2336 FT_Stream stream = NULL;
2337 FT_Face face = NULL;
2338 FT_ListNode node = NULL;
2339 FT_Bool external_stream;
2340 FT_Module* cur;
2341 FT_Module* limit;
2342
2343 #ifndef FT_CONFIG_OPTION_MAC_FONTS
2344 FT_UNUSED( test_mac_fonts );
2345 #endif
2346
2347
2348 #ifdef FT_DEBUG_LEVEL_TRACE
2349 FT_TRACE3(( "FT_Open_Face: " ));
2350 if ( face_index < 0 )
2351 FT_TRACE3(( "Requesting number of faces and named instances\n"));
2352 else
2353 {
2354 FT_TRACE3(( "Requesting face %ld", face_index & 0xFFFFL ));
2355 if ( face_index & 0x7FFF0000L )
2356 FT_TRACE3(( ", named instance %ld", face_index >> 16 ));
2357 FT_TRACE3(( "\n" ));
2358 }
2359 #endif
2360
2361 /* test for valid `library' delayed to `FT_Stream_New' */
2362
2363 if ( ( !aface && face_index >= 0 ) || !args )
2364 return FT_THROW( Invalid_Argument );
2365
2366 external_stream = FT_BOOL( ( args->flags & FT_OPEN_STREAM ) &&
2367 args->stream );
2368
2369 /* create input stream */
2370 error = FT_Stream_New( library, args, &stream );
2371 if ( error )
2372 goto Fail3;
2373
2374 memory = library->memory;
2375
2376 /* If the font driver is specified in the `args' structure, use */
2377 /* it. Otherwise, we scan the list of registered drivers. */
2378 if ( ( args->flags & FT_OPEN_DRIVER ) && args->driver )
2379 {
2380 driver = FT_DRIVER( args->driver );
2381
2382 /* not all modules are drivers, so check... */
2383 if ( FT_MODULE_IS_DRIVER( driver ) )
2384 {
2385 FT_Int num_params = 0;
2386 FT_Parameter* params = NULL;
2387
2388
2389 if ( args->flags & FT_OPEN_PARAMS )
2390 {
2391 num_params = args->num_params;
2392 params = args->params;
2393 }
2394
2395 error = open_face( driver, &stream, external_stream, face_index,
2396 num_params, params, &face );
2397 if ( !error )
2398 goto Success;
2399 }
2400 else
2401 error = FT_THROW( Invalid_Handle );
2402
2403 FT_Stream_Free( stream, external_stream );
2404 goto Fail;
2405 }
2406 else
2407 {
2408 error = FT_ERR( Missing_Module );
2409
2410 /* check each font driver for an appropriate format */
2411 cur = library->modules;
2412 limit = cur + library->num_modules;
2413
2414 for ( ; cur < limit; cur++ )
2415 {
2416 /* not all modules are font drivers, so check... */
2417 if ( FT_MODULE_IS_DRIVER( cur[0] ) )
2418 {
2419 FT_Int num_params = 0;
2420 FT_Parameter* params = NULL;
2421
2422
2423 driver = FT_DRIVER( cur[0] );
2424
2425 if ( args->flags & FT_OPEN_PARAMS )
2426 {
2427 num_params = args->num_params;
2428 params = args->params;
2429 }
2430
2431 error = open_face( driver, &stream, external_stream, face_index,
2432 num_params, params, &face );
2433 if ( !error )
2434 goto Success;
2435
2436 #ifdef FT_CONFIG_OPTION_MAC_FONTS
2437 if ( test_mac_fonts &&
2438 ft_strcmp( cur[0]->clazz->module_name, "truetype" ) == 0 &&
2439 FT_ERR_EQ( error, Table_Missing ) )
2440 {
2441 /* TrueType but essential tables are missing */
2442 error = FT_Stream_Seek( stream, 0 );
2443 if ( error )
2444 break;
2445
2446 error = open_face_PS_from_sfnt_stream( library,
2447 stream,
2448 face_index,
2449 num_params,
2450 params,
2451 aface );
2452 if ( !error )
2453 {
2454 FT_Stream_Free( stream, external_stream );
2455 return error;
2456 }
2457 }
2458 #endif
2459
2460 if ( FT_ERR_NEQ( error, Unknown_File_Format ) )
2461 goto Fail3;
2462 }
2463 }
2464
2465 Fail3:
2466 /* If we are on the mac, and we get an */
2467 /* FT_Err_Invalid_Stream_Operation it may be because we have an */
2468 /* empty data fork, so we need to check the resource fork. */
2469 if ( FT_ERR_NEQ( error, Cannot_Open_Stream ) &&
2470 FT_ERR_NEQ( error, Unknown_File_Format ) &&
2471 FT_ERR_NEQ( error, Invalid_Stream_Operation ) )
2472 goto Fail2;
2473
2474 #if !defined( FT_MACINTOSH ) && defined( FT_CONFIG_OPTION_MAC_FONTS )
2475 if ( test_mac_fonts )
2476 {
2477 error = load_mac_face( library, stream, face_index, aface, args );
2478 if ( !error )
2479 {
2480 /* We don't want to go to Success here. We've already done */
2481 /* that. On the other hand, if we succeeded we still need to */
2482 /* close this stream (we opened a different stream which */
2483 /* extracted the interesting information out of this stream */
2484 /* here. That stream will still be open and the face will */
2485 /* point to it). */
2486 FT_Stream_Free( stream, external_stream );
2487 return error;
2488 }
2489 }
2490
2491 if ( FT_ERR_NEQ( error, Unknown_File_Format ) )
2492 goto Fail2;
2493 #endif /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */
2494
2495 /* no driver is able to handle this format */
2496 error = FT_THROW( Unknown_File_Format );
2497
2498 Fail2:
2499 FT_Stream_Free( stream, external_stream );
2500 goto Fail;
2501 }
2502
2503 Success:
2504 FT_TRACE4(( "FT_Open_Face: New face object, adding to list\n" ));
2505
2506 /* add the face object to its driver's list */
2507 if ( FT_NEW( node ) )
2508 goto Fail;
2509
2510 node->data = face;
2511 /* don't assume driver is the same as face->driver, so use */
2512 /* face->driver instead. */
2513 FT_List_Add( &face->driver->faces_list, node );
2514
2515 /* now allocate a glyph slot object for the face */
2516 FT_TRACE4(( "FT_Open_Face: Creating glyph slot\n" ));
2517
2518 if ( face_index >= 0 )
2519 {
2520 error = FT_New_GlyphSlot( face, NULL );
2521 if ( error )
2522 goto Fail;
2523
2524 /* finally, allocate a size object for the face */
2525 {
2526 FT_Size size;
2527
2528
2529 FT_TRACE4(( "FT_Open_Face: Creating size object\n" ));
2530
2531 error = FT_New_Size( face, &size );
2532 if ( error )
2533 goto Fail;
2534
2535 face->size = size;
2536 }
2537 }
2538
2539 /* some checks */
2540
2541 if ( FT_IS_SCALABLE( face ) )
2542 {
2543 if ( face->height < 0 )
2544 face->height = (FT_Short)-face->height;
2545
2546 if ( !FT_HAS_VERTICAL( face ) )
2547 face->max_advance_height = (FT_Short)face->height;
2548 }
2549
2550 if ( FT_HAS_FIXED_SIZES( face ) )
2551 {
2552 FT_Int i;
2553
2554
2555 for ( i = 0; i < face->num_fixed_sizes; i++ )
2556 {
2557 FT_Bitmap_Size* bsize = face->available_sizes + i;
2558
2559
2560 if ( bsize->height < 0 )
2561 bsize->height = -bsize->height;
2562 if ( bsize->x_ppem < 0 )
2563 bsize->x_ppem = -bsize->x_ppem;
2564 if ( bsize->y_ppem < 0 )
2565 bsize->y_ppem = -bsize->y_ppem;
2566
2567 /* check whether negation actually has worked */
2568 if ( bsize->height < 0 || bsize->x_ppem < 0 || bsize->y_ppem < 0 )
2569 {
2570 FT_TRACE0(( "FT_Open_Face:"
2571 " Invalid bitmap dimensions for strike %d,"
2572 " now disabled\n", i ));
2573 bsize->width = 0;
2574 bsize->height = 0;
2575 bsize->size = 0;
2576 bsize->x_ppem = 0;
2577 bsize->y_ppem = 0;
2578 }
2579 }
2580 }
2581
2582 /* initialize internal face data */
2583 {
2584 FT_Face_Internal internal = face->internal;
2585
2586
2587 internal->transform_matrix.xx = 0x10000L;
2588 internal->transform_matrix.xy = 0;
2589 internal->transform_matrix.yx = 0;
2590 internal->transform_matrix.yy = 0x10000L;
2591
2592 internal->transform_delta.x = 0;
2593 internal->transform_delta.y = 0;
2594
2595 internal->refcount = 1;
2596
2597 internal->no_stem_darkening = -1;
2598
2599 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
2600 /* Per-face filtering can only be set up by FT_Face_Properties */
2601 internal->lcd_filter_func = NULL;
2602 #endif
2603 }
2604
2605 if ( aface )
2606 *aface = face;
2607 else
2608 FT_Done_Face( face );
2609
2610 goto Exit;
2611
2612 Fail:
2613 if ( node )
2614 FT_Done_Face( face ); /* face must be in the driver's list */
2615 else if ( face )
2616 destroy_face( memory, face, driver );
2617
2618 Exit:
2619 #ifdef FT_DEBUG_LEVEL_TRACE
2620 if ( !error && face_index < 0 )
2621 {
2622 FT_TRACE3(( "FT_Open_Face: The font has %ld face%s\n"
2623 " and %ld named instance%s for face %ld\n",
2624 face->num_faces,
2625 face->num_faces == 1 ? "" : "s",
2626 face->style_flags >> 16,
2627 ( face->style_flags >> 16 ) == 1 ? "" : "s",
2628 -face_index - 1 ));
2629 }
2630 #endif
2631
2632 FT_TRACE4(( "FT_Open_Face: Return 0x%x\n", error ));
2633
2634 return error;
2635 }
2636
2637
2638 /* documentation is in freetype.h */
2639
2640 FT_EXPORT_DEF( FT_Error )
2641 FT_Attach_File( FT_Face face,
2642 const char* filepathname )
2643 {
2644 FT_Open_Args open;
2645
2646
2647 /* test for valid `face' delayed to `FT_Attach_Stream' */
2648
2649 if ( !filepathname )
2650 return FT_THROW( Invalid_Argument );
2651
2652 open.stream = NULL;
2653 open.flags = FT_OPEN_PATHNAME;
2654 open.pathname = (char*)filepathname;
2655
2656 return FT_Attach_Stream( face, &open );
2657 }
2658
2659
2660 /* documentation is in freetype.h */
2661
2662 FT_EXPORT_DEF( FT_Error )
2663 FT_Attach_Stream( FT_Face face,
2664 FT_Open_Args* parameters )
2665 {
2666 FT_Stream stream;
2667 FT_Error error;
2668 FT_Driver driver;
2669
2670 FT_Driver_Class clazz;
2671
2672
2673 /* test for valid `parameters' delayed to `FT_Stream_New' */
2674
2675 if ( !face )
2676 return FT_THROW( Invalid_Face_Handle );
2677
2678 driver = face->driver;
2679 if ( !driver )
2680 return FT_THROW( Invalid_Driver_Handle );
2681
2682 error = FT_Stream_New( driver->root.library, parameters, &stream );
2683 if ( error )
2684 goto Exit;
2685
2686 /* we implement FT_Attach_Stream in each driver through the */
2687 /* `attach_file' interface */
2688
2689 error = FT_ERR( Unimplemented_Feature );
2690 clazz = driver->clazz;
2691 if ( clazz->attach_file )
2692 error = clazz->attach_file( face, stream );
2693
2694 /* close the attached stream */
2695 FT_Stream_Free( stream,
2696 (FT_Bool)( parameters->stream &&
2697 ( parameters->flags & FT_OPEN_STREAM ) ) );
2698
2699 Exit:
2700 return error;
2701 }
2702
2703
2704 /* documentation is in freetype.h */
2705
2706 FT_EXPORT_DEF( FT_Error )
2707 FT_Reference_Face( FT_Face face )
2708 {
2709 if ( !face )
2710 return FT_THROW( Invalid_Face_Handle );
2711
2712 face->internal->refcount++;
2713
2714 return FT_Err_Ok;
2715 }
2716
2717
2718 /* documentation is in freetype.h */
2719
2720 FT_EXPORT_DEF( FT_Error )
2721 FT_Done_Face( FT_Face face )
2722 {
2723 FT_Error error;
2724 FT_Driver driver;
2725 FT_Memory memory;
2726 FT_ListNode node;
2727
2728
2729 error = FT_ERR( Invalid_Face_Handle );
2730 if ( face && face->driver )
2731 {
2732 face->internal->refcount--;
2733 if ( face->internal->refcount > 0 )
2734 error = FT_Err_Ok;
2735 else
2736 {
2737 driver = face->driver;
2738 memory = driver->root.memory;
2739
2740 /* find face in driver's list */
2741 node = FT_List_Find( &driver->faces_list, face );
2742 if ( node )
2743 {
2744 /* remove face object from the driver's list */
2745 FT_List_Remove( &driver->faces_list, node );
2746 FT_FREE( node );
2747
2748 /* now destroy the object proper */
2749 destroy_face( memory, face, driver );
2750 error = FT_Err_Ok;
2751 }
2752 }
2753 }
2754
2755 return error;
2756 }
2757
2758
2759 /* documentation is in ftobjs.h */
2760
2761 FT_EXPORT_DEF( FT_Error )
2762 FT_New_Size( FT_Face face,
2763 FT_Size *asize )
2764 {
2765 FT_Error error;
2766 FT_Memory memory;
2767 FT_Driver driver;
2768 FT_Driver_Class clazz;
2769
2770 FT_Size size = NULL;
2771 FT_ListNode node = NULL;
2772
2773 FT_Size_Internal internal = NULL;
2774
2775
2776 if ( !face )
2777 return FT_THROW( Invalid_Face_Handle );
2778
2779 if ( !asize )
2780 return FT_THROW( Invalid_Argument );
2781
2782 if ( !face->driver )
2783 return FT_THROW( Invalid_Driver_Handle );
2784
2785 *asize = NULL;
2786
2787 driver = face->driver;
2788 clazz = driver->clazz;
2789 memory = face->memory;
2790
2791 /* Allocate new size object and perform basic initialisation */
2792 if ( FT_ALLOC( size, clazz->size_object_size ) || FT_NEW( node ) )
2793 goto Exit;
2794
2795 size->face = face;
2796
2797 if ( FT_NEW( internal ) )
2798 goto Exit;
2799
2800 size->internal = internal;
2801
2802 if ( clazz->init_size )
2803 error = clazz->init_size( size );
2804
2805 /* in case of success, add to the face's list */
2806 if ( !error )
2807 {
2808 *asize = size;
2809 node->data = size;
2810 FT_List_Add( &face->sizes_list, node );
2811 }
2812
2813 Exit:
2814 if ( error )
2815 {
2816 FT_FREE( node );
2817 FT_FREE( size );
2818 }
2819
2820 return error;
2821 }
2822
2823
2824 /* documentation is in ftobjs.h */
2825
2826 FT_EXPORT_DEF( FT_Error )
2827 FT_Done_Size( FT_Size size )
2828 {
2829 FT_Error error;
2830 FT_Driver driver;
2831 FT_Memory memory;
2832 FT_Face face;
2833 FT_ListNode node;
2834
2835
2836 if ( !size )
2837 return FT_THROW( Invalid_Size_Handle );
2838
2839 face = size->face;
2840 if ( !face )
2841 return FT_THROW( Invalid_Face_Handle );
2842
2843 driver = face->driver;
2844 if ( !driver )
2845 return FT_THROW( Invalid_Driver_Handle );
2846
2847 memory = driver->root.memory;
2848
2849 error = FT_Err_Ok;
2850 node = FT_List_Find( &face->sizes_list, size );
2851 if ( node )
2852 {
2853 FT_List_Remove( &face->sizes_list, node );
2854 FT_FREE( node );
2855
2856 if ( face->size == size )
2857 {
2858 face->size = NULL;
2859 if ( face->sizes_list.head )
2860 face->size = (FT_Size)(face->sizes_list.head->data);
2861 }
2862
2863 destroy_size( memory, size, driver );
2864 }
2865 else
2866 error = FT_THROW( Invalid_Size_Handle );
2867
2868 return error;
2869 }
2870
2871
2872 /* documentation is in ftobjs.h */
2873
2874 FT_BASE_DEF( FT_Error )
2875 FT_Match_Size( FT_Face face,
2876 FT_Size_Request req,
2877 FT_Bool ignore_width,
2878 FT_ULong* size_index )
2879 {
2880 FT_Int i;
2881 FT_Long w, h;
2882
2883
2884 if ( !FT_HAS_FIXED_SIZES( face ) )
2885 return FT_THROW( Invalid_Face_Handle );
2886
2887 /* FT_Bitmap_Size doesn't provide enough info... */
2888 if ( req->type != FT_SIZE_REQUEST_TYPE_NOMINAL )
2889 return FT_THROW( Unimplemented_Feature );
2890
2891 w = FT_REQUEST_WIDTH ( req );
2892 h = FT_REQUEST_HEIGHT( req );
2893
2894 if ( req->width && !req->height )
2895 h = w;
2896 else if ( !req->width && req->height )
2897 w = h;
2898
2899 w = FT_PIX_ROUND( w );
2900 h = FT_PIX_ROUND( h );
2901
2902 if ( !w || !h )
2903 return FT_THROW( Invalid_Pixel_Size );
2904
2905 for ( i = 0; i < face->num_fixed_sizes; i++ )
2906 {
2907 FT_Bitmap_Size* bsize = face->available_sizes + i;
2908
2909
2910 if ( h != FT_PIX_ROUND( bsize->y_ppem ) )
2911 continue;
2912
2913 if ( w == FT_PIX_ROUND( bsize->x_ppem ) || ignore_width )
2914 {
2915 FT_TRACE3(( "FT_Match_Size: bitmap strike %d matches\n", i ));
2916
2917 if ( size_index )
2918 *size_index = (FT_ULong)i;
2919
2920 return FT_Err_Ok;
2921 }
2922 }
2923
2924 FT_TRACE3(( "FT_Match_Size: no matching bitmap strike\n" ));
2925
2926 return FT_THROW( Invalid_Pixel_Size );
2927 }
2928
2929
2930 /* documentation is in ftobjs.h */
2931
2932 FT_BASE_DEF( void )
2933 ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics,
2934 FT_Pos advance )
2935 {
2936 FT_Pos height = metrics->height;
2937
2938
2939 /* compensate for glyph with bbox above/below the baseline */
2940 if ( metrics->horiBearingY < 0 )
2941 {
2942 if ( height < metrics->horiBearingY )
2943 height = metrics->horiBearingY;
2944 }
2945 else if ( metrics->horiBearingY > 0 )
2946 height -= metrics->horiBearingY;
2947
2948 /* the factor 1.2 is a heuristical value */
2949 if ( !advance )
2950 advance = height * 12 / 10;
2951
2952 metrics->vertBearingX = metrics->horiBearingX - metrics->horiAdvance / 2;
2953 metrics->vertBearingY = ( advance - height ) / 2;
2954 metrics->vertAdvance = advance;
2955 }
2956
2957
2958 static void
2959 ft_recompute_scaled_metrics( FT_Face face,
2960 FT_Size_Metrics* metrics )
2961 {
2962 /* Compute root ascender, descender, test height, and max_advance */
2963
2964 #ifdef GRID_FIT_METRICS
2965 metrics->ascender = FT_PIX_CEIL( FT_MulFix( face->ascender,
2966 metrics->y_scale ) );
2967
2968 metrics->descender = FT_PIX_FLOOR( FT_MulFix( face->descender,
2969 metrics->y_scale ) );
2970
2971 metrics->height = FT_PIX_ROUND( FT_MulFix( face->height,
2972 metrics->y_scale ) );
2973
2974 metrics->max_advance = FT_PIX_ROUND( FT_MulFix( face->max_advance_width,
2975 metrics->x_scale ) );
2976 #else /* !GRID_FIT_METRICS */
2977 metrics->ascender = FT_MulFix( face->ascender,
2978 metrics->y_scale );
2979
2980 metrics->descender = FT_MulFix( face->descender,
2981 metrics->y_scale );
2982
2983 metrics->height = FT_MulFix( face->height,
2984 metrics->y_scale );
2985
2986 metrics->max_advance = FT_MulFix( face->max_advance_width,
2987 metrics->x_scale );
2988 #endif /* !GRID_FIT_METRICS */
2989 }
2990
2991
2992 FT_BASE_DEF( void )
2993 FT_Select_Metrics( FT_Face face,
2994 FT_ULong strike_index )
2995 {
2996 FT_Size_Metrics* metrics;
2997 FT_Bitmap_Size* bsize;
2998
2999
3000 metrics = &face->size->metrics;
3001 bsize = face->available_sizes + strike_index;
3002
3003 metrics->x_ppem = (FT_UShort)( ( bsize->x_ppem + 32 ) >> 6 );
3004 metrics->y_ppem = (FT_UShort)( ( bsize->y_ppem + 32 ) >> 6 );
3005
3006 if ( FT_IS_SCALABLE( face ) )
3007 {
3008 metrics->x_scale = FT_DivFix( bsize->x_ppem,
3009 face->units_per_EM );
3010 metrics->y_scale = FT_DivFix( bsize->y_ppem,
3011 face->units_per_EM );
3012
3013 ft_recompute_scaled_metrics( face, metrics );
3014 }
3015 else
3016 {
3017 metrics->x_scale = 1L << 16;
3018 metrics->y_scale = 1L << 16;
3019 metrics->ascender = bsize->y_ppem;
3020 metrics->descender = 0;
3021 metrics->height = bsize->height << 6;
3022 metrics->max_advance = bsize->x_ppem;
3023 }
3024 }
3025
3026
3027 FT_BASE_DEF( void )
3028 FT_Request_Metrics( FT_Face face,
3029 FT_Size_Request req )
3030 {
3031 FT_Size_Metrics* metrics;
3032
3033
3034 metrics = &face->size->metrics;
3035
3036 if ( FT_IS_SCALABLE( face ) )
3037 {
3038 FT_Long w = 0, h = 0, scaled_w = 0, scaled_h = 0;
3039
3040
3041 switch ( req->type )
3042 {
3043 case FT_SIZE_REQUEST_TYPE_NOMINAL:
3044 w = h = face->units_per_EM;
3045 break;
3046
3047 case FT_SIZE_REQUEST_TYPE_REAL_DIM:
3048 w = h = face->ascender - face->descender;
3049 break;
3050
3051 case FT_SIZE_REQUEST_TYPE_BBOX:
3052 w = face->bbox.xMax - face->bbox.xMin;
3053 h = face->bbox.yMax - face->bbox.yMin;
3054 break;
3055
3056 case FT_SIZE_REQUEST_TYPE_CELL:
3057 w = face->max_advance_width;
3058 h = face->ascender - face->descender;
3059 break;
3060
3061 case FT_SIZE_REQUEST_TYPE_SCALES:
3062 metrics->x_scale = (FT_Fixed)req->width;
3063 metrics->y_scale = (FT_Fixed)req->height;
3064 if ( !metrics->x_scale )
3065 metrics->x_scale = metrics->y_scale;
3066 else if ( !metrics->y_scale )
3067 metrics->y_scale = metrics->x_scale;
3068 goto Calculate_Ppem;
3069
3070 case FT_SIZE_REQUEST_TYPE_MAX:
3071 break;
3072 }
3073
3074 /* to be on the safe side */
3075 if ( w < 0 )
3076 w = -w;
3077
3078 if ( h < 0 )
3079 h = -h;
3080
3081 scaled_w = FT_REQUEST_WIDTH ( req );
3082 scaled_h = FT_REQUEST_HEIGHT( req );
3083
3084 /* determine scales */
3085 if ( req->width )
3086 {
3087 metrics->x_scale = FT_DivFix( scaled_w, w );
3088
3089 if ( req->height )
3090 {
3091 metrics->y_scale = FT_DivFix( scaled_h, h );
3092
3093 if ( req->type == FT_SIZE_REQUEST_TYPE_CELL )
3094 {
3095 if ( metrics->y_scale > metrics->x_scale )
3096 metrics->y_scale = metrics->x_scale;
3097 else
3098 metrics->x_scale = metrics->y_scale;
3099 }
3100 }
3101 else
3102 {
3103 metrics->y_scale = metrics->x_scale;
3104 scaled_h = FT_MulDiv( scaled_w, h, w );
3105 }
3106 }
3107 else
3108 {
3109 metrics->x_scale = metrics->y_scale = FT_DivFix( scaled_h, h );
3110 scaled_w = FT_MulDiv( scaled_h, w, h );
3111 }
3112
3113 Calculate_Ppem:
3114 /* calculate the ppems */
3115 if ( req->type != FT_SIZE_REQUEST_TYPE_NOMINAL )
3116 {
3117 scaled_w = FT_MulFix( face->units_per_EM, metrics->x_scale );
3118 scaled_h = FT_MulFix( face->units_per_EM, metrics->y_scale );
3119 }
3120
3121 metrics->x_ppem = (FT_UShort)( ( scaled_w + 32 ) >> 6 );
3122 metrics->y_ppem = (FT_UShort)( ( scaled_h + 32 ) >> 6 );
3123
3124 ft_recompute_scaled_metrics( face, metrics );
3125 }
3126 else
3127 {
3128 FT_ZERO( metrics );
3129 metrics->x_scale = 1L << 16;
3130 metrics->y_scale = 1L << 16;
3131 }
3132 }
3133
3134
3135 /* documentation is in freetype.h */
3136
3137 FT_EXPORT_DEF( FT_Error )
3138 FT_Select_Size( FT_Face face,
3139 FT_Int strike_index )
3140 {
3141 FT_Error error = FT_Err_Ok;
3142 FT_Driver_Class clazz;
3143
3144
3145 if ( !face || !FT_HAS_FIXED_SIZES( face ) )
3146 return FT_THROW( Invalid_Face_Handle );
3147
3148 if ( strike_index < 0 || strike_index >= face->num_fixed_sizes )
3149 return FT_THROW( Invalid_Argument );
3150
3151 clazz = face->driver->clazz;
3152
3153 if ( clazz->select_size )
3154 {
3155 error = clazz->select_size( face->size, (FT_ULong)strike_index );
3156
3157 FT_TRACE5(( "FT_Select_Size (%s driver):\n",
3158 face->driver->root.clazz->module_name ));
3159 }
3160 else
3161 {
3162 FT_Select_Metrics( face, (FT_ULong)strike_index );
3163
3164 FT_TRACE5(( "FT_Select_Size:\n" ));
3165 }
3166
3167 #ifdef FT_DEBUG_LEVEL_TRACE
3168 {
3169 FT_Size_Metrics* metrics = &face->size->metrics;
3170
3171
3172 FT_TRACE5(( " x scale: %d (%f)\n",
3173 metrics->x_scale, metrics->x_scale / 65536.0 ));
3174 FT_TRACE5(( " y scale: %d (%f)\n",
3175 metrics->y_scale, metrics->y_scale / 65536.0 ));
3176 FT_TRACE5(( " ascender: %f\n", metrics->ascender / 64.0 ));
3177 FT_TRACE5(( " descender: %f\n", metrics->descender / 64.0 ));
3178 FT_TRACE5(( " height: %f\n", metrics->height / 64.0 ));
3179 FT_TRACE5(( " max advance: %f\n", metrics->max_advance / 64.0 ));
3180 FT_TRACE5(( " x ppem: %d\n", metrics->x_ppem ));
3181 FT_TRACE5(( " y ppem: %d\n", metrics->y_ppem ));
3182 }
3183 #endif
3184
3185 return error;
3186 }
3187
3188
3189 /* documentation is in freetype.h */
3190
3191 FT_EXPORT_DEF( FT_Error )
3192 FT_Request_Size( FT_Face face,
3193 FT_Size_Request req )
3194 {
3195 FT_Error error = FT_Err_Ok;
3196 FT_Driver_Class clazz;
3197 FT_ULong strike_index;
3198
3199
3200 if ( !face )
3201 return FT_THROW( Invalid_Face_Handle );
3202
3203 if ( !req || req->width < 0 || req->height < 0 ||
3204 req->type >= FT_SIZE_REQUEST_TYPE_MAX )
3205 return FT_THROW( Invalid_Argument );
3206
3207 /* signal the auto-hinter to recompute its size metrics */
3208 /* (if requested) */
3209 face->size->internal->autohint_metrics.x_scale = 0;
3210
3211 clazz = face->driver->clazz;
3212
3213 if ( clazz->request_size )
3214 {
3215 error = clazz->request_size( face->size, req );
3216
3217 FT_TRACE5(( "FT_Request_Size (%s driver):\n",
3218 face->driver->root.clazz->module_name ));
3219 }
3220 else if ( !FT_IS_SCALABLE( face ) && FT_HAS_FIXED_SIZES( face ) )
3221 {
3222 /*
3223 * The reason that a driver doesn't have `request_size' defined is
3224 * either that the scaling here suffices or that the supported formats
3225 * are bitmap-only and size matching is not implemented.
3226 *
3227 * In the latter case, a simple size matching is done.
3228 */
3229 error = FT_Match_Size( face, req, 0, &strike_index );
3230 if ( error )
3231 return error;
3232
3233 return FT_Select_Size( face, (FT_Int)strike_index );
3234 }
3235 else
3236 {
3237 FT_Request_Metrics( face, req );
3238
3239 FT_TRACE5(( "FT_Request_Size:\n" ));
3240 }
3241
3242 #ifdef FT_DEBUG_LEVEL_TRACE
3243 {
3244 FT_Size_Metrics* metrics = &face->size->metrics;
3245
3246
3247 FT_TRACE5(( " x scale: %d (%f)\n",
3248 metrics->x_scale, metrics->x_scale / 65536.0 ));
3249 FT_TRACE5(( " y scale: %d (%f)\n",
3250 metrics->y_scale, metrics->y_scale / 65536.0 ));
3251 FT_TRACE5(( " ascender: %f\n", metrics->ascender / 64.0 ));
3252 FT_TRACE5(( " descender: %f\n", metrics->descender / 64.0 ));
3253 FT_TRACE5(( " height: %f\n", metrics->height / 64.0 ));
3254 FT_TRACE5(( " max advance: %f\n", metrics->max_advance / 64.0 ));
3255 FT_TRACE5(( " x ppem: %d\n", metrics->x_ppem ));
3256 FT_TRACE5(( " y ppem: %d\n", metrics->y_ppem ));
3257 }
3258 #endif
3259
3260 return error;
3261 }
3262
3263
3264 /* documentation is in freetype.h */
3265
3266 FT_EXPORT_DEF( FT_Error )
3267 FT_Set_Char_Size( FT_Face face,
3268 FT_F26Dot6 char_width,
3269 FT_F26Dot6 char_height,
3270 FT_UInt horz_resolution,
3271 FT_UInt vert_resolution )
3272 {
3273 FT_Size_RequestRec req;
3274
3275
3276 /* check of `face' delayed to `FT_Request_Size' */
3277
3278 if ( !char_width )
3279 char_width = char_height;
3280 else if ( !char_height )
3281 char_height = char_width;
3282
3283 if ( !horz_resolution )
3284 horz_resolution = vert_resolution;
3285 else if ( !vert_resolution )
3286 vert_resolution = horz_resolution;
3287
3288 if ( char_width < 1 * 64 )
3289 char_width = 1 * 64;
3290 if ( char_height < 1 * 64 )
3291 char_height = 1 * 64;
3292
3293 if ( !horz_resolution )
3294 horz_resolution = vert_resolution = 72;
3295
3296 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL;
3297 req.width = char_width;
3298 req.height = char_height;
3299 req.horiResolution = horz_resolution;
3300 req.vertResolution = vert_resolution;
3301
3302 return FT_Request_Size( face, &req );
3303 }
3304
3305
3306 /* documentation is in freetype.h */
3307
3308 FT_EXPORT_DEF( FT_Error )
3309 FT_Set_Pixel_Sizes( FT_Face face,
3310 FT_UInt pixel_width,
3311 FT_UInt pixel_height )
3312 {
3313 FT_Size_RequestRec req;
3314
3315
3316 /* check of `face' delayed to `FT_Request_Size' */
3317
3318 if ( pixel_width == 0 )
3319 pixel_width = pixel_height;
3320 else if ( pixel_height == 0 )
3321 pixel_height = pixel_width;
3322
3323 if ( pixel_width < 1 )
3324 pixel_width = 1;
3325 if ( pixel_height < 1 )
3326 pixel_height = 1;
3327
3328 /* use `>=' to avoid potential compiler warning on 16bit platforms */
3329 if ( pixel_width >= 0xFFFFU )
3330 pixel_width = 0xFFFFU;
3331 if ( pixel_height >= 0xFFFFU )
3332 pixel_height = 0xFFFFU;
3333
3334 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL;
3335 req.width = (FT_Long)( pixel_width << 6 );
3336 req.height = (FT_Long)( pixel_height << 6 );
3337 req.horiResolution = 0;
3338 req.vertResolution = 0;
3339
3340 return FT_Request_Size( face, &req );
3341 }
3342
3343
3344 /* documentation is in freetype.h */
3345
3346 FT_EXPORT_DEF( FT_Error )
3347 FT_Get_Kerning( FT_Face face,
3348 FT_UInt left_glyph,
3349 FT_UInt right_glyph,
3350 FT_UInt kern_mode,
3351 FT_Vector *akerning )
3352 {
3353 FT_Error error = FT_Err_Ok;
3354 FT_Driver driver;
3355
3356
3357 if ( !face )
3358 return FT_THROW( Invalid_Face_Handle );
3359
3360 if ( !akerning )
3361 return FT_THROW( Invalid_Argument );
3362
3363 driver = face->driver;
3364
3365 akerning->x = 0;
3366 akerning->y = 0;
3367
3368 if ( driver->clazz->get_kerning )
3369 {
3370 error = driver->clazz->get_kerning( face,
3371 left_glyph,
3372 right_glyph,
3373 akerning );
3374 if ( !error )
3375 {
3376 if ( kern_mode != FT_KERNING_UNSCALED )
3377 {
3378 akerning->x = FT_MulFix( akerning->x, face->size->metrics.x_scale );
3379 akerning->y = FT_MulFix( akerning->y, face->size->metrics.y_scale );
3380
3381 if ( kern_mode != FT_KERNING_UNFITTED )
3382 {
3383 FT_Pos orig_x = akerning->x;
3384 FT_Pos orig_y = akerning->y;
3385
3386
3387 /* we scale down kerning values for small ppem values */
3388 /* to avoid that rounding makes them too big. */
3389 /* `25' has been determined heuristically. */
3390 if ( face->size->metrics.x_ppem < 25 )
3391 akerning->x = FT_MulDiv( orig_x,
3392 face->size->metrics.x_ppem, 25 );
3393 if ( face->size->metrics.y_ppem < 25 )
3394 akerning->y = FT_MulDiv( orig_y,
3395 face->size->metrics.y_ppem, 25 );
3396
3397 akerning->x = FT_PIX_ROUND( akerning->x );
3398 akerning->y = FT_PIX_ROUND( akerning->y );
3399
3400 #ifdef FT_DEBUG_LEVEL_TRACE
3401 {
3402 FT_Pos orig_x_rounded = FT_PIX_ROUND( orig_x );
3403 FT_Pos orig_y_rounded = FT_PIX_ROUND( orig_y );
3404
3405
3406 if ( akerning->x != orig_x_rounded ||
3407 akerning->y != orig_y_rounded )
3408 FT_TRACE5(( "FT_Get_Kerning: horizontal kerning"
3409 " (%d, %d) scaled down to (%d, %d) pixels\n",
3410 orig_x_rounded / 64, orig_y_rounded / 64,
3411 akerning->x / 64, akerning->y / 64 ));
3412 }
3413 #endif
3414 }
3415 }
3416 }
3417 }
3418
3419 return error;
3420 }
3421
3422
3423 /* documentation is in freetype.h */
3424
3425 FT_EXPORT_DEF( FT_Error )
3426 FT_Get_Track_Kerning( FT_Face face,
3427 FT_Fixed point_size,
3428 FT_Int degree,
3429 FT_Fixed* akerning )
3430 {
3431 FT_Service_Kerning service;
3432 FT_Error error = FT_Err_Ok;
3433
3434
3435 if ( !face )
3436 return FT_THROW( Invalid_Face_Handle );
3437
3438 if ( !akerning )
3439 return FT_THROW( Invalid_Argument );
3440
3441 FT_FACE_FIND_SERVICE( face, service, KERNING );
3442 if ( !service )
3443 return FT_THROW( Unimplemented_Feature );
3444
3445 error = service->get_track( face,
3446 point_size,
3447 degree,
3448 akerning );
3449
3450 return error;
3451 }
3452
3453
3454 /* documentation is in freetype.h */
3455
3456 FT_EXPORT_DEF( FT_Error )
3457 FT_Select_Charmap( FT_Face face,
3458 FT_Encoding encoding )
3459 {
3460 FT_CharMap* cur;
3461 FT_CharMap* limit;
3462
3463
3464 if ( !face )
3465 return FT_THROW( Invalid_Face_Handle );
3466
3467 if ( encoding == FT_ENCODING_NONE )
3468 return FT_THROW( Invalid_Argument );
3469
3470 /* FT_ENCODING_UNICODE is special. We try to find the `best' Unicode */
3471 /* charmap available, i.e., one with UCS-4 characters, if possible. */
3472 /* */
3473 /* This is done by find_unicode_charmap() above, to share code. */
3474 if ( encoding == FT_ENCODING_UNICODE )
3475 return find_unicode_charmap( face );
3476
3477 cur = face->charmaps;
3478 if ( !cur )
3479 return FT_THROW( Invalid_CharMap_Handle );
3480
3481 limit = cur + face->num_charmaps;
3482
3483 for ( ; cur < limit; cur++ )
3484 {
3485 if ( cur[0]->encoding == encoding )
3486 {
3487 face->charmap = cur[0];
3488 return 0;
3489 }
3490 }
3491
3492 return FT_THROW( Invalid_Argument );
3493 }
3494
3495
3496 /* documentation is in freetype.h */
3497
3498 FT_EXPORT_DEF( FT_Error )
3499 FT_Set_Charmap( FT_Face face,
3500 FT_CharMap charmap )
3501 {
3502 FT_CharMap* cur;
3503 FT_CharMap* limit;
3504
3505
3506 if ( !face )
3507 return FT_THROW( Invalid_Face_Handle );
3508
3509 cur = face->charmaps;
3510 if ( !cur || !charmap )
3511 return FT_THROW( Invalid_CharMap_Handle );
3512
3513 if ( FT_Get_CMap_Format( charmap ) == 14 )
3514 return FT_THROW( Invalid_Argument );
3515
3516 limit = cur + face->num_charmaps;
3517
3518 for ( ; cur < limit; cur++ )
3519 {
3520 if ( cur[0] == charmap )
3521 {
3522 face->charmap = cur[0];
3523 return FT_Err_Ok;
3524 }
3525 }
3526
3527 return FT_THROW( Invalid_Argument );
3528 }
3529
3530
3531 /* documentation is in freetype.h */
3532
3533 FT_EXPORT_DEF( FT_Int )
3534 FT_Get_Charmap_Index( FT_CharMap charmap )
3535 {
3536 FT_Int i;
3537
3538
3539 if ( !charmap || !charmap->face )
3540 return -1;
3541
3542 for ( i = 0; i < charmap->face->num_charmaps; i++ )
3543 if ( charmap->face->charmaps[i] == charmap )
3544 break;
3545
3546 FT_ASSERT( i < charmap->face->num_charmaps );
3547
3548 return i;
3549 }
3550
3551
3552 static void
3553 ft_cmap_done_internal( FT_CMap cmap )
3554 {
3555 FT_CMap_Class clazz = cmap->clazz;
3556 FT_Face face = cmap->charmap.face;
3557 FT_Memory memory = FT_FACE_MEMORY( face );
3558
3559
3560 if ( clazz->done )
3561 clazz->done( cmap );
3562
3563 FT_FREE( cmap );
3564 }
3565
3566
3567 FT_BASE_DEF( void )
3568 FT_CMap_Done( FT_CMap cmap )
3569 {
3570 if ( cmap )
3571 {
3572 FT_Face face = cmap->charmap.face;
3573 FT_Memory memory = FT_FACE_MEMORY( face );
3574 FT_Error error;
3575 FT_Int i, j;
3576
3577
3578 for ( i = 0; i < face->num_charmaps; i++ )
3579 {
3580 if ( (FT_CMap)face->charmaps[i] == cmap )
3581 {
3582 FT_CharMap last_charmap = face->charmaps[face->num_charmaps - 1];
3583
3584
3585 if ( FT_RENEW_ARRAY( face->charmaps,
3586 face->num_charmaps,
3587 face->num_charmaps - 1 ) )
3588 return;
3589
3590 /* remove it from our list of charmaps */
3591 for ( j = i + 1; j < face->num_charmaps; j++ )
3592 {
3593 if ( j == face->num_charmaps - 1 )
3594 face->charmaps[j - 1] = last_charmap;
3595 else
3596 face->charmaps[j - 1] = face->charmaps[j];
3597 }
3598
3599 face->num_charmaps--;
3600
3601 if ( (FT_CMap)face->charmap == cmap )
3602 face->charmap = NULL;
3603
3604 ft_cmap_done_internal( cmap );
3605
3606 break;
3607 }
3608 }
3609 }
3610 }
3611
3612
3613 FT_BASE_DEF( FT_Error )
3614 FT_CMap_New( FT_CMap_Class clazz,
3615 FT_Pointer init_data,
3616 FT_CharMap charmap,
3617 FT_CMap *acmap )
3618 {
3619 FT_Error error = FT_Err_Ok;
3620 FT_Face face;
3621 FT_Memory memory;
3622 FT_CMap cmap = NULL;
3623
3624
3625 if ( !clazz || !charmap || !charmap->face )
3626 return FT_THROW( Invalid_Argument );
3627
3628 face = charmap->face;
3629 memory = FT_FACE_MEMORY( face );
3630
3631 if ( !FT_ALLOC( cmap, clazz->size ) )
3632 {
3633 cmap->charmap = *charmap;
3634 cmap->clazz = clazz;
3635
3636 if ( clazz->init )
3637 {
3638 error = clazz->init( cmap, init_data );
3639 if ( error )
3640 goto Fail;
3641 }
3642
3643 /* add it to our list of charmaps */
3644 if ( FT_RENEW_ARRAY( face->charmaps,
3645 face->num_charmaps,
3646 face->num_charmaps + 1 ) )
3647 goto Fail;
3648
3649 face->charmaps[face->num_charmaps++] = (FT_CharMap)cmap;
3650 }
3651
3652 Exit:
3653 if ( acmap )
3654 *acmap = cmap;
3655
3656 return error;
3657
3658 Fail:
3659 ft_cmap_done_internal( cmap );
3660 cmap = NULL;
3661 goto Exit;
3662 }
3663
3664
3665 /* documentation is in freetype.h */
3666
3667 FT_EXPORT_DEF( FT_UInt )
3668 FT_Get_Char_Index( FT_Face face,
3669 FT_ULong charcode )
3670 {
3671 FT_UInt result = 0;
3672
3673
3674 if ( face && face->charmap )
3675 {
3676 FT_CMap cmap = FT_CMAP( face->charmap );
3677
3678
3679 if ( charcode > 0xFFFFFFFFUL )
3680 {
3681 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
3682 FT_TRACE1(( " 0x%x is truncated\n", charcode ));
3683 }
3684
3685 result = cmap->clazz->char_index( cmap, (FT_UInt32)charcode );
3686 if ( result >= (FT_UInt)face->num_glyphs )
3687 result = 0;
3688 }
3689
3690 return result;
3691 }
3692
3693
3694 /* documentation is in freetype.h */
3695
3696 FT_EXPORT_DEF( FT_ULong )
3697 FT_Get_First_Char( FT_Face face,
3698 FT_UInt *agindex )
3699 {
3700 FT_ULong result = 0;
3701 FT_UInt gindex = 0;
3702
3703
3704 /* only do something if we have a charmap, and we have glyphs at all */
3705 if ( face && face->charmap && face->num_glyphs )
3706 {
3707 gindex = FT_Get_Char_Index( face, 0 );
3708 if ( gindex == 0 )
3709 result = FT_Get_Next_Char( face, 0, &gindex );
3710 }
3711
3712 if ( agindex )
3713 *agindex = gindex;
3714
3715 return result;
3716 }
3717
3718
3719 /* documentation is in freetype.h */
3720
3721 FT_EXPORT_DEF( FT_ULong )
3722 FT_Get_Next_Char( FT_Face face,
3723 FT_ULong charcode,
3724 FT_UInt *agindex )
3725 {
3726 FT_ULong result = 0;
3727 FT_UInt gindex = 0;
3728
3729
3730 if ( face && face->charmap && face->num_glyphs )
3731 {
3732 FT_UInt32 code = (FT_UInt32)charcode;
3733 FT_CMap cmap = FT_CMAP( face->charmap );
3734
3735
3736 do
3737 {
3738 gindex = cmap->clazz->char_next( cmap, &code );
3739
3740 } while ( gindex >= (FT_UInt)face->num_glyphs );
3741
3742 result = ( gindex == 0 ) ? 0 : code;
3743 }
3744
3745 if ( agindex )
3746 *agindex = gindex;
3747
3748 return result;
3749 }
3750
3751
3752 /* documentation is in freetype.h */
3753
3754 FT_EXPORT_DEF( FT_Error )
3755 FT_Face_Properties( FT_Face face,
3756 FT_UInt num_properties,
3757 FT_Parameter* properties )
3758 {
3759 FT_Error error = FT_Err_Ok;
3760
3761
3762 if ( num_properties > 0 && !properties )
3763 {
3764 error = FT_THROW( Invalid_Argument );
3765 goto Exit;
3766 }
3767
3768 for ( ; num_properties > 0; num_properties-- )
3769 {
3770 if ( properties->tag == FT_PARAM_TAG_STEM_DARKENING )
3771 {
3772 if ( properties->data )
3773 {
3774 if ( *( (FT_Bool*)properties->data ) == TRUE )
3775 face->internal->no_stem_darkening = FALSE;
3776 else
3777 face->internal->no_stem_darkening = TRUE;
3778 }
3779 else
3780 {
3781 /* use module default */
3782 face->internal->no_stem_darkening = -1;
3783 }
3784 }
3785 else if ( properties->tag == FT_PARAM_TAG_LCD_FILTER_WEIGHTS )
3786 {
3787 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
3788 if ( properties->data )
3789 {
3790 ft_memcpy( face->internal->lcd_weights,
3791 properties->data,
3792 FT_LCD_FILTER_FIVE_TAPS );
3793 face->internal->lcd_filter_func = ft_lcd_filter_fir;
3794 }
3795 #else
3796 error = FT_THROW( Unimplemented_Feature );
3797 goto Exit;
3798 #endif
3799 }
3800 else if ( properties->tag == FT_PARAM_TAG_RANDOM_SEED )
3801 {
3802 if ( properties->data )
3803 {
3804 face->internal->random_seed = *( (FT_Int32*)properties->data );
3805 if ( face->internal->random_seed < 0 )
3806 face->internal->random_seed = 0;
3807 }
3808 else
3809 {
3810 /* use module default */
3811 face->internal->random_seed = -1;
3812 }
3813 }
3814 else
3815 {
3816 error = FT_THROW( Invalid_Argument );
3817 goto Exit;
3818 }
3819
3820 if ( error )
3821 break;
3822
3823 properties++;
3824 }
3825
3826 Exit:
3827 return error;
3828 }
3829
3830
3831 /* documentation is in freetype.h */
3832
3833 FT_EXPORT_DEF( FT_UInt )
3834 FT_Face_GetCharVariantIndex( FT_Face face,
3835 FT_ULong charcode,
3836 FT_ULong variantSelector )
3837 {
3838 FT_UInt result = 0;
3839
3840
3841 if ( face &&
3842 face->charmap &&
3843 face->charmap->encoding == FT_ENCODING_UNICODE )
3844 {
3845 FT_CharMap charmap = find_variant_selector_charmap( face );
3846 FT_CMap ucmap = FT_CMAP( face->charmap );
3847
3848
3849 if ( charmap )
3850 {
3851 FT_CMap vcmap = FT_CMAP( charmap );
3852
3853
3854 if ( charcode > 0xFFFFFFFFUL )
3855 {
3856 FT_TRACE1(( "FT_Face_GetCharVariantIndex:"
3857 " too large charcode" ));
3858 FT_TRACE1(( " 0x%x is truncated\n", charcode ));
3859 }
3860 if ( variantSelector > 0xFFFFFFFFUL )
3861 {
3862 FT_TRACE1(( "FT_Face_GetCharVariantIndex:"
3863 " too large variantSelector" ));
3864 FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
3865 }
3866
3867 result = vcmap->clazz->char_var_index( vcmap, ucmap,
3868 (FT_UInt32)charcode,
3869 (FT_UInt32)variantSelector );
3870 }
3871 }
3872
3873 return result;
3874 }
3875
3876
3877 /* documentation is in freetype.h */
3878
3879 FT_EXPORT_DEF( FT_Int )
3880 FT_Face_GetCharVariantIsDefault( FT_Face face,
3881 FT_ULong charcode,
3882 FT_ULong variantSelector )
3883 {
3884 FT_Int result = -1;
3885
3886
3887 if ( face )
3888 {
3889 FT_CharMap charmap = find_variant_selector_charmap( face );
3890
3891
3892 if ( charmap )
3893 {
3894 FT_CMap vcmap = FT_CMAP( charmap );
3895
3896
3897 if ( charcode > 0xFFFFFFFFUL )
3898 {
3899 FT_TRACE1(( "FT_Face_GetCharVariantIsDefault:"
3900 " too large charcode" ));
3901 FT_TRACE1(( " 0x%x is truncated\n", charcode ));
3902 }
3903 if ( variantSelector > 0xFFFFFFFFUL )
3904 {
3905 FT_TRACE1(( "FT_Face_GetCharVariantIsDefault:"
3906 " too large variantSelector" ));
3907 FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
3908 }
3909
3910 result = vcmap->clazz->char_var_default( vcmap,
3911 (FT_UInt32)charcode,
3912 (FT_UInt32)variantSelector );
3913 }
3914 }
3915
3916 return result;
3917 }
3918
3919
3920 /* documentation is in freetype.h */
3921
3922 FT_EXPORT_DEF( FT_UInt32* )
3923 FT_Face_GetVariantSelectors( FT_Face face )
3924 {
3925 FT_UInt32 *result = NULL;
3926
3927
3928 if ( face )
3929 {
3930 FT_CharMap charmap = find_variant_selector_charmap( face );
3931
3932
3933 if ( charmap )
3934 {
3935 FT_CMap vcmap = FT_CMAP( charmap );
3936 FT_Memory memory = FT_FACE_MEMORY( face );
3937
3938
3939 result = vcmap->clazz->variant_list( vcmap, memory );
3940 }
3941 }
3942
3943 return result;
3944 }
3945
3946
3947 /* documentation is in freetype.h */
3948
3949 FT_EXPORT_DEF( FT_UInt32* )
3950 FT_Face_GetVariantsOfChar( FT_Face face,
3951 FT_ULong charcode )
3952 {
3953 FT_UInt32 *result = NULL;
3954
3955
3956 if ( face )
3957 {
3958 FT_CharMap charmap = find_variant_selector_charmap( face );
3959
3960
3961 if ( charmap )
3962 {
3963 FT_CMap vcmap = FT_CMAP( charmap );
3964 FT_Memory memory = FT_FACE_MEMORY( face );
3965
3966
3967 if ( charcode > 0xFFFFFFFFUL )
3968 {
3969 FT_TRACE1(( "FT_Face_GetVariantsOfChar: too large charcode" ));
3970 FT_TRACE1(( " 0x%x is truncated\n", charcode ));
3971 }
3972
3973 result = vcmap->clazz->charvariant_list( vcmap, memory,
3974 (FT_UInt32)charcode );
3975 }
3976 }
3977 return result;
3978 }
3979
3980
3981 /* documentation is in freetype.h */
3982
3983 FT_EXPORT_DEF( FT_UInt32* )
3984 FT_Face_GetCharsOfVariant( FT_Face face,
3985 FT_ULong variantSelector )
3986 {
3987 FT_UInt32 *result = NULL;
3988
3989
3990 if ( face )
3991 {
3992 FT_CharMap charmap = find_variant_selector_charmap( face );
3993
3994
3995 if ( charmap )
3996 {
3997 FT_CMap vcmap = FT_CMAP( charmap );
3998 FT_Memory memory = FT_FACE_MEMORY( face );
3999
4000
4001 if ( variantSelector > 0xFFFFFFFFUL )
4002 {
4003 FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
4004 FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
4005 }
4006
4007 result = vcmap->clazz->variantchar_list( vcmap, memory,
4008 (FT_UInt32)variantSelector );
4009 }
4010 }
4011
4012 return result;
4013 }
4014
4015
4016 /* documentation is in freetype.h */
4017
4018 FT_EXPORT_DEF( FT_UInt )
4019 FT_Get_Name_Index( FT_Face face,
4020 FT_String* glyph_name )
4021 {
4022 FT_UInt result = 0;
4023
4024
4025 if ( face &&
4026 FT_HAS_GLYPH_NAMES( face ) &&
4027 glyph_name )
4028 {
4029 FT_Service_GlyphDict service;
4030
4031
4032 FT_FACE_LOOKUP_SERVICE( face,
4033 service,
4034 GLYPH_DICT );
4035
4036 if ( service && service->name_index )
4037 result = service->name_index( face, glyph_name );
4038 }
4039
4040 return result;
4041 }
4042
4043
4044 /* documentation is in freetype.h */
4045
4046 FT_EXPORT_DEF( FT_Error )
4047 FT_Get_Glyph_Name( FT_Face face,
4048 FT_UInt glyph_index,
4049 FT_Pointer buffer,
4050 FT_UInt buffer_max )
4051 {
4052 FT_Error error;
4053 FT_Service_GlyphDict service;
4054
4055
4056 if ( !face )
4057 return FT_THROW( Invalid_Face_Handle );
4058
4059 if ( !buffer || buffer_max == 0 )
4060 return FT_THROW( Invalid_Argument );
4061
4062 /* clean up buffer */
4063 ((FT_Byte*)buffer)[0] = '\0';
4064
4065 if ( (FT_Long)glyph_index >= face->num_glyphs )
4066 return FT_THROW( Invalid_Glyph_Index );
4067
4068 if ( !FT_HAS_GLYPH_NAMES( face ) )
4069 return FT_THROW( Invalid_Argument );
4070
4071 FT_FACE_LOOKUP_SERVICE( face, service, GLYPH_DICT );
4072 if ( service && service->get_name )
4073 error = service->get_name( face, glyph_index, buffer, buffer_max );
4074 else
4075 error = FT_THROW( Invalid_Argument );
4076
4077 return error;
4078 }
4079
4080
4081 /* documentation is in freetype.h */
4082
4083 FT_EXPORT_DEF( const char* )
4084 FT_Get_Postscript_Name( FT_Face face )
4085 {
4086 const char* result = NULL;
4087
4088
4089 if ( !face )
4090 goto Exit;
4091
4092 if ( !result )
4093 {
4094 FT_Service_PsFontName service;
4095
4096
4097 FT_FACE_LOOKUP_SERVICE( face,
4098 service,
4099 POSTSCRIPT_FONT_NAME );
4100
4101 if ( service && service->get_ps_font_name )
4102 result = service->get_ps_font_name( face );
4103 }
4104
4105 Exit:
4106 return result;
4107 }
4108
4109
4110 /* documentation is in tttables.h */
4111
4112 FT_EXPORT_DEF( void* )
4113 FT_Get_Sfnt_Table( FT_Face face,
4114 FT_Sfnt_Tag tag )
4115 {
4116 void* table = NULL;
4117 FT_Service_SFNT_Table service;
4118
4119
4120 if ( face && FT_IS_SFNT( face ) )
4121 {
4122 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
4123 if ( service )
4124 table = service->get_table( face, tag );
4125 }
4126
4127 return table;
4128 }
4129
4130
4131 /* documentation is in tttables.h */
4132
4133 FT_EXPORT_DEF( FT_Error )
4134 FT_Load_Sfnt_Table( FT_Face face,
4135 FT_ULong tag,
4136 FT_Long offset,
4137 FT_Byte* buffer,
4138 FT_ULong* length )
4139 {
4140 FT_Service_SFNT_Table service;
4141
4142
4143 if ( !face || !FT_IS_SFNT( face ) )
4144 return FT_THROW( Invalid_Face_Handle );
4145
4146 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
4147 if ( !service )
4148 return FT_THROW( Unimplemented_Feature );
4149
4150 return service->load_table( face, tag, offset, buffer, length );
4151 }
4152
4153
4154 /* documentation is in tttables.h */
4155
4156 FT_EXPORT_DEF( FT_Error )
4157 FT_Sfnt_Table_Info( FT_Face face,
4158 FT_UInt table_index,
4159 FT_ULong *tag,
4160 FT_ULong *length )
4161 {
4162 FT_Service_SFNT_Table service;
4163 FT_ULong offset;
4164
4165
4166 /* test for valid `length' delayed to `service->table_info' */
4167
4168 if ( !face || !FT_IS_SFNT( face ) )
4169 return FT_THROW( Invalid_Face_Handle );
4170
4171 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE );
4172 if ( !service )
4173 return FT_THROW( Unimplemented_Feature );
4174
4175 return service->table_info( face, table_index, tag, &offset, length );
4176 }
4177
4178
4179 /* documentation is in tttables.h */
4180
4181 FT_EXPORT_DEF( FT_ULong )
4182 FT_Get_CMap_Language_ID( FT_CharMap charmap )
4183 {
4184 FT_Service_TTCMaps service;
4185 FT_Face face;
4186 TT_CMapInfo cmap_info;
4187
4188
4189 if ( !charmap || !charmap->face )
4190 return 0;
4191
4192 face = charmap->face;
4193 FT_FACE_FIND_SERVICE( face, service, TT_CMAP );
4194 if ( !service )
4195 return 0;
4196 if ( service->get_cmap_info( charmap, &cmap_info ))
4197 return 0;
4198
4199 return cmap_info.language;
4200 }
4201
4202
4203 /* documentation is in tttables.h */
4204
4205 FT_EXPORT_DEF( FT_Long )
4206 FT_Get_CMap_Format( FT_CharMap charmap )
4207 {
4208 FT_Service_TTCMaps service;
4209 FT_Face face;
4210 TT_CMapInfo cmap_info;
4211
4212
4213 if ( !charmap || !charmap->face )
4214 return -1;
4215
4216 face = charmap->face;
4217 FT_FACE_FIND_SERVICE( face, service, TT_CMAP );
4218 if ( !service )
4219 return -1;
4220 if ( service->get_cmap_info( charmap, &cmap_info ))
4221 return -1;
4222
4223 return cmap_info.format;
4224 }
4225
4226
4227 /* documentation is in ftsizes.h */
4228
4229 FT_EXPORT_DEF( FT_Error )
4230 FT_Activate_Size( FT_Size size )
4231 {
4232 FT_Face face;
4233
4234
4235 if ( !size )
4236 return FT_THROW( Invalid_Size_Handle );
4237
4238 face = size->face;
4239 if ( !face || !face->driver )
4240 return FT_THROW( Invalid_Face_Handle );
4241
4242 /* we don't need anything more complex than that; all size objects */
4243 /* are already listed by the face */
4244 face->size = size;
4245
4246 return FT_Err_Ok;
4247 }
4248
4249
4250 /*************************************************************************/
4251 /*************************************************************************/
4252 /*************************************************************************/
4253 /**** ****/
4254 /**** ****/
4255 /**** R E N D E R E R S ****/
4256 /**** ****/
4257 /**** ****/
4258 /*************************************************************************/
4259 /*************************************************************************/
4260 /*************************************************************************/
4261
4262 /* lookup a renderer by glyph format in the library's list */
4263 FT_BASE_DEF( FT_Renderer )
4264 FT_Lookup_Renderer( FT_Library library,
4265 FT_Glyph_Format format,
4266 FT_ListNode* node )
4267 {
4268 FT_ListNode cur;
4269 FT_Renderer result = NULL;
4270
4271
4272 if ( !library )
4273 goto Exit;
4274
4275 cur = library->renderers.head;
4276
4277 if ( node )
4278 {
4279 if ( *node )
4280 cur = (*node)->next;
4281 *node = NULL;
4282 }
4283
4284 while ( cur )
4285 {
4286 FT_Renderer renderer = FT_RENDERER( cur->data );
4287
4288
4289 if ( renderer->glyph_format == format )
4290 {
4291 if ( node )
4292 *node = cur;
4293
4294 result = renderer;
4295 break;
4296 }
4297 cur = cur->next;
4298 }
4299
4300 Exit:
4301 return result;
4302 }
4303
4304
4305 static FT_Renderer
4306 ft_lookup_glyph_renderer( FT_GlyphSlot slot )
4307 {
4308 FT_Face face = slot->face;
4309 FT_Library library = FT_FACE_LIBRARY( face );
4310 FT_Renderer result = library->cur_renderer;
4311
4312
4313 if ( !result || result->glyph_format != slot->format )
4314 result = FT_Lookup_Renderer( library, slot->format, 0 );
4315
4316 return result;
4317 }
4318
4319
4320 static void
4321 ft_set_current_renderer( FT_Library library )
4322 {
4323 FT_Renderer renderer;
4324
4325
4326 renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE, 0 );
4327 library->cur_renderer = renderer;
4328 }
4329
4330
4331 static FT_Error
4332 ft_add_renderer( FT_Module module )
4333 {
4334 FT_Library library = module->library;
4335 FT_Memory memory = library->memory;
4336 FT_Error error;
4337 FT_ListNode node = NULL;
4338
4339
4340 if ( FT_NEW( node ) )
4341 goto Exit;
4342
4343 {
4344 FT_Renderer render = FT_RENDERER( module );
4345 FT_Renderer_Class* clazz = (FT_Renderer_Class*)module->clazz;
4346
4347
4348 render->clazz = clazz;
4349 render->glyph_format = clazz->glyph_format;
4350
4351 /* allocate raster object if needed */
4352 if ( clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE &&
4353 clazz->raster_class->raster_new )
4354 {
4355 error = clazz->raster_class->raster_new( memory, &render->raster );
4356 if ( error )
4357 goto Fail;
4358
4359 render->raster_render = clazz->raster_class->raster_render;
4360 render->render = clazz->render_glyph;
4361 }
4362
4363 /* add to list */
4364 node->data = module;
4365 FT_List_Add( &library->renderers, node );
4366
4367 ft_set_current_renderer( library );
4368 }
4369
4370 Fail:
4371 if ( error )
4372 FT_FREE( node );
4373
4374 Exit:
4375 return error;
4376 }
4377
4378
4379 static void
4380 ft_remove_renderer( FT_Module module )
4381 {
4382 FT_Library library;
4383 FT_Memory memory;
4384 FT_ListNode node;
4385
4386
4387 library = module->library;
4388 if ( !library )
4389 return;
4390
4391 memory = library->memory;
4392
4393 node = FT_List_Find( &library->renderers, module );
4394 if ( node )
4395 {
4396 FT_Renderer render = FT_RENDERER( module );
4397
4398
4399 /* release raster object, if any */
4400 if ( render->clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE &&
4401 render->raster )
4402 render->clazz->raster_class->raster_done( render->raster );
4403
4404 /* remove from list */
4405 FT_List_Remove( &library->renderers, node );
4406 FT_FREE( node );
4407
4408 ft_set_current_renderer( library );
4409 }
4410 }
4411
4412
4413 /* documentation is in ftrender.h */
4414
4415 FT_EXPORT_DEF( FT_Renderer )
4416 FT_Get_Renderer( FT_Library library,
4417 FT_Glyph_Format format )
4418 {
4419 /* test for valid `library' delayed to `FT_Lookup_Renderer' */
4420
4421 return FT_Lookup_Renderer( library, format, 0 );
4422 }
4423
4424
4425 /* documentation is in ftrender.h */
4426
4427 FT_EXPORT_DEF( FT_Error )
4428 FT_Set_Renderer( FT_Library library,
4429 FT_Renderer renderer,
4430 FT_UInt num_params,
4431 FT_Parameter* parameters )
4432 {
4433 FT_ListNode node;
4434 FT_Error error = FT_Err_Ok;
4435
4436 FT_Renderer_SetModeFunc set_mode;
4437
4438
4439 if ( !library )
4440 {
4441 error = FT_THROW( Invalid_Library_Handle );
4442 goto Exit;
4443 }
4444
4445 if ( !renderer )
4446 {
4447 error = FT_THROW( Invalid_Argument );
4448 goto Exit;
4449 }
4450
4451 if ( num_params > 0 && !parameters )
4452 {
4453 error = FT_THROW( Invalid_Argument );
4454 goto Exit;
4455 }
4456
4457 node = FT_List_Find( &library->renderers, renderer );
4458 if ( !node )
4459 {
4460 error = FT_THROW( Invalid_Argument );
4461 goto Exit;
4462 }
4463
4464 FT_List_Up( &library->renderers, node );
4465
4466 if ( renderer->glyph_format == FT_GLYPH_FORMAT_OUTLINE )
4467 library->cur_renderer = renderer;
4468
4469 set_mode = renderer->clazz->set_mode;
4470
4471 for ( ; num_params > 0; num_params-- )
4472 {
4473 error = set_mode( renderer, parameters->tag, parameters->data );
4474 if ( error )
4475 break;
4476 parameters++;
4477 }
4478
4479 Exit:
4480 return error;
4481 }
4482
4483
4484 FT_BASE_DEF( FT_Error )
4485 FT_Render_Glyph_Internal( FT_Library library,
4486 FT_GlyphSlot slot,
4487 FT_Render_Mode render_mode )
4488 {
4489 FT_Error error = FT_Err_Ok;
4490 FT_Renderer renderer;
4491
4492
4493 /* if it is already a bitmap, no need to do anything */
4494 switch ( slot->format )
4495 {
4496 case FT_GLYPH_FORMAT_BITMAP: /* already a bitmap, don't do anything */
4497 break;
4498
4499 default:
4500 {
4501 FT_ListNode node = NULL;
4502
4503
4504 /* small shortcut for the very common case */
4505 if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
4506 {
4507 renderer = library->cur_renderer;
4508 node = library->renderers.head;
4509 }
4510 else
4511 renderer = FT_Lookup_Renderer( library, slot->format, &node );
4512
4513 error = FT_ERR( Unimplemented_Feature );
4514 while ( renderer )
4515 {
4516 error = renderer->render( renderer, slot, render_mode, NULL );
4517 if ( !error ||
4518 FT_ERR_NEQ( error, Cannot_Render_Glyph ) )
4519 break;
4520
4521 /* FT_Err_Cannot_Render_Glyph is returned if the render mode */
4522 /* is unsupported by the current renderer for this glyph image */
4523 /* format. */
4524
4525 /* now, look for another renderer that supports the same */
4526 /* format. */
4527 renderer = FT_Lookup_Renderer( library, slot->format, &node );
4528 }
4529 }
4530 }
4531
4532 #ifdef FT_DEBUG_LEVEL_TRACE
4533
4534 #undef FT_COMPONENT
4535 #define FT_COMPONENT trace_bitmap
4536
4537 /*
4538 * Computing the MD5 checksum is expensive, unnecessarily distorting a
4539 * possible profiling of FreeType if compiled with tracing support. For
4540 * this reason, we execute the following code only if explicitly
4541 * requested.
4542 */
4543
4544 /* we use FT_TRACE3 in this block */
4545 if ( !error &&
4546 ft_trace_levels[trace_bitmap] >= 3 &&
4547 slot->bitmap.buffer )
4548 {
4549 FT_Bitmap bitmap;
4550 FT_Error err;
4551
4552
4553 FT_Bitmap_Init( &bitmap );
4554
4555 /* we convert to a single bitmap format for computing the checksum */
4556 /* this also converts the bitmap flow to `down' (i.e., pitch > 0) */
4557 err = FT_Bitmap_Convert( library, &slot->bitmap, &bitmap, 1 );
4558 if ( !err )
4559 {
4560 MD5_CTX ctx;
4561 unsigned char md5[16];
4562 unsigned long coverage = 0;
4563 int i, j;
4564 int rows = (int)bitmap.rows;
4565 int pitch = bitmap.pitch;
4566
4567
4568 FT_TRACE3(( "FT_Render_Glyph: bitmap %dx%d, mode %d\n",
4569 rows, pitch, slot->bitmap.pixel_mode ));
4570
4571 for ( i = 0; i < rows; i++ )
4572 for ( j = 0; j < pitch; j++ )
4573 coverage += bitmap.buffer[i * pitch + j];
4574
4575 FT_TRACE3(( " Total coverage: %lu\n", coverage ));
4576
4577 MD5_Init( &ctx );
4578 if ( bitmap.buffer )
4579 MD5_Update( &ctx, bitmap.buffer,
4580 (unsigned long)rows * (unsigned long)pitch );
4581 MD5_Final( md5, &ctx );
4582
4583 FT_TRACE3(( " MD5 checksum: " ));
4584 for ( i = 0; i < 16; i++ )
4585 FT_TRACE3(( "%02X", md5[i] ));
4586 FT_TRACE3(( "\n" ));
4587 }
4588
4589 FT_Bitmap_Done( library, &bitmap );
4590 }
4591
4592 /*
4593 * Dump bitmap in Netpbm format (PBM or PGM).
4594 */
4595
4596 /* we use FT_TRACE7 in this block */
4597 if ( !error &&
4598 ft_trace_levels[trace_bitmap] >= 7 &&
4599 slot->bitmap.rows < 128U &&
4600 slot->bitmap.width < 128U &&
4601 slot->bitmap.buffer )
4602 {
4603 int rows = (int)slot->bitmap.rows;
4604 int width = (int)slot->bitmap.width;
4605 int pitch = slot->bitmap.pitch;
4606 int i, j, m;
4607 unsigned char* topleft = slot->bitmap.buffer;
4608
4609 if ( pitch < 0 )
4610 topleft -= pitch * ( rows - 1 );
4611
4612 FT_TRACE7(( "Netpbm image: start\n" ));
4613 switch ( slot->bitmap.pixel_mode )
4614 {
4615 case FT_PIXEL_MODE_MONO:
4616 FT_TRACE7(( "P1 %d %d\n", width, rows ));
4617 for ( i = 0; i < rows; i++ )
4618 {
4619 for ( j = 0; j < width; )
4620 for ( m = 128; m > 0 && j < width; m >>= 1, j++ )
4621 FT_TRACE7(( " %d", ( topleft[i * pitch + j / 8] & m ) != 0 ));
4622 FT_TRACE7(( "\n" ));
4623 }
4624 break;
4625
4626 default:
4627 FT_TRACE7(( "P2 %d %d 255\n", width, rows ));
4628 for ( i = 0; i < rows; i++ )
4629 {
4630 for ( j = 0; j < width; j += 1 )
4631 FT_TRACE7(( " %3u", topleft[i * pitch + j] ));
4632 FT_TRACE7(( "\n" ));
4633 }
4634 }
4635 FT_TRACE7(( "Netpbm image: end\n" ));
4636 }
4637
4638 #undef FT_COMPONENT
4639 #define FT_COMPONENT trace_objs
4640
4641 #endif /* FT_DEBUG_LEVEL_TRACE */
4642
4643 return error;
4644 }
4645
4646
4647 /* documentation is in freetype.h */
4648
4649 FT_EXPORT_DEF( FT_Error )
4650 FT_Render_Glyph( FT_GlyphSlot slot,
4651 FT_Render_Mode render_mode )
4652 {
4653 FT_Library library;
4654
4655
4656 if ( !slot || !slot->face )
4657 return FT_THROW( Invalid_Argument );
4658
4659 library = FT_FACE_LIBRARY( slot->face );
4660
4661 return FT_Render_Glyph_Internal( library, slot, render_mode );
4662 }
4663
4664
4665 /*************************************************************************/
4666 /*************************************************************************/
4667 /*************************************************************************/
4668 /**** ****/
4669 /**** ****/
4670 /**** M O D U L E S ****/
4671 /**** ****/
4672 /**** ****/
4673 /*************************************************************************/
4674 /*************************************************************************/
4675 /*************************************************************************/
4676
4677
4678 /*************************************************************************/
4679 /* */
4680 /* <Function> */
4681 /* Destroy_Module */
4682 /* */
4683 /* <Description> */
4684 /* Destroys a given module object. For drivers, this also destroys */
4685 /* all child faces. */
4686 /* */
4687 /* <InOut> */
4688 /* module :: A handle to the target driver object. */
4689 /* */
4690 /* <Note> */
4691 /* The driver _must_ be LOCKED! */
4692 /* */
4693 static void
4694 Destroy_Module( FT_Module module )
4695 {
4696 FT_Memory memory = module->memory;
4697 FT_Module_Class* clazz = module->clazz;
4698 FT_Library library = module->library;
4699
4700
4701 if ( library && library->auto_hinter == module )
4702 library->auto_hinter = NULL;
4703
4704 /* if the module is a renderer */
4705 if ( FT_MODULE_IS_RENDERER( module ) )
4706 ft_remove_renderer( module );
4707
4708 /* if the module is a font driver, add some steps */
4709 if ( FT_MODULE_IS_DRIVER( module ) )
4710 Destroy_Driver( FT_DRIVER( module ) );
4711
4712 /* finalize the module object */
4713 if ( clazz->module_done )
4714 clazz->module_done( module );
4715
4716 /* discard it */
4717 FT_FREE( module );
4718 }
4719
4720
4721 /* documentation is in ftmodapi.h */
4722
4723 FT_EXPORT_DEF( FT_Error )
4724 FT_Add_Module( FT_Library library,
4725 const FT_Module_Class* clazz )
4726 {
4727 FT_Error error;
4728 FT_Memory memory;
4729 FT_Module module = NULL;
4730 FT_UInt nn;
4731
4732
4733 #define FREETYPE_VER_FIXED ( ( (FT_Long)FREETYPE_MAJOR << 16 ) | \
4734 FREETYPE_MINOR )
4735
4736 if ( !library )
4737 return FT_THROW( Invalid_Library_Handle );
4738
4739 if ( !clazz )
4740 return FT_THROW( Invalid_Argument );
4741
4742 /* check FreeType version */
4743 if ( clazz->module_requires > FREETYPE_VER_FIXED )
4744 return FT_THROW( Invalid_Version );
4745
4746 /* look for a module with the same name in the library's table */
4747 for ( nn = 0; nn < library->num_modules; nn++ )
4748 {
4749 module = library->modules[nn];
4750 if ( ft_strcmp( module->clazz->module_name, clazz->module_name ) == 0 )
4751 {
4752 /* this installed module has the same name, compare their versions */
4753 if ( clazz->module_version <= module->clazz->module_version )
4754 return FT_THROW( Lower_Module_Version );
4755
4756 /* remove the module from our list, then exit the loop to replace */
4757 /* it by our new version.. */
4758 FT_Remove_Module( library, module );
4759 break;
4760 }
4761 }
4762
4763 memory = library->memory;
4764 error = FT_Err_Ok;
4765
4766 if ( library->num_modules >= FT_MAX_MODULES )
4767 {
4768 error = FT_THROW( Too_Many_Drivers );
4769 goto Exit;
4770 }
4771
4772 /* allocate module object */
4773 if ( FT_ALLOC( module, clazz->module_size ) )
4774 goto Exit;
4775
4776 /* base initialization */
4777 module->library = library;
4778 module->memory = memory;
4779 module->clazz = (FT_Module_Class*)clazz;
4780
4781 /* check whether the module is a renderer - this must be performed */
4782 /* before the normal module initialization */
4783 if ( FT_MODULE_IS_RENDERER( module ) )
4784 {
4785 /* add to the renderers list */
4786 error = ft_add_renderer( module );
4787 if ( error )
4788 goto Fail;
4789 }
4790
4791 /* is the module a auto-hinter? */
4792 if ( FT_MODULE_IS_HINTER( module ) )
4793 library->auto_hinter = module;
4794
4795 /* if the module is a font driver */
4796 if ( FT_MODULE_IS_DRIVER( module ) )
4797 {
4798 FT_Driver driver = FT_DRIVER( module );
4799
4800
4801 driver->clazz = (FT_Driver_Class)module->clazz;
4802 }
4803
4804 if ( clazz->module_init )
4805 {
4806 error = clazz->module_init( module );
4807 if ( error )
4808 goto Fail;
4809 }
4810
4811 /* add module to the library's table */
4812 library->modules[library->num_modules++] = module;
4813
4814 Exit:
4815 return error;
4816
4817 Fail:
4818 if ( FT_MODULE_IS_RENDERER( module ) )
4819 {
4820 FT_Renderer renderer = FT_RENDERER( module );
4821
4822
4823 if ( renderer->clazz &&
4824 renderer->clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE &&
4825 renderer->raster )
4826 renderer->clazz->raster_class->raster_done( renderer->raster );
4827 }
4828
4829 FT_FREE( module );
4830 goto Exit;
4831 }
4832
4833
4834 /* documentation is in ftmodapi.h */
4835
4836 FT_EXPORT_DEF( FT_Module )
4837 FT_Get_Module( FT_Library library,
4838 const char* module_name )
4839 {
4840 FT_Module result = NULL;
4841 FT_Module* cur;
4842 FT_Module* limit;
4843
4844
4845 if ( !library || !module_name )
4846 return result;
4847
4848 cur = library->modules;
4849 limit = cur + library->num_modules;
4850
4851 for ( ; cur < limit; cur++ )
4852 if ( ft_strcmp( cur[0]->clazz->module_name, module_name ) == 0 )
4853 {
4854 result = cur[0];
4855 break;
4856 }
4857
4858 return result;
4859 }
4860
4861
4862 /* documentation is in ftobjs.h */
4863
4864 FT_BASE_DEF( const void* )
4865 FT_Get_Module_Interface( FT_Library library,
4866 const char* mod_name )
4867 {
4868 FT_Module module;
4869
4870
4871 /* test for valid `library' delayed to FT_Get_Module() */
4872
4873 module = FT_Get_Module( library, mod_name );
4874
4875 return module ? module->clazz->module_interface : 0;
4876 }
4877
4878
4879 FT_BASE_DEF( FT_Pointer )
4880 ft_module_get_service( FT_Module module,
4881 const char* service_id,
4882 FT_Bool global )
4883 {
4884 FT_Pointer result = NULL;
4885
4886
4887 if ( module )
4888 {
4889 FT_ASSERT( module->clazz && module->clazz->get_interface );
4890
4891 /* first, look for the service in the module */
4892 if ( module->clazz->get_interface )
4893 result = module->clazz->get_interface( module, service_id );
4894
4895 if ( global && !result )
4896 {
4897 /* we didn't find it, look in all other modules then */
4898 FT_Library library = module->library;
4899 FT_Module* cur = library->modules;
4900 FT_Module* limit = cur + library->num_modules;
4901
4902
4903 for ( ; cur < limit; cur++ )
4904 {
4905 if ( cur[0] != module )
4906 {
4907 FT_ASSERT( cur[0]->clazz );
4908
4909 if ( cur[0]->clazz->get_interface )
4910 {
4911 result = cur[0]->clazz->get_interface( cur[0], service_id );
4912 if ( result )
4913 break;
4914 }
4915 }
4916 }
4917 }
4918 }
4919
4920 return result;
4921 }
4922
4923
4924 /* documentation is in ftmodapi.h */
4925
4926 FT_EXPORT_DEF( FT_Error )
4927 FT_Remove_Module( FT_Library library,
4928 FT_Module module )
4929 {
4930 /* try to find the module from the table, then remove it from there */
4931
4932 if ( !library )
4933 return FT_THROW( Invalid_Library_Handle );
4934
4935 if ( module )
4936 {
4937 FT_Module* cur = library->modules;
4938 FT_Module* limit = cur + library->num_modules;
4939
4940
4941 for ( ; cur < limit; cur++ )
4942 {
4943 if ( cur[0] == module )
4944 {
4945 /* remove it from the table */
4946 library->num_modules--;
4947 limit--;
4948 while ( cur < limit )
4949 {
4950 cur[0] = cur[1];
4951 cur++;
4952 }
4953 limit[0] = NULL;
4954
4955 /* destroy the module */
4956 Destroy_Module( module );
4957
4958 return FT_Err_Ok;
4959 }
4960 }
4961 }
4962 return FT_THROW( Invalid_Driver_Handle );
4963 }
4964
4965
4966 static FT_Error
4967 ft_property_do( FT_Library library,
4968 const FT_String* module_name,
4969 const FT_String* property_name,
4970 void* value,
4971 FT_Bool set,
4972 FT_Bool value_is_string )
4973 {
4974 FT_Module* cur;
4975 FT_Module* limit;
4976 FT_Module_Interface interface;
4977
4978 FT_Service_Properties service;
4979
4980 #ifdef FT_DEBUG_LEVEL_ERROR
4981 const FT_String* set_name = "FT_Property_Set";
4982 const FT_String* get_name = "FT_Property_Get";
4983 const FT_String* func_name = set ? set_name : get_name;
4984 #endif
4985
4986 FT_Bool missing_func;
4987
4988
4989 if ( !library )
4990 return FT_THROW( Invalid_Library_Handle );
4991
4992 if ( !module_name || !property_name || !value )
4993 return FT_THROW( Invalid_Argument );
4994
4995 cur = library->modules;
4996 limit = cur + library->num_modules;
4997
4998 /* search module */
4999 for ( ; cur < limit; cur++ )
5000 if ( !ft_strcmp( cur[0]->clazz->module_name, module_name ) )
5001 break;
5002
5003 if ( cur == limit )
5004 {
5005 FT_ERROR(( "%s: can't find module `%s'\n",
5006 func_name, module_name ));
5007 return FT_THROW( Missing_Module );
5008 }
5009
5010 /* check whether we have a service interface */
5011 if ( !cur[0]->clazz->get_interface )
5012 {
5013 FT_ERROR(( "%s: module `%s' doesn't support properties\n",
5014 func_name, module_name ));
5015 return FT_THROW( Unimplemented_Feature );
5016 }
5017
5018 /* search property service */
5019 interface = cur[0]->clazz->get_interface( cur[0],
5020 FT_SERVICE_ID_PROPERTIES );
5021 if ( !interface )
5022 {
5023 FT_ERROR(( "%s: module `%s' doesn't support properties\n",
5024 func_name, module_name ));
5025 return FT_THROW( Unimplemented_Feature );
5026 }
5027
5028 service = (FT_Service_Properties)interface;
5029
5030 if ( set )
5031 missing_func = (FT_Bool)( !service->set_property );
5032 else
5033 missing_func = (FT_Bool)( !service->get_property );
5034
5035 if ( missing_func )
5036 {
5037 FT_ERROR(( "%s: property service of module `%s' is broken\n",
5038 func_name, module_name ));
5039 return FT_THROW( Unimplemented_Feature );
5040 }
5041
5042 return set ? service->set_property( cur[0],
5043 property_name,
5044 value,
5045 value_is_string )
5046 : service->get_property( cur[0],
5047 property_name,
5048 value );
5049 }
5050
5051
5052 /* documentation is in ftmodapi.h */
5053
5054 FT_EXPORT_DEF( FT_Error )
5055 FT_Property_Set( FT_Library library,
5056 const FT_String* module_name,
5057 const FT_String* property_name,
5058 const void* value )
5059 {
5060 return ft_property_do( library,
5061 module_name,
5062 property_name,
5063 (void*)value,
5064 TRUE,
5065 FALSE );
5066 }
5067
5068
5069 /* documentation is in ftmodapi.h */
5070
5071 FT_EXPORT_DEF( FT_Error )
5072 FT_Property_Get( FT_Library library,
5073 const FT_String* module_name,
5074 const FT_String* property_name,
5075 void* value )
5076 {
5077 return ft_property_do( library,
5078 module_name,
5079 property_name,
5080 value,
5081 FALSE,
5082 FALSE );
5083 }
5084
5085
5086 #ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
5087
5088 /* this variant is used for handling the FREETYPE_PROPERTIES */
5089 /* environment variable */
5090
5091 FT_BASE_DEF( FT_Error )
5092 ft_property_string_set( FT_Library library,
5093 const FT_String* module_name,
5094 const FT_String* property_name,
5095 FT_String* value )
5096 {
5097 return ft_property_do( library,
5098 module_name,
5099 property_name,
5100 (void*)value,
5101 TRUE,
5102 TRUE );
5103 }
5104
5105 #endif
5106
5107
5108 /*************************************************************************/
5109 /*************************************************************************/
5110 /*************************************************************************/
5111 /**** ****/
5112 /**** ****/
5113 /**** L I B R A R Y ****/
5114 /**** ****/
5115 /**** ****/
5116 /*************************************************************************/
5117 /*************************************************************************/
5118 /*************************************************************************/
5119
5120
5121 /* documentation is in ftmodapi.h */
5122
5123 FT_EXPORT_DEF( FT_Error )
5124 FT_Reference_Library( FT_Library library )
5125 {
5126 if ( !library )
5127 return FT_THROW( Invalid_Library_Handle );
5128
5129 library->refcount++;
5130
5131 return FT_Err_Ok;
5132 }
5133
5134
5135 /* documentation is in ftmodapi.h */
5136
5137 FT_EXPORT_DEF( FT_Error )
5138 FT_New_Library( FT_Memory memory,
5139 FT_Library *alibrary )
5140 {
5141 FT_Library library = NULL;
5142 FT_Error error;
5143
5144
5145 if ( !memory || !alibrary )
5146 return FT_THROW( Invalid_Argument );
5147
5148 #ifdef FT_DEBUG_LEVEL_ERROR
5149 /* init debugging support */
5150 ft_debug_init();
5151 #endif
5152
5153 /* first of all, allocate the library object */
5154 if ( FT_NEW( library ) )
5155 return error;
5156
5157 library->memory = memory;
5158
5159 #ifdef FT_CONFIG_OPTION_PIC
5160 /* initialize position independent code containers */
5161 error = ft_pic_container_init( library );
5162 if ( error )
5163 goto Fail;
5164 #endif
5165
5166 library->version_major = FREETYPE_MAJOR;
5167 library->version_minor = FREETYPE_MINOR;
5168 library->version_patch = FREETYPE_PATCH;
5169
5170 library->refcount = 1;
5171
5172 /* That's ok now */
5173 *alibrary = library;
5174
5175 return FT_Err_Ok;
5176
5177 #ifdef FT_CONFIG_OPTION_PIC
5178 Fail:
5179 ft_pic_container_destroy( library );
5180 FT_FREE( library );
5181 return error;
5182 #endif
5183 }
5184
5185
5186 /* documentation is in freetype.h */
5187
5188 FT_EXPORT_DEF( void )
5189 FT_Library_Version( FT_Library library,
5190 FT_Int *amajor,
5191 FT_Int *aminor,
5192 FT_Int *apatch )
5193 {
5194 FT_Int major = 0;
5195 FT_Int minor = 0;
5196 FT_Int patch = 0;
5197
5198
5199 if ( library )
5200 {
5201 major = library->version_major;
5202 minor = library->version_minor;
5203 patch = library->version_patch;
5204 }
5205
5206 if ( amajor )
5207 *amajor = major;
5208
5209 if ( aminor )
5210 *aminor = minor;
5211
5212 if ( apatch )
5213 *apatch = patch;
5214 }
5215
5216
5217 /* documentation is in ftmodapi.h */
5218
5219 FT_EXPORT_DEF( FT_Error )
5220 FT_Done_Library( FT_Library library )
5221 {
5222 FT_Memory memory;
5223
5224
5225 if ( !library )
5226 return FT_THROW( Invalid_Library_Handle );
5227
5228 library->refcount--;
5229 if ( library->refcount > 0 )
5230 goto Exit;
5231
5232 memory = library->memory;
5233
5234 /*
5235 * Close all faces in the library. If we don't do this, we can have
5236 * some subtle memory leaks.
5237 *
5238 * Example:
5239 *
5240 * - the cff font driver uses the pshinter module in cff_size_done
5241 * - if the pshinter module is destroyed before the cff font driver,
5242 * opened FT_Face objects managed by the driver are not properly
5243 * destroyed, resulting in a memory leak
5244 *
5245 * Some faces are dependent on other faces, like Type42 faces that
5246 * depend on TrueType faces synthesized internally.
5247 *
5248 * The order of drivers should be specified in driver_name[].
5249 */
5250 {
5251 FT_UInt m, n;
5252 const char* driver_name[] = { "type42", NULL };
5253
5254
5255 for ( m = 0;
5256 m < sizeof ( driver_name ) / sizeof ( driver_name[0] );
5257 m++ )
5258 {
5259 for ( n = 0; n < library->num_modules; n++ )
5260 {
5261 FT_Module module = library->modules[n];
5262 const char* module_name = module->clazz->module_name;
5263 FT_List faces;
5264
5265
5266 if ( driver_name[m] &&
5267 ft_strcmp( module_name, driver_name[m] ) != 0 )
5268 continue;
5269
5270 if ( ( module->clazz->module_flags & FT_MODULE_FONT_DRIVER ) == 0 )
5271 continue;
5272
5273 FT_TRACE7(( "FT_Done_Library: close faces for %s\n", module_name ));
5274
5275 faces = &FT_DRIVER( module )->faces_list;
5276 while ( faces->head )
5277 {
5278 FT_Done_Face( FT_FACE( faces->head->data ) );
5279 if ( faces->head )
5280 FT_TRACE0(( "FT_Done_Library: failed to free some faces\n" ));
5281 }
5282 }
5283 }
5284 }
5285
5286 /* Close all other modules in the library */
5287 #if 1
5288 /* XXX Modules are removed in the reversed order so that */
5289 /* type42 module is removed before truetype module. This */
5290 /* avoids double free in some occasions. It is a hack. */
5291 while ( library->num_modules > 0 )
5292 FT_Remove_Module( library,
5293 library->modules[library->num_modules - 1] );
5294 #else
5295 {
5296 FT_UInt n;
5297
5298
5299 for ( n = 0; n < library->num_modules; n++ )
5300 {
5301 FT_Module module = library->modules[n];
5302
5303
5304 if ( module )
5305 {
5306 Destroy_Module( module );
5307 library->modules[n] = NULL;
5308 }
5309 }
5310 }
5311 #endif
5312
5313 #ifdef FT_CONFIG_OPTION_PIC
5314 /* Destroy pic container contents */
5315 ft_pic_container_destroy( library );
5316 #endif
5317
5318 FT_FREE( library );
5319
5320 Exit:
5321 return FT_Err_Ok;
5322 }
5323
5324
5325 /* documentation is in ftmodapi.h */
5326
5327 FT_EXPORT_DEF( void )
5328 FT_Set_Debug_Hook( FT_Library library,
5329 FT_UInt hook_index,
5330 FT_DebugHook_Func debug_hook )
5331 {
5332 if ( library && debug_hook &&
5333 hook_index <
5334 ( sizeof ( library->debug_hooks ) / sizeof ( void* ) ) )
5335 library->debug_hooks[hook_index] = debug_hook;
5336 }
5337
5338
5339 /* documentation is in ftmodapi.h */
5340
5341 FT_EXPORT_DEF( FT_TrueTypeEngineType )
5342 FT_Get_TrueType_Engine_Type( FT_Library library )
5343 {
5344 FT_TrueTypeEngineType result = FT_TRUETYPE_ENGINE_TYPE_NONE;
5345
5346
5347 if ( library )
5348 {
5349 FT_Module module = FT_Get_Module( library, "truetype" );
5350
5351
5352 if ( module )
5353 {
5354 FT_Service_TrueTypeEngine service;
5355
5356
5357 service = (FT_Service_TrueTypeEngine)
5358 ft_module_get_service( module,
5359 FT_SERVICE_ID_TRUETYPE_ENGINE,
5360 0 );
5361 if ( service )
5362 result = service->engine_type;
5363 }
5364 }
5365
5366 return result;
5367 }
5368
5369
5370 /* documentation is in freetype.h */
5371
5372 FT_EXPORT_DEF( FT_Error )
5373 FT_Get_SubGlyph_Info( FT_GlyphSlot glyph,
5374 FT_UInt sub_index,
5375 FT_Int *p_index,
5376 FT_UInt *p_flags,
5377 FT_Int *p_arg1,
5378 FT_Int *p_arg2,
5379 FT_Matrix *p_transform )
5380 {
5381 FT_Error error = FT_ERR( Invalid_Argument );
5382
5383
5384 if ( glyph &&
5385 glyph->subglyphs &&
5386 glyph->format == FT_GLYPH_FORMAT_COMPOSITE &&
5387 sub_index < glyph->num_subglyphs )
5388 {
5389 FT_SubGlyph subg = glyph->subglyphs + sub_index;
5390
5391
5392 *p_index = subg->index;
5393 *p_flags = subg->flags;
5394 *p_arg1 = subg->arg1;
5395 *p_arg2 = subg->arg2;
5396 *p_transform = subg->transform;
5397
5398 error = FT_Err_Ok;
5399 }
5400
5401 return error;
5402 }
5403
5404
5405 /* END */