/******************************************************************* * * t1gload.c 1.0 * * Type1 Glyph Loader. * * Copyright 1996-1999 by * David Turner, Robert Wilhelm, and Werner Lemberg. * * This file is part of the FreeType project, and may only be used * modified and distributed under the terms of the FreeType project * license, LICENSE.TXT. By continuing to use, modify, or distribute * this file you indicate that you have read the license and * understand and accept it fully. * ******************************************************************/ #include #include #include #undef FT_COMPONENT #define FT_COMPONENT trace_t1gload typedef enum T1_Operator_ { op_none = 0, op_endchar, op_hsbw, op_seac, op_sbw, op_closepath, op_hlineto, op_hmoveto, op_hvcurveto, op_rlineto, op_rmoveto, op_rrcurveto, op_vhcurveto, op_vlineto, op_vmoveto, op_dotsection, op_hstem, op_hstem3, op_vstem, op_vstem3, op_div, op_callothersubr, op_callsubr, op_pop, op_return, op_setcurrentpoint, op_max /* never remove this one */ } T1_Operator; static const T1_Int t1_args_count[ op_max ] = { 0, /* none */ 0, /* endchar */ 2, /* hsbw */ 5, /* seac */ 4, /* sbw */ 0, /* closepath */ 1, /* hlineto */ 1, /* hmoveto */ 4, /* hvcurveto */ 2, /* rlineto */ 2, /* rmoveto */ 6, /* rrcurveto */ 4, /* vhcurveto */ 1, /* vlineto */ 1, /* vmoveto */ 0, /* dotsection */ 2, /* hstem */ 6, /* hstem3 */ 2, /* vstem */ 6, /* vstem3 */ 2, /* div */ -1, /* callothersubr */ 1, /* callsubr */ 0, /* pop */ 0, /* return */ 2 /* setcurrentpoint */ }; /**********************************************************************/ /**********************************************************************/ /**********************************************************************/ /********** *********/ /********** *********/ /********** GENERIC CHARSTRINGS PARSING *********/ /********** *********/ /********** *********/ /**********************************************************************/ /**********************************************************************/ /**********************************************************************/ /********************************************************************* * * * T1_Init_Builder * * * Initialise a given glyph builder. * * * builder :: glyph builder to initialise * face :: current face object * size :: current size object * glyph :: current glyph object * *********************************************************************/ LOCAL_FUNC void T1_Init_Builder( T1_Builder* builder, T1_Face face, T1_Size size, T1_GlyphSlot glyph ) { builder->path_begun = 0; builder->load_points = 1; builder->face = face; builder->glyph = glyph; builder->memory = face->root.memory; if (glyph) { builder->base = glyph->root.outline; builder->max_points = glyph->max_points; builder->max_contours = glyph->max_contours; } if (size) { builder->scale_x = size->root.metrics.x_scale; builder->scale_y = size->root.metrics.y_scale; } builder->pos_x = 0; builder->pos_y = 0; builder->left_bearing.x = 0; builder->left_bearing.y = 0; builder->advance.x = 0; builder->advance.y = 0; builder->base.n_points = 0; builder->base.n_contours = 0; builder->current = builder->base; } /********************************************************************* * * * T1_Done_Builder * * * Finalise a given glyph builder. Its content can still be * used after the call, but the function saves important information * within the corresponding glyph slot. * * * builder :: glyph builder to initialise * *********************************************************************/ LOCAL_FUNC void T1_Done_Builder( T1_Builder* builder ) { T1_GlyphSlot glyph = builder->glyph; if (glyph) { glyph->root.outline = builder->base; glyph->max_points = builder->max_points; glyph->max_contours = builder->max_contours; } } /********************************************************************* * * * T1_Init_Decoder * * * Initialise a given Type 1 decoder for parsing * * * decoder :: Type 1 decoder to initialise * funcs :: hinter functions interface * *********************************************************************/ EXPORT_FUNC void T1_Init_Decoder( T1_Decoder* decoder ) { decoder->top = 0; decoder->zone = 0; decoder->flex_state = 0; decoder->num_flex_vectors = 0; /* Clear loader */ MEM_Set( &decoder->builder, 0, sizeof(decoder->builder) ); } /* check that there is enough room for "count" more points */ static T1_Error check_points( T1_Builder* builder, T1_Int count ) { FT_Outline* base = &builder->base; FT_Outline* outline = &builder->current; if (!builder->load_points) return T1_Err_Ok; count += base->n_points + outline->n_points; /* realloc points table if necessary */ if ( count >= builder->max_points ) { T1_Error error; FT_Memory memory = builder->memory; T1_Int increment = outline->points - base->points; T1_Int current = builder->max_points; while ( builder->max_points < count ) builder->max_points += 8; if ( REALLOC_ARRAY( base->points, current, builder->max_points, T1_Vector ) || REALLOC_ARRAY( base->flags, current, builder->max_points, T1_Byte ) ) { builder->error = error; return error; } outline->points = base->points + increment; outline->flags = base->flags + increment; } return T1_Err_Ok; } /* add a new point, do not check room */ static void add_point( T1_Builder* builder, FT_Pos x, FT_Pos y, FT_Byte flag ) { FT_Outline* outline = &builder->current; if (builder->load_points) { FT_Vector* point = outline->points + outline->n_points; FT_Byte* control = (FT_Byte*)outline->flags + outline->n_points; point->x = x; point->y = y; *control = ( flag ? FT_Curve_Tag_On : FT_Curve_Tag_Cubic ); builder->last = *point; } outline->n_points++; } /* check room for a new on-curve point, then add it */ static T1_Error add_point1( T1_Builder* builder, FT_Pos x, FT_Pos y ) { T1_Error error; error = check_points(builder,1); if (!error) add_point( builder, x, y, 1 ); return error; } /* check room for a new contour, then add it */ static T1_Error add_contour( T1_Builder* builder ) { FT_Outline* base = &builder->base; FT_Outline* outline = &builder->current; if (!builder->load_points) { outline->n_contours++; return T1_Err_Ok; } /* realloc contours array if necessary */ if ( base->n_contours + outline->n_contours >= builder->max_contours && builder->load_points ) { T1_Error error; FT_Memory memory = builder->memory; T1_Int increment = outline->contours - base->contours; T1_Int current = builder->max_contours; builder->max_contours += 4; if ( REALLOC_ARRAY( base->contours, current, builder->max_contours, T1_Short ) ) { builder->error = error; return error; } outline->contours = base->contours + increment; } if (outline->n_contours > 0) outline->contours[ outline->n_contours-1 ] = outline->n_points-1; outline->n_contours++; return T1_Err_Ok; } /* if a path was begun, add its first on-curve point */ static T1_Error start_point( T1_Builder* builder, T1_Pos x, T1_Pos y ) { /* test wether we're building a new contour */ if (!builder->path_begun) { T1_Error error; builder->path_begun = 1; error = add_contour( builder ); if (error) return error; } return add_point1( builder, x, y ); } /* close the current contour */ static void close_contour( T1_Builder* builder ) { FT_Outline* outline = &builder->current; if ( outline->n_contours > 0 ) outline->contours[outline->n_contours-1] = outline->n_points-1; } /********************************************************************* * * * lookup_glyph_by_stdcharcode * * * Lookup a given glyph by its StandardEncoding charcode. Used * to implement the SEAC Type 1 operator. * * * face :: current face object * charcode :: charcode to look for * * * glyph index in font face. Returns -1 if the corresponding * glyph wasn't found. * *********************************************************************/ static T1_Int lookup_glyph_by_stdcharcode( T1_Face face, T1_Int charcode ) { T1_Int n; const T1_String* glyph_name; PSNames_Interface* psnames = (PSNames_Interface*)face->psnames; /* check range of standard char code */ if (charcode < 0 || charcode > 255) return -1; glyph_name = psnames->adobe_std_strings( psnames->adobe_std_encoding[charcode]); for ( n = 0; n < face->type1.num_glyphs; n++ ) { T1_String* name = (T1_String*)face->type1.glyph_names[n]; if ( name && strcmp(name,glyph_name) == 0 ) return n; } return -1; } /********************************************************************* * * * t1operator_seac * * * Implements the "seac" Type 1 operator for a Type 1 decoder * * * decoder :: current Type 1 decoder * asb :: accent's side bearing * adx :: horizontal position of accent * ady :: vertical position of accent * bchar :: base character's StandardEncoding charcode * achar :: accent character's StandardEncoding charcode * * * Error code. 0 means success. * *********************************************************************/ static T1_Error t1operator_seac( T1_Decoder* decoder, T1_Pos asb, T1_Pos adx, T1_Pos ady, T1_Int bchar, T1_Int achar ) { T1_Error error; T1_Face face = decoder->builder.face; T1_Int bchar_index, achar_index, n_base_points; FT_Outline* cur = &decoder->builder.current; FT_Outline* base = &decoder->builder.base; T1_Vector left_bearing, advance; T1_Font* type1 = &face->type1; bchar_index = lookup_glyph_by_stdcharcode( face, bchar ); achar_index = lookup_glyph_by_stdcharcode( face, achar ); if (bchar_index < 0 || achar_index < 0) { FT_ERROR(( "T1.Parse_Seac : invalid seac character code arguments\n" )); return T1_Err_Syntax_Error; } /* First load "bchar" in builder */ /* now load the unscaled outline */ cur->n_points = 0; cur->n_contours = 0; cur->points = base->points + base->n_points; cur->flags = base->flags + base->n_points; cur->contours = base->contours + base->n_contours; error = T1_Parse_CharStrings( decoder, type1->charstrings [bchar_index], type1->charstrings_len[bchar_index], type1->num_subrs, type1->subrs, type1->subrs_len ); if (error) return error; n_base_points = cur->n_points; /* save the left bearing and width of the base character */ /* as they will be erase by the next load.. */ left_bearing = decoder->builder.left_bearing; advance = decoder->builder.advance; decoder->builder.left_bearing.x = 0; decoder->builder.left_bearing.y = 0; /* Now load "achar" on top of */ /* the base outline */ /* */ cur->n_points = 0; cur->n_contours = 0; cur->points = base->points + base->n_points; cur->flags = base->flags + base->n_points; cur->contours = base->contours + base->n_contours; error = T1_Parse_CharStrings( decoder, type1->charstrings [achar_index], type1->charstrings_len[achar_index], type1->num_subrs, type1->subrs, type1->subrs_len ); if (error) return error; /* adjust contours in accented character outline */ if (decoder->builder.load_points) { T1_Int n; for ( n = 0; n < cur->n_contours; n++ ) cur->contours[n] += n_base_points; } /* restore the left side bearing and */ /* advance width of the base character */ decoder->builder.left_bearing = left_bearing; decoder->builder.advance = advance; /* Finally, move the accent */ if (decoder->builder.load_points) FT_Translate_Outline( cur, adx - asb, ady ); (void)asb; /* ignore this parameter */ return T1_Err_Ok; } /********************************************************************* * * * T1_Parse_CharStrings * * * Parses a given Type 1 charstrings program * * * decoder :: current Type 1 decoder * charstring_base :: base of the charstring stream * charstring_len :: length in bytes of the charstring stream * num_subrs :: number of sub-routines * subrs_base :: array of sub-routines addresses * subrs_len :: array of sub-routines lengths * * * Error code. 0 means success. * *********************************************************************/ #define USE_ARGS(n) top -= n; if (top < decoder->stack) goto Stack_Underflow EXPORT_FUNC T1_Error T1_Parse_CharStrings( T1_Decoder* decoder, T1_Byte* charstring_base, T1_Int charstring_len, T1_Int num_subrs, T1_Byte** subrs_base, T1_Int* subrs_len ) { T1_Error error; T1_Decoder_Zone* zone; T1_Byte* ip; T1_Byte* limit; T1_Builder* builder = &decoder->builder; FT_Outline* outline; T1_Pos x, y; /* First of all, initialise the decoder */ decoder->top = decoder->stack; decoder->zone = decoder->zones; zone = decoder->zones; builder->path_begun = 0; zone->base = charstring_base; limit = zone->limit = charstring_base + charstring_len; ip = zone->cursor = zone->base; error = T1_Err_Ok; outline = &builder->current; x = builder->pos_x; y = builder->pos_y; /* now, execute loop */ while ( ip < limit ) { T1_Int* top = decoder->top; T1_Operator op = op_none; T1_Long value = 0; /********************************************************************/ /* */ /* Decode operator or operand */ /* */ /* */ /* First of all, decompress operator or value */ switch (*ip++) { case 1: op = op_hstem; break; case 3: op = op_vstem; break; case 4: op = op_vmoveto; break; case 5: op = op_rlineto; break; case 6: op = op_hlineto; break; case 7: op = op_vlineto; break; case 8: op = op_rrcurveto; break; case 9: op = op_closepath; break; case 10: op = op_callsubr; break; case 11: op = op_return; break; case 13: op = op_hsbw; break; case 14: op = op_endchar; break; case 21: op = op_rmoveto; break; case 22: op = op_hmoveto; break; case 30: op = op_vhcurveto; break; case 31: op = op_hvcurveto; break; case 12: { if (ip > limit) { FT_ERROR(( "T1.Parse_CharStrings : invalid escape (12+EOF)\n" )); goto Syntax_Error; } switch (*ip++) { case 0: op = op_dotsection; break; case 1: op = op_vstem3; break; case 2: op = op_hstem3; break; case 6: op = op_seac; break; case 7: op = op_sbw; break; case 12: op = op_div; break; case 16: op = op_callothersubr; break; case 17: op = op_pop; break; case 33: op = op_setcurrentpoint; break; default: FT_ERROR(( "T1.Parse_CharStrings : invalid escape (12+%d)\n", ip[-1] )); goto Syntax_Error; } } break; case 255: /* four bytes integer */ { if (ip+4 > limit) { FT_ERROR(( "T1.Parse_CharStrings : unexpected EOF in integer\n" )); goto Syntax_Error; } value = ((long)ip[0] << 24) | ((long)ip[1] << 16) | ((long)ip[2] << 8) | ip[3]; ip += 4; } break; default: if (ip[-1] >= 32) { if (ip[-1] < 247) value = (long)ip[-1] - 139; else { if (++ip > limit) { FT_ERROR(( "T1.Parse_CharStrings : unexpected EOF in integer\n" )); goto Syntax_Error; } if (ip[-2] < 251) value = ((long)(ip[-2]-247) << 8) + ip[-1] + 108; else value = -((((long)ip[-2]-251) << 8) + ip[-1] + 108 ); } } else { FT_ERROR(( "T1.Parse_CharStrings : invalid byte (%d)\n", ip[-1] )); goto Syntax_Error; } } /********************************************************************/ /* */ /* Push value on stack, or process operator */ /* */ /* */ if ( op == op_none ) { if ( top - decoder->stack >= T1_MAX_CHARSTRINGS_OPERANDS ) { FT_ERROR(( "T1.Parse_CharStrings : Stack overflow !!\n" )); goto Syntax_Error; } FT_TRACE4(( " %ld", value )); *top++ = value; decoder->top = top; } else if ( op == op_callothersubr ) /* callothersubr */ { FT_TRACE4(( " callothersubr" )); if ( top - decoder->stack < 2 ) goto Stack_Underflow; top -= 2; switch ( top[1] ) { case 1: /* start flex feature ---------------------- */ { if ( top[0] != 0 ) goto Unexpected_OtherSubr; decoder->flex_state = 1; decoder->num_flex_vectors = 0; if ( start_point(builder, x, y) || check_points(builder,6) ) goto Memory_Error; } break; case 2: /* add flex vectors ------------------------ */ { T1_Int index; if ( top[0] != 0 ) goto Unexpected_OtherSubr; /* note that we should not add a point for index 0 */ /* this will move our current position to the flex */ /* point without adding any point to the outline */ index = decoder->num_flex_vectors++; if (index > 0 && index < 7) add_point( builder, x, y, (T1_Byte)( index==3 || index==6 ) ); } break; case 0: /* end flex feature ------------------------- */ { if ( top[0] != 3 ) goto Unexpected_OtherSubr; if ( decoder->flex_state == 0 || decoder->num_flex_vectors != 7 ) { FT_ERROR(( "T1.Parse_CharStrings: unexpected flex end\n" )); goto Syntax_Error; } /* now consume the remaining "pop pop setcurpoint" */ if ( ip+6 > limit || ip[0] != 12 || ip[1] != 17 || /* pop */ ip[2] != 12 || ip[3] != 17 || /* pop */ ip[4] != 12 || ip[5] != 33 ) /* setcurpoint */ { FT_ERROR(( "T1.Parse_CharStrings: invalid flex charstring\n" )); goto Syntax_Error; } ip += 6; decoder->flex_state = 0; break; } case 3: /* change hints ---------------------------- */ { if ( top[0] != 1 ) goto Unexpected_OtherSubr; /* eat the following "pop" */ if (ip+2 > limit) { FT_ERROR(( "T1.Parse_CharStrings: invalid escape (12+%d)\n", ip[-1] )); goto Syntax_Error; } if (ip[0] != 12 || ip[1] != 17) { FT_ERROR(( "T1.Parse_CharStrings: 'pop' expected, found (%d %d)\n", ip[0], ip[1] )); goto Syntax_Error; } ip += 2; break;; } default: Unexpected_OtherSubr: FT_ERROR(( "T1.Parse_CharStrings: invalid othersubr [%d %d]!!\n", top[0], top[1] )); goto Syntax_Error; } decoder->top = top; } else /* general operator */ { T1_Int num_args = t1_args_count[op]; if ( top - decoder->stack < num_args ) goto Stack_Underflow; top -= num_args; switch (op) { case op_endchar: /*************************************************/ { FT_TRACE4(( " endchar" )); close_contour( builder ); /* add current outline to the glyph slot */ builder->base.n_points += builder->current.n_points; builder->base.n_contours += builder->current.n_contours; /* return now !! */ FT_TRACE4(( "\n\n" )); return T1_Err_Ok; } case op_hsbw: /****************************************************/ { FT_TRACE4(( " hsbw" )); builder->left_bearing.x += top[0]; builder->advance.x = top[1]; builder->advance.y = 0; builder->last.x = x = top[0]; builder->last.y = y = 0; /* the "metrics_only" indicates that we only want to compute */ /* the glyph's metrics (lsb + advance width), not load the */ /* rest of it.. so exit immediately */ if (builder->metrics_only) return T1_Err_Ok; break; } case op_seac: /****************************************************/ /* return immediately after the processing */ return t1operator_seac( decoder, top[0], top[1], top[2], top[3], top[4] ); case op_sbw: /****************************************************/ { FT_TRACE4(( " sbw" )); builder->left_bearing.x += top[0]; builder->left_bearing.y += top[1]; builder->advance.x = top[2]; builder->advance.y = top[3]; builder->last.x = x = top[0]; builder->last.y = y = top[1]; /* the "metrics_only" indicates that we only want to compute */ /* the glyph's metrics (lsb + advance width), not load the */ /* rest of it.. so exit immediately */ if (builder->metrics_only) return T1_Err_Ok; break; } case op_closepath: /**********************************************/ { FT_TRACE4(( " closepath" )); close_contour( builder ); builder->path_begun = 0; } break; case op_hlineto: /************************************************/ { FT_TRACE4(( " hlineto" )); if ( start_point( builder, x, y ) ) goto Memory_Error; x += top[0]; goto Add_Line; } case op_hmoveto: /************************************************/ { FT_TRACE4(( " hmoveto" )); x += top[0]; break; } case op_hvcurveto: /**********************************************/ { FT_TRACE4(( " hvcurveto" )); if ( start_point( builder, x, y ) || check_points( builder, 3 ) ) goto Memory_Error; x += top[0]; add_point( builder, x, y, 0 ); x += top[1]; y += top[2]; add_point( builder, x, y, 0 ); y += top[3]; add_point( builder, x, y, 1 ); break; } case op_rlineto: /*************************************************/ { FT_TRACE4(( " rlineto" )); if ( start_point( builder, x, y ) ) goto Memory_Error; x += top[0]; y += top[1]; Add_Line: if (add_point1( builder, x, y )) goto Memory_Error; break; } case op_rmoveto: /*************************************************/ { FT_TRACE4(( " rmoveto" )); x += top[0]; y += top[1]; break; } case op_rrcurveto: /***********************************************/ { FT_TRACE4(( " rcurveto" )); if ( start_point( builder, x, y ) || check_points( builder, 3 ) ) goto Memory_Error; x += top[0]; y += top[1]; add_point( builder, x, y, 0 ); x += top[2]; y += top[3]; add_point( builder, x, y, 0 ); x += top[4]; y += top[5]; add_point( builder, x, y, 1 ); break; } case op_vhcurveto: /**********************************************/ { FT_TRACE4(( " vhcurveto" )); if ( start_point( builder, x, y ) || check_points( builder, 3 ) ) goto Memory_Error; y += top[0]; add_point( builder, x, y, 0 ); x += top[1]; y += top[2]; add_point( builder, x, y, 0 ); x += top[3]; add_point( builder, x, y, 1 ); break; } case op_vlineto: /************************************************/ { FT_TRACE4(( " vlineto" )); if ( start_point( builder, x, y ) ) goto Memory_Error; y += top[0]; goto Add_Line; } case op_vmoveto: /************************************************/ { FT_TRACE4(( " vmoveto" )); y += top[0]; break; } case op_div: /****************************************************/ { FT_TRACE4(( " div" )); if (top[1]) *top++ = top[0] / top[1]; else { FT_ERROR(( "T1.Parse_CharStrings : division by 0\n" )); goto Syntax_Error; } break; } case op_callsubr: /***********************************************/ { T1_Int index; FT_TRACE4(( " callsubr" )); index = top[0]; if ( index < 0 || index >= num_subrs ) { FT_ERROR(( "T1.Parse_CharStrings : invalid subrs index\n" )); goto Syntax_Error; } if ( zone - decoder->zones >= T1_MAX_SUBRS_CALLS ) { FT_ERROR(( "T1.Parse_CharStrings : too many nested subrs\n" )); goto Syntax_Error; } zone->cursor = ip; /* save current instruction pointer */ zone++; zone->base = subrs_base[index]; zone->limit = zone->base + subrs_len[index]; zone->cursor = zone->base; if (!zone->base) { FT_ERROR(( "T1.Parse_CharStrings : invoking empty subrs !!\n" )); goto Syntax_Error; } decoder->zone = zone; ip = zone->base; limit = zone->limit; break; } case op_pop: /****************************************************/ { FT_TRACE4(( " pop" )); FT_ERROR(( "T1.Parse_CharStrings : unexpected POP\n" )); goto Syntax_Error; } case op_return: /************************************************/ { FT_TRACE4(( " return" )); if ( zone <= decoder->zones ) { FT_ERROR(( "T1.Parse_CharStrings : unexpected return\n" )); goto Syntax_Error; } zone--; ip = zone->cursor; limit = zone->limit; decoder->zone = zone; break; } case op_dotsection: /*********************************************/ { FT_TRACE4(( " dotsection" )); break; } case op_hstem: /**************************************************/ { FT_TRACE4(( " hstem" )); break; } case op_hstem3: /*************************************************/ { FT_TRACE4(( " hstem3" )); break; } case op_vstem: /**************************************************/ { FT_TRACE4(( " vstem" )); break; } case op_vstem3: /*************************************************/ { FT_TRACE4(( " vstem3" )); break; } case op_setcurrentpoint: /*****************************************/ { FT_TRACE4(( " setcurrentpoint" )); FT_ERROR(( "T1.Parse_CharStrings : unexpected SETCURRENTPOINT\n" )); goto Syntax_Error; } default: FT_ERROR(( "T1.Parse_CharStrings : unhandled opcode %d\n", op )); goto Syntax_Error; } decoder->top = top; } /* general operator processing */ } /* while ip < limit */ FT_TRACE4(( "..end..\n\n" )); return error; Syntax_Error: return T1_Err_Syntax_Error; Stack_Underflow: return T1_Err_Stack_Underflow; Memory_Error: return builder->error; } /**********************************************************************/ /**********************************************************************/ /**********************************************************************/ /********** *********/ /********** *********/ /********** COMPUTE THE MAXIMUM ADVANCE WIDTH *********/ /********** *********/ /********** The following code is in charge of computing *********/ /********** the maximum advance width of the font. It *********/ /********** quickly process each glyph charstring to *********/ /********** extract the value from either a "sbw" or "seac" *********/ /********** operator. *********/ /********** *********/ /**********************************************************************/ /**********************************************************************/ /**********************************************************************/ LOCAL_FUNC T1_Error T1_Compute_Max_Advance( T1_Face face, T1_Int *max_advance ) { T1_Error error; T1_Decoder decoder; T1_Int glyph_index; T1_Font* type1 = &face->type1; *max_advance = 0; /* Initialise load decoder */ T1_Init_Decoder( &decoder ); T1_Init_Builder( &decoder.builder, face, 0, 0 ); decoder.builder.metrics_only = 1; decoder.builder.load_points = 0; /* For each glyph, parse the glyph charstring and extract */ /* the advance width.. */ for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ ) { /* now get load the unscaled outline */ error = T1_Parse_CharStrings( &decoder, type1->charstrings [glyph_index], type1->charstrings_len[glyph_index], type1->num_subrs, type1->subrs, type1->subrs_len ); /* ignore the error if one occured - skip to next glyph */ (void)error; } *max_advance = decoder.builder.advance.x; return T1_Err_Ok; } /**********************************************************************/ /**********************************************************************/ /**********************************************************************/ /********** *********/ /********** *********/ /********** UNHINTED GLYPH LOADER *********/ /********** *********/ /********** The following code is in charge of loading a *********/ /********** single outline. It completely ignores hinting *********/ /********** and is used when FT_LOAD_NO_HINTING is set. *********/ /********** *********/ /**********************************************************************/ /**********************************************************************/ /**********************************************************************/ LOCAL_FUNC T1_Error T1_Load_Glyph( T1_GlyphSlot glyph, T1_Size size, T1_Int glyph_index, T1_Int load_flags ) { T1_Error error; T1_Decoder decoder; T1_Face face = (T1_Face)glyph->root.face; T1_Bool hinting; T1_Font* type1 = &face->type1; glyph->x_scale = size->root.metrics.x_scale; glyph->y_scale = size->root.metrics.y_scale; glyph->root.outline.n_points = 0; glyph->root.outline.n_contours = 0; hinting = ( load_flags & FT_LOAD_NO_SCALE ) == 0 && ( load_flags & FT_LOAD_NO_HINTING ) == 0; glyph->root.format = ft_glyph_format_none; { T1_Init_Decoder( &decoder ); T1_Init_Builder( &decoder.builder, face, size, glyph ); /* now load the unscaled outline */ error = T1_Parse_CharStrings( &decoder, type1->charstrings [glyph_index], type1->charstrings_len[glyph_index], type1->num_subrs, type1->subrs, type1->subrs_len ); /* save new glyph tables */ T1_Done_Builder( &decoder.builder ); } /* Now, set the metrics.. - this is rather simple, as : */ /* the left side bearing is the xMin, and the top side */ /* bearing the yMax.. */ if (!error) { FT_BBox cbox; FT_Glyph_Metrics* metrics = &glyph->root.metrics; FT_Get_Outline_CBox( &glyph->root.outline, &cbox ); /* grid fit the bounding box if necessary */ if (hinting) { cbox.xMin &= -64; cbox.yMin &= -64; cbox.xMax = ( cbox.xMax+63 ) & -64; cbox.yMax = ( cbox.yMax+63 ) & -64; } metrics->width = cbox.xMax - cbox.xMin; metrics->height = cbox.yMax - cbox.yMin; metrics->horiBearingX = cbox.xMin; metrics->horiBearingY = cbox.yMax; /* copy the _unscaled_ advance width */ metrics->horiAdvance = decoder.builder.advance.x; /* make up vertical metrics */ metrics->vertBearingX = 0; metrics->vertBearingY = 0; metrics->vertAdvance = 0; glyph->root.format = ft_glyph_format_outline; glyph->root.outline.second_pass = TRUE; glyph->root.outline.high_precision = ( size->root.metrics.y_ppem < 24 ); glyph->root.outline.dropout_mode = 2; if ( (load_flags & FT_LOAD_NO_SCALE) == 0 ) { /* scale the outline and the metrics */ T1_Int n; FT_Outline* cur = &decoder.builder.base; T1_Vector* vec = cur->points; T1_Fixed x_scale = glyph->x_scale; T1_Fixed y_scale = glyph->y_scale; /* First of all, scale the points */ for ( n = cur->n_points; n > 0; n--, vec++ ) { vec->x = FT_MulFix( vec->x, x_scale ); vec->y = FT_MulFix( vec->y, y_scale ); } /* Then scale the metrics */ metrics->width = FT_MulFix( metrics->width, x_scale ); metrics->height = FT_MulFix( metrics->height, y_scale ); metrics->horiBearingX = FT_MulFix( metrics->horiBearingX, x_scale ); metrics->horiBearingY = FT_MulFix( metrics->horiBearingY, y_scale ); metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale ); metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale ); metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale ); metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, x_scale ); } } return error; }