| /***************************************************************************/ |
| /* */ |
| /* ttgload.c */ |
| /* */ |
| /* TrueType Glyph Loader (body). */ |
| /* */ |
| /* 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 <freetype.h> |
| #include <ftdebug.h> |
| #include <ftcalc.h> |
| #include <ftstream.h> |
| |
| #include <sfnt.h> |
| #include <ttgload.h> |
| |
| #include <tttags.h> |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| #include <ttinterp.h> |
| #endif |
| |
| /* required for the tracing mode */ |
| #undef FT_COMPONENT |
| #define FT_COMPONENT trace_ttgload |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* Composite font flags. */ |
| /* */ |
| #define ARGS_ARE_WORDS 0x001 |
| #define ARGS_ARE_XY_VALUES 0x002 |
| #define ROUND_XY_TO_GRID 0x004 |
| #define WE_HAVE_A_SCALE 0x008 |
| /* reserved 0x010 */ |
| #define MORE_COMPONENTS 0x020 |
| #define WE_HAVE_AN_XY_SCALE 0x040 |
| #define WE_HAVE_A_2X2 0x080 |
| #define WE_HAVE_INSTR 0x100 |
| #define USE_MY_METRICS 0x200 |
| |
| |
| |
| /*************************************************************************/ |
| /* Returns the horizontal or vertical metrics in font units for a */ |
| /* given glyph. The metrics are the left side bearing (resp. top */ |
| /* side bearing) and advance width (resp. advance height). */ |
| /* */ |
| LOCAL_FUNC |
| void TT_Get_Metrics( TT_HoriHeader* header, |
| TT_UInt index, |
| TT_Short* bearing, |
| TT_UShort* advance ) |
| { |
| TT_LongMetrics* longs_m; |
| TT_UShort k = header->number_Of_HMetrics; |
| |
| |
| if ( index < k ) |
| { |
| longs_m = (TT_LongMetrics*)header->long_metrics + index; |
| *bearing = longs_m->bearing; |
| *advance = longs_m->advance; |
| } |
| else |
| { |
| *bearing = ((TT_ShortMetrics*)header->short_metrics)[index - k]; |
| *advance = ((TT_LongMetrics*)header->long_metrics)[k - 1].advance; |
| } |
| } |
| |
| |
| /*************************************************************************/ |
| /* Returns the horizontal metrics in font units for a given glyph. */ |
| /* If `check' is true, take care of monospaced fonts by returning the */ |
| /* advance width maximum. */ |
| /* */ |
| static |
| void Get_HMetrics( TT_Face face, |
| TT_UInt index, |
| TT_Bool check, |
| TT_Short* lsb, |
| TT_UShort* aw ) |
| { |
| TT_Get_Metrics( &face->horizontal, index, lsb, aw ); |
| |
| if ( check && face->postscript.isFixedPitch ) |
| *aw = face->horizontal.advance_Width_Max; |
| } |
| |
| |
| /*************************************************************************/ |
| /* Returns the advance width table for a given pixel size if it is */ |
| /* found in the font's `hdmx' table (if any). */ |
| /* */ |
| static |
| TT_Byte* Get_Advance_Widths( TT_Face face, |
| TT_UShort ppem ) |
| { |
| TT_UShort n; |
| |
| |
| for ( n = 0; n < face->hdmx.num_records; n++ ) |
| if ( face->hdmx.records[n].ppem == ppem ) |
| return face->hdmx.records[n].widths; |
| |
| return NULL; |
| } |
| |
| |
| #define cur_to_org( n, zone ) \ |
| MEM_Copy( (zone)->org, (zone)->cur, n * sizeof ( TT_Vector ) ) |
| |
| #define org_to_cur( n, zone ) \ |
| MEM_Copy( (zone)->cur, (zone)->org, n * sizeof ( TT_Vector ) ) |
| |
| |
| /*************************************************************************/ |
| /* Translates an array of coordinates. */ |
| /* */ |
| static |
| void translate_array( TT_UInt n, |
| TT_Vector* coords, |
| TT_Pos delta_x, |
| TT_Pos delta_y ) |
| { |
| TT_UInt k; |
| |
| if ( delta_x ) |
| for ( k = 0; k < n; k++ ) |
| coords[k].x += delta_x; |
| |
| if ( delta_y ) |
| for ( k = 0; k < n; k++ ) |
| coords[k].y += delta_y; |
| } |
| |
| |
| |
| /*************************************************************************/ |
| /* Mounts one glyph zone on top of another. This is needed to */ |
| /* assemble composite glyphs. */ |
| /* */ |
| static |
| void mount_zone( FT_GlyphZone* source, |
| FT_GlyphZone* target ) |
| { |
| TT_UInt np; |
| TT_Int nc; |
| |
| np = source->n_points; |
| nc = source->n_contours; |
| |
| target->org = source->org + np; |
| target->cur = source->cur + np; |
| target->tags = source->tags + np; |
| |
| target->contours = source->contours + nc; |
| |
| target->n_points = 0; |
| target->n_contours = 0; |
| } |
| |
| |
| #undef IS_HINTED |
| #define IS_HINTED(flags) ((flags & FT_LOAD_NO_HINTING) == 0) |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* Load_Simple_Glyph */ |
| /* */ |
| /* <Description> */ |
| /* Loads a simple (i.e, non-composite) glyph. This function is used */ |
| /* for the `Load_Simple' state of TT_Load_Glyph(). All composite */ |
| /* glyphs elements will be loaded with routine. */ |
| /* */ |
| static |
| TT_Error Load_Simple( TT_Loader* load, |
| TT_UInt byte_count, |
| TT_Int n_contours, |
| TT_Bool debug ) |
| { |
| TT_Error error; |
| FT_Stream stream = load->stream; |
| FT_GlyphZone* zone = &load->zone; |
| TT_Face face = load->face; |
| |
| TT_UShort n_ins; |
| TT_Int n, n_points; |
| |
| /*********************************************************************/ |
| /* simple check */ |
| |
| if ( n_contours > load->left_contours ) |
| { |
| FT_TRACE0(( "ERROR: Glyph index %ld has %d contours > left %d\n", |
| load->glyph_index, |
| n_contours, |
| load->left_contours )); |
| return TT_Err_Too_Many_Contours; |
| } |
| |
| /* preparing the execution context */ |
| mount_zone( &load->base, zone ); |
| |
| /*********************************************************************/ |
| /* reading the contours endpoints */ |
| |
| if ( ACCESS_Frame( byte_count ) ) |
| return error; |
| |
| for ( n = 0; n < n_contours; n++ ) |
| zone->contours[n] = GET_UShort(); |
| |
| n_points = 0; |
| if ( n_contours > 0 ) |
| n_points = zone->contours[n_contours - 1] + 1; |
| |
| |
| /*********************************************************************/ |
| /* reading the bytecode instructions */ |
| |
| n_ins = GET_UShort(); |
| |
| if ( n_points > load->left_points ) |
| { |
| FT_TRACE0(( "ERROR: Too many points in glyph %ld\n", load->glyph_index )); |
| error = TT_Err_Too_Many_Points; |
| goto Fail; |
| } |
| |
| FT_TRACE4(( "Instructions size : %d\n", n_ins )); |
| |
| if ( n_ins > face->max_profile.maxSizeOfInstructions ) |
| { |
| FT_TRACE0(( "ERROR: Too many instructions!\n" )); |
| error = TT_Err_Too_Many_Ins; |
| goto Fail; |
| } |
| |
| if (stream->cursor + n_ins > stream->limit) |
| { |
| FT_TRACE0(( "ERROR: Instruction count mismatch!\n" )); |
| error = TT_Err_Too_Many_Ins; |
| goto Fail; |
| } |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| if ( (load->load_flags & (FT_LOAD_NO_SCALE|FT_LOAD_NO_HINTING))==0 ) |
| { |
| MEM_Copy( load->exec->glyphIns, stream->cursor, n_ins ); |
| |
| error = TT_Set_CodeRange( load->exec, tt_coderange_glyph, |
| load->exec->glyphIns, n_ins ); |
| if (error) goto Fail; |
| } |
| #endif |
| |
| stream->cursor += n_ins; |
| |
| /*********************************************************************/ |
| /* reading the point tags */ |
| |
| { |
| TT_Byte* flag = load->zone.tags; |
| TT_Byte* limit = flag + n_points; |
| TT_Byte c, count; |
| |
| for (; flag < limit; flag++) |
| { |
| *flag = c = GET_Byte(); |
| if ( c & 8 ) |
| { |
| for ( count = GET_Byte(); count > 0; count-- ) |
| *++flag = c; |
| } |
| } |
| } |
| |
| /*********************************************************************/ |
| /* reading the X coordinates */ |
| |
| { |
| TT_Vector* vec = zone->org; |
| TT_Vector* limit = vec + n_points; |
| TT_Byte* flag = zone->tags; |
| TT_Pos x = 0; |
| |
| for ( ; vec < limit; vec++, flag++ ) |
| { |
| TT_Pos y = 0; |
| |
| if ( *flag & 2 ) |
| { |
| y = GET_Byte(); |
| if ((*flag & 16) == 0) y = -y; |
| } |
| else if ((*flag & 16) == 0) |
| y = GET_Short(); |
| |
| x += y; |
| vec->x = x; |
| } |
| } |
| |
| /*********************************************************************/ |
| /* reading the Y coordinates */ |
| |
| { |
| TT_Vector* vec = zone->org; |
| TT_Vector* limit = vec + n_points; |
| TT_Byte* flag = zone->tags; |
| TT_Pos x = 0; |
| |
| for ( ; vec < limit; vec++, flag++ ) |
| { |
| TT_Pos y = 0; |
| |
| if ( *flag & 4 ) |
| { |
| y = GET_Byte(); |
| if ((*flag & 32) == 0) y = -y; |
| } |
| else if ((*flag & 32) == 0) |
| y = GET_Short(); |
| |
| x += y; |
| vec->y = x; |
| } |
| } |
| |
| FORGET_Frame(); |
| |
| /*********************************************************************/ |
| /* Add shadow points */ |
| |
| /* Now add the two shadow points at n and n + 1. */ |
| /* We need the left side bearing and advance width. */ |
| |
| { |
| TT_Vector* pp1; |
| TT_Vector* pp2; |
| |
| /* pp1 = xMin - lsb */ |
| pp1 = zone->org + n_points; |
| pp1->x = load->bbox.xMin - load->left_bearing; |
| pp1->y = 0; |
| |
| /* pp2 = pp1 + aw */ |
| pp2 = pp1 + 1; |
| pp2->x = pp1->x + load->advance; |
| pp2->y = 0; |
| |
| /* clear the touch tags */ |
| for ( n = 0; n < n_points; n++ ) |
| zone->tags[n] &= FT_Curve_Tag_On; |
| |
| zone->tags[n_points ] = 0; |
| zone->tags[n_points + 1] = 0; |
| } |
| /* Note that we return two more points that are not */ |
| /* part of the glyph outline. */ |
| |
| zone->n_points = n_points; |
| zone->n_contours = n_contours; |
| n_points += 2; |
| |
| /*******************************************/ |
| /* now eventually scale and hint the glyph */ |
| |
| if (load->load_flags & FT_LOAD_NO_SCALE) |
| { |
| /* no scaling, just copy the orig arrays into the cur ones */ |
| org_to_cur( n_points, zone ); |
| } |
| else |
| { |
| TT_Vector* vec = zone->org; |
| TT_Vector* limit = vec + n_points; |
| TT_Fixed x_scale = load->size->root.metrics.x_scale; |
| TT_Fixed y_scale = load->size->root.metrics.y_scale; |
| |
| /* first scale the glyph points */ |
| for (; vec < limit; vec++) |
| { |
| vec->x = FT_MulFix( vec->x, x_scale ); |
| vec->y = FT_MulFix( vec->y, y_scale ); |
| } |
| |
| /* if hinting, round pp1, and shift the glyph accordingly */ |
| if ( !IS_HINTED(load->load_flags) ) |
| { |
| org_to_cur( n_points, zone ); |
| } |
| else |
| { |
| TT_Pos x = zone->org[n_points-2].x; |
| x = ((x + 32) & -64) - x; |
| translate_array( n_points, zone->org, x, 0 ); |
| |
| org_to_cur( n_points, zone ); |
| |
| zone->cur[n_points-1].x = (zone->cur[n_points-1].x + 32) & -64; |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| /* now consider hinting */ |
| if ( n_ins > 0 ) |
| { |
| load->exec->is_composite = FALSE; |
| load->exec->pedantic_hinting = (TT_Bool)(load->load_flags & FT_LOAD_PEDANTIC); |
| load->exec->pts = *zone; |
| load->exec->pts.n_points += 2; |
| |
| error = TT_Run_Context( load->exec, debug ); |
| if ( error && load->exec->pedantic_hinting ) |
| return error; |
| } |
| #endif |
| } |
| } |
| |
| /* save glyph phantom points */ |
| if ( !load->preserve_pps ) |
| { |
| load->pp1 = zone->cur[n_points - 2]; |
| load->pp2 = zone->cur[n_points - 1]; |
| } |
| |
| return TT_Err_Ok; |
| |
| Fail: |
| FORGET_Frame(); |
| return error; |
| } |
| |
| |
| |
| |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* load_truetype_glyph */ |
| /* */ |
| /* <Description> */ |
| /* Loads a given truetype glyph. Handles composites and uses a */ |
| /* TT_Loader object.. */ |
| /* */ |
| static |
| TT_Error load_truetype_glyph( TT_Loader* loader, |
| TT_UInt glyph_index ) |
| { |
| FT_Stream stream = loader->stream; |
| TT_Error error; |
| TT_Face face = loader->face; |
| TT_ULong offset; |
| FT_SubGlyph subglyphs[ TT_MAX_SUBGLYPHS ]; |
| TT_Int num_subglyphs = 0, contours_count; |
| TT_UInt index, num_points, num_contours, count; |
| TT_Fixed x_scale, y_scale; |
| TT_ULong ins_offset; |
| |
| /* check glyph index */ |
| index = (TT_UInt)glyph_index; |
| if ( index >= (TT_UInt)face->root.num_glyphs ) |
| { |
| error = TT_Err_Invalid_Glyph_Index; |
| goto Fail; |
| } |
| |
| loader->glyph_index = glyph_index; |
| num_contours = 0; |
| num_points = 0; |
| ins_offset = 0; |
| |
| x_scale = 0x10000; |
| y_scale = 0x10000; |
| if ( (loader->load_flags & FT_LOAD_NO_SCALE)==0 ) |
| { |
| x_scale = loader->size->root.metrics.x_scale; |
| y_scale = loader->size->root.metrics.y_scale; |
| } |
| |
| /* get horizontal metrics */ |
| { |
| TT_Short left_bearing; |
| TT_UShort advance_width; |
| |
| Get_HMetrics( face, index, |
| (TT_Bool)!(loader->load_flags & |
| FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH), |
| &left_bearing, |
| &advance_width ); |
| |
| loader->left_bearing = left_bearing; |
| loader->advance = advance_width; |
| } |
| |
| /* load glyph header */ |
| offset = face->glyph_locations[index]; |
| count = 0; |
| if (index < (TT_UInt)face->num_locations-1) |
| count = face->glyph_locations[index+1] - offset; |
| |
| |
| if (count == 0) |
| { |
| /* as described by Frederic Loyer, these are spaces, and */ |
| /* not the unknown glyph. */ |
| loader->bbox.xMin = 0; |
| loader->bbox.xMax = 0; |
| loader->bbox.yMin = 0; |
| loader->bbox.yMax = 0; |
| |
| loader->pp1.x = 0; |
| loader->pp2.x = loader->advance; |
| |
| if ( (loader->load_flags & FT_LOAD_NO_SCALE)==0 ) |
| loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale ); |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| if (loader->exec) |
| loader->exec->glyphSize = 0; |
| #endif |
| goto Load_End; |
| } |
| |
| offset = loader->glyf_offset + offset; |
| |
| /* read first glyph header */ |
| if ( FILE_Seek( offset ) || ACCESS_Frame( 10L ) ) |
| goto Fail; |
| |
| contours_count = GET_Short(); |
| |
| loader->bbox.xMin = GET_Short(); |
| loader->bbox.yMin = GET_Short(); |
| loader->bbox.xMax = GET_Short(); |
| loader->bbox.yMax = GET_Short(); |
| |
| FORGET_Frame(); |
| |
| FT_TRACE6(( "Glyph %ld\n", index )); |
| FT_TRACE6(( " # of contours : %d\n", num_contours )); |
| FT_TRACE6(( " xMin: %4d xMax: %4d\n", loader->bbox.xMin, |
| loader->bbox.xMax )); |
| FT_TRACE6(( " yMin: %4d yMax: %4d\n", loader->bbox.yMin, |
| loader->bbox.yMax )); |
| FT_TRACE6(( "-" )); |
| |
| count -= 10; |
| |
| if ( contours_count > loader->left_contours ) |
| { |
| FT_TRACE0(( "ERROR: Too many contours for glyph %ld\n", index )); |
| error = TT_Err_Too_Many_Contours; |
| goto Fail; |
| } |
| |
| loader->pp1.x = loader->bbox.xMin - loader->left_bearing; |
| loader->pp1.y = 0; |
| loader->pp2.x = loader->pp1.x + loader->advance; |
| loader->pp2.y = 0; |
| |
| if ((loader->load_flags & FT_LOAD_NO_SCALE)==0) |
| { |
| loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale ); |
| loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale ); |
| } |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| /**********************************************************************/ |
| /* if it is a simple glyph, load it */ |
| if (contours_count >= 0) |
| { |
| TT_UInt num_base_points; |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| error = Load_Simple( loader, |
| count, |
| contours_count, |
| (TT_Bool)( loader->size && |
| loader->size->debug ) ); |
| #else |
| error = Load_Simple( loader, count, contours_count, 0 ); |
| #endif |
| if ( error ) |
| goto Fail; |
| |
| /* Note: We could have put the simple loader source there */ |
| /* but the code is fat enough already :-) */ |
| num_points = loader->zone.n_points; |
| num_contours = loader->zone.n_contours; |
| |
| num_base_points = loader->base.n_points; |
| { |
| TT_UInt k; |
| for ( k = 0; k < num_contours; k++ ) |
| loader->zone.contours[k] += num_base_points; |
| } |
| |
| loader->base.n_points += num_points; |
| loader->base.n_contours += num_contours; |
| |
| loader->zone.n_points = 0; |
| loader->zone.n_contours = 0; |
| |
| loader->left_points -= num_points; |
| loader->left_contours -= num_contours; |
| } |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| /************************************************************************/ |
| else /* otherwise, load a composite !! */ |
| { |
| /* for each subglyph, read composite header */ |
| FT_SubGlyph* subglyph = subglyphs; |
| |
| if (ACCESS_Frame(count)) goto Fail; |
| |
| num_subglyphs = 0; |
| do |
| { |
| TT_Fixed xx, xy, yy, yx; |
| |
| subglyph->arg1 = subglyph->arg2 = 0; |
| |
| subglyph->flags = GET_UShort(); |
| subglyph->index = GET_UShort(); |
| |
| /* read arguments */ |
| if (subglyph->flags & ARGS_ARE_WORDS) |
| { |
| subglyph->arg1 = GET_Short(); |
| subglyph->arg2 = GET_Short(); |
| } |
| else |
| { |
| subglyph->arg1 = GET_Char(); |
| subglyph->arg2 = GET_Char(); |
| } |
| |
| /* read transform */ |
| xx = yy = 0x10000; |
| xy = yx = 0; |
| |
| if (subglyph->flags & WE_HAVE_A_SCALE) |
| { |
| xx = (TT_Fixed)GET_Short() << 2; |
| yy = xx; |
| } |
| else if (subglyph->flags & WE_HAVE_AN_XY_SCALE) |
| { |
| xx = (TT_Fixed)GET_Short() << 2; |
| yy = (TT_Fixed)GET_Short() << 2; |
| } |
| else if (subglyph->flags & WE_HAVE_A_2X2) |
| { |
| xx = (TT_Fixed)GET_Short() << 2; |
| xy = (TT_Fixed)GET_Short() << 2; |
| yx = (TT_Fixed)GET_Short() << 2; |
| yy = (TT_Fixed)GET_Short() << 2; |
| } |
| |
| subglyph->transform.xx = xx; |
| subglyph->transform.xy = xy; |
| subglyph->transform.yx = yx; |
| subglyph->transform.yy = yy; |
| |
| subglyph++; |
| num_subglyphs++; |
| if (num_subglyphs >= TT_MAX_SUBGLYPHS) |
| break; |
| } |
| while (subglyph[-1].flags & MORE_COMPONENTS); |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| { |
| /* we must undo the ACCESS_Frame in order to point to the */ |
| /* composite instructions, if we find some .. */ |
| /* we will process them later.. */ |
| ins_offset = FILE_Pos() + stream->cursor - stream->limit; |
| FORGET_Frame(); |
| } |
| #endif |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| /*********************************************************************/ |
| /* Now, read each subglyph independently.. */ |
| { |
| TT_Int n, num_base_points, num_new_points; |
| |
| subglyph = subglyphs; |
| for ( n = 0; n < num_subglyphs; n++, subglyph++ ) |
| { |
| TT_Vector pp1, pp2; |
| TT_Pos x, y; |
| |
| pp1 = loader->pp1; |
| pp2 = loader->pp2; |
| |
| num_base_points = loader->base.n_points; |
| |
| error = load_truetype_glyph( loader, subglyph->index ); |
| if ( subglyph->flags & USE_MY_METRICS ) |
| { |
| pp1 = loader->pp1; |
| pp2 = loader->pp2; |
| } |
| else |
| { |
| loader->pp1 = pp1; |
| loader->pp2 = pp2; |
| } |
| |
| num_points = loader->base.n_points; |
| num_contours = loader->base.n_contours; |
| |
| num_new_points = num_points - num_base_points; |
| |
| /********************************************************/ |
| /* now perform the transform required for this subglyph */ |
| |
| if ( subglyph->flags & ( WE_HAVE_A_SCALE | |
| WE_HAVE_AN_XY_SCALE | |
| WE_HAVE_A_2X2 ) ) |
| { |
| TT_Vector* cur = loader->zone.cur; |
| TT_Vector* org = loader->zone.org; |
| TT_Vector* limit = cur + num_new_points; |
| |
| for ( ; cur < limit; cur++, org++ ) |
| { |
| TT_Pos nx, ny; |
| |
| nx = FT_MulFix( cur->x, subglyph->transform.xx ) + |
| FT_MulFix( cur->y, subglyph->transform.yx ); |
| |
| ny = FT_MulFix( cur->x, subglyph->transform.xy ) + |
| FT_MulFix( cur->y, subglyph->transform.yy ); |
| |
| cur->x = nx; |
| cur->y = ny; |
| |
| nx = FT_MulFix( org->x, subglyph->transform.xx ) + |
| FT_MulFix( org->y, subglyph->transform.yx ); |
| |
| ny = FT_MulFix( org->x, subglyph->transform.xy ) + |
| FT_MulFix( org->y, subglyph->transform.yy ); |
| |
| org->x = nx; |
| org->y = ny; |
| } |
| } |
| |
| /* apply offset */ |
| |
| if ( !(subglyph->flags & ARGS_ARE_XY_VALUES) ) |
| { |
| TT_Int k = subglyph->arg1; |
| TT_UInt l = subglyph->arg2; |
| |
| if ( k >= num_base_points || |
| l >= (TT_UInt)num_new_points ) |
| { |
| error = TT_Err_Invalid_Composite; |
| goto Fail; |
| } |
| |
| l += num_base_points; |
| |
| x = loader->base.cur[k].x - loader->base.cur[l].x; |
| y = loader->base.cur[k].y - loader->base.cur[l].y; |
| } |
| else |
| { |
| x = subglyph->arg1; |
| y = subglyph->arg2; |
| |
| if (!(loader->load_flags & FT_LOAD_NO_SCALE)) |
| { |
| x = FT_MulFix( x, x_scale ); |
| y = FT_MulFix( y, y_scale ); |
| |
| if ( subglyph->flags & ROUND_XY_TO_GRID ) |
| { |
| x = (x + 32) & -64; |
| y = (y + 32) & -64; |
| } |
| } |
| } |
| |
| translate_array( num_new_points, loader->zone.cur, x, y ); |
| cur_to_org( num_new_points, &loader->zone ); |
| } |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| /* we have finished loading all sub-glyphs, now, look for */ |
| /* instructions for this composite !! */ |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| subglyph--; |
| if (num_subglyphs > 0 && loader->exec && subglyph->flags & WE_HAVE_INSTR) |
| { |
| TT_UShort n_ins; |
| TT_ExecContext exec = loader->exec; |
| TT_UInt n_points = loader->base.n_points; |
| FT_GlyphZone* pts; |
| TT_Vector* pp1; |
| |
| /* read size of instructions */ |
| if ( FILE_Seek( ins_offset ) || |
| READ_UShort(n_ins) ) goto Fail; |
| FT_TRACE4(( "Instructions size = %d\n", n_ins )); |
| |
| /* check it */ |
| if ( n_ins > face->max_profile.maxSizeOfInstructions ) |
| { |
| FT_TRACE0(( "Too many instructions in composite glyph %ld\n", |
| subglyph->index )); |
| return TT_Err_Too_Many_Ins; |
| } |
| |
| if (exec) |
| { |
| } |
| /* read the instructions */ |
| if ( FILE_Read( exec->glyphIns, n_ins ) ) |
| goto Fail; |
| |
| error = TT_Set_CodeRange( exec, |
| tt_coderange_glyph, |
| exec->glyphIns, |
| n_ins ); |
| if ( error ) goto Fail; |
| |
| /* prepare the execution context */ |
| exec->pts = loader->base; |
| pts = &exec->pts; |
| |
| pts->n_points = num_points + 2; |
| pts->n_contours = num_contours; |
| |
| /* add phantom points */ |
| pp1 = pts->cur + num_points; |
| pp1[0] = loader->pp1; |
| pp1[1] = loader->pp2; |
| |
| pts->tags[num_points + 1] = 0; |
| pts->tags[num_points + 2] = 0; |
| |
| /* if hinting, round the phantom points */ |
| if ( IS_HINTED(loader->load_flags) ) |
| { |
| pp1[0].x = ((loader->pp1.x + 32) & -64); |
| pp1[1].x = ((loader->pp2.x + 32) & -64); |
| } |
| |
| { |
| TT_UInt k; |
| for ( k = 0; k < n_points; k++ ) |
| pts->tags[k] &= FT_Curve_Tag_On; |
| } |
| |
| cur_to_org( n_points, pts ); |
| |
| /* now consider hinting */ |
| if ( IS_HINTED(loader->load_flags) && n_ins > 0 ) |
| { |
| exec->is_composite = TRUE; |
| exec->pedantic_hinting = |
| (TT_Bool)(loader->load_flags & FT_LOAD_PEDANTIC); |
| |
| error = TT_Run_Context( exec, loader->size->debug ); |
| if ( error && exec->pedantic_hinting ) |
| goto Fail; |
| } |
| |
| /* save glyph origin and advance points */ |
| loader->pp1 = pp1[0]; |
| loader->pp2 = pp1[1]; |
| } |
| #endif |
| |
| } |
| } |
| |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| /*************************************************************************/ |
| |
| Load_End: |
| error = TT_Err_Ok; |
| |
| Fail: |
| return error; |
| } |
| |
| |
| |
| |
| |
| static |
| void compute_glyph_metrics( TT_Loader* loader, |
| TT_UInt glyph_index ) |
| { |
| TT_UInt num_points = loader->base.n_points; |
| TT_UInt num_contours = loader->base.n_contours; |
| TT_BBox bbox; |
| TT_Face face = loader->face; |
| TT_Fixed x_scale, y_scale; |
| TT_GlyphSlot glyph = loader->glyph; |
| TT_Size size = loader->size; |
| |
| /* when a simple glyph was loaded, the value of */ |
| /* "base.n_points" and "base.n_contours" is 0, we must */ |
| /* take those in the "zone" instead.. */ |
| if ( num_points == 0 && num_contours == 0 ) |
| { |
| num_points = loader->zone.n_points; |
| num_contours = loader->zone.n_contours; |
| } |
| |
| x_scale = 0x10000; |
| y_scale = 0x10000; |
| if ( (loader->load_flags & FT_LOAD_NO_SCALE) == 0) |
| { |
| x_scale = size->root.metrics.x_scale; |
| y_scale = size->root.metrics.y_scale; |
| } |
| |
| { |
| TT_UInt u; |
| for ( u = 0; u < num_points + 2; u++ ) |
| { |
| glyph->outline.points[u] = loader->base.cur[u]; |
| glyph->outline.tags [u] = loader->base.tags[u]; |
| } |
| |
| for ( u = 0; u < num_contours; u++ ) |
| glyph->outline.contours[u] = loader->base.contours[u]; |
| } |
| |
| glyph->outline.n_points = num_points; |
| glyph->outline.n_contours = num_contours; |
| |
| /* glyph->outline.second_pass = TRUE; */ |
| glyph->outline.flags &= ~ft_outline_single_pass; |
| |
| /* translate array so that (0,0) is the glyph's origin */ |
| translate_array( (TT_UShort)(num_points + 2), |
| glyph->outline.points, |
| -loader->pp1.x, |
| 0 ); |
| |
| FT_Outline_Get_CBox( &glyph->outline, &bbox ); |
| |
| if ( IS_HINTED(loader->load_flags) ) |
| { |
| /* grid-fit the bounding box */ |
| bbox.xMin &= -64; |
| bbox.yMin &= -64; |
| bbox.xMax = (bbox.xMax + 63) & -64; |
| bbox.yMax = (bbox.yMax + 63) & -64; |
| } |
| |
| /* get the device-independent scaled horizontal metrics */ |
| /* take care of fixed-pitch fonts... */ |
| { |
| TT_Pos left_bearing; |
| TT_Pos advance; |
| |
| left_bearing = loader->left_bearing; |
| advance = loader->advance; |
| |
| /* the flag FT_LOAD_NO_ADVANCE_CHECK was introduced to */ |
| /* correctly support DynaLab fonts, who have an incorrect */ |
| /* "advance_Width_Max" field !! It is used, to my knowledge */ |
| /* exclusively in the X-TrueType font server.. */ |
| /* */ |
| if ( face->postscript.isFixedPitch && |
| (loader->load_flags & FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH) == 0 ) |
| advance = face->horizontal.advance_Width_Max; |
| |
| if ( !(loader->load_flags & FT_LOAD_NO_SCALE) ) |
| { |
| left_bearing = FT_MulFix( left_bearing, x_scale ); |
| advance = FT_MulFix( advance, x_scale ); |
| } |
| |
| glyph->metrics2.horiBearingX = left_bearing; |
| glyph->metrics2.horiAdvance = advance; |
| } |
| |
| glyph->metrics.horiBearingX = bbox.xMin; |
| glyph->metrics.horiBearingY = bbox.yMax; |
| glyph->metrics.horiAdvance = loader->pp2.x - loader->pp1.x; |
| |
| /* Now take care of vertical metrics. In the case where there is */ |
| /* no vertical information within the font (relatively common), make */ |
| /* up some metrics by `hand'... */ |
| |
| { |
| TT_Short top_bearing; /* vertical top side bearing (EM units) */ |
| TT_UShort advance_height; /* vertical advance height (EM units) */ |
| |
| TT_Pos left; /* scaled vertical left side bearing */ |
| TT_Pos Top; /* scaled original vertical top side bearing */ |
| TT_Pos top; /* scaled vertical top side bearing */ |
| TT_Pos advance; /* scaled vertical advance height */ |
| |
| |
| /* Get the unscaled `tsb' and `ah' */ |
| if ( face->vertical_info && |
| face->vertical.number_Of_VMetrics > 0 ) |
| { |
| /* Don't assume that both the vertical header and vertical */ |
| /* metrics are present in the same font :-) */ |
| |
| TT_Get_Metrics( (TT_HoriHeader*)&face->vertical, |
| glyph_index, |
| &top_bearing, |
| &advance_height ); |
| } |
| else |
| { |
| /* Make up the distances from the horizontal header.. */ |
| |
| /* NOTE: The OS/2 values are the only `portable' ones, */ |
| /* which is why we use them, when there is an */ |
| /* OS/2 table in the font. Otherwise, we use the */ |
| /* values defined in the horizontal header.. */ |
| /* */ |
| /* NOTE2: The sTypoDescender is negative, which is why */ |
| /* we compute the baseline-to-baseline distance */ |
| /* here with: */ |
| /* ascender - descender + linegap */ |
| /* */ |
| if ( face->os2.version != 0xFFFF ) |
| { |
| top_bearing = face->os2.sTypoLineGap / 2; |
| advance_height = (TT_UShort)(face->os2.sTypoAscender - |
| face->os2.sTypoDescender + |
| face->os2.sTypoLineGap); |
| } |
| else |
| { |
| top_bearing = face->horizontal.Line_Gap / 2; |
| advance_height = (TT_UShort)(face->horizontal.Ascender + |
| face->horizontal.Descender + |
| face->horizontal.Line_Gap); |
| } |
| } |
| |
| /* We must adjust the top_bearing value from the bounding box given |
| in the glyph header to te bounding box calculated with |
| TT_Get_Outline_BBox() */ |
| |
| /* scale the metrics */ |
| if ( !(loader->load_flags & FT_LOAD_NO_SCALE) ) |
| { |
| Top = FT_MulFix( top_bearing, y_scale ); |
| top = FT_MulFix( top_bearing + loader->bbox.yMax, y_scale ) |
| - bbox.yMax; |
| advance = FT_MulFix( advance_height, y_scale ); |
| } |
| else |
| { |
| Top = top_bearing; |
| top = top_bearing + loader->bbox.yMax - bbox.yMax; |
| advance = advance_height; |
| } |
| |
| glyph->metrics2.vertBearingY = Top; |
| glyph->metrics2.vertAdvance = advance; |
| |
| /* XXX: for now, we have no better algorithm for the lsb, but it */ |
| /* should work fine. */ |
| /* */ |
| left = ( bbox.xMin - bbox.xMax ) / 2; |
| |
| /* grid-fit them if necessary */ |
| if ( IS_HINTED(loader->load_flags) ) |
| { |
| left &= -64; |
| top = (top + 63) & -64; |
| advance = (advance + 32) & -64; |
| } |
| |
| glyph->metrics.vertBearingX = left; |
| glyph->metrics.vertBearingY = top; |
| glyph->metrics.vertAdvance = advance; |
| } |
| |
| /* Adjust advance width to the value contained in the hdmx table. */ |
| if ( !face->postscript.isFixedPitch && size && |
| IS_HINTED(loader->load_flags) ) |
| { |
| TT_Byte* widths = Get_Advance_Widths( face, |
| size->root.metrics.x_ppem ); |
| if ( widths ) |
| glyph->metrics.horiAdvance = widths[glyph_index] << 6; |
| } |
| |
| /* drop-out mode is irrelevant, we always use mode 2 */ |
| #if 0 |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| if (loader->exec) |
| glyph->outline.dropout_mode = (TT_Char)loader->exec->GS.scan_type; |
| #else |
| glyph->outline.dropout_mode = 2; |
| #endif |
| #endif |
| |
| /* set glyph dimensions */ |
| glyph->metrics.width = bbox.xMax - bbox.xMin; |
| glyph->metrics.height = bbox.yMax - bbox.yMin; |
| |
| glyph->format = ft_glyph_format_outline; |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| LOCAL_FUNC |
| TT_Error TT_Load_Glyph( TT_Size size, |
| TT_GlyphSlot glyph, |
| TT_UShort glyph_index, |
| TT_UInt load_flags ) |
| { |
| SFNT_Interface* sfnt; |
| TT_Face face; |
| FT_Stream stream; |
| FT_Memory memory; |
| TT_Error error; |
| TT_Loader loader; |
| FT_GlyphZone* zone; |
| |
| face = (TT_Face)glyph->face; |
| sfnt = (SFNT_Interface*)face->sfnt; |
| stream = face->root.stream; |
| memory = face->root.memory; |
| error = 0; |
| |
| if ( !size || (load_flags & FT_LOAD_NO_SCALE) ) |
| { |
| size = NULL; |
| load_flags |= FT_LOAD_NO_SCALE | |
| FT_LOAD_NO_HINTING | |
| FT_LOAD_NO_BITMAP; |
| } |
| |
| #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS |
| /*********************************************************************/ |
| /* Try to load embedded bitmap if any */ |
| if ( size && (load_flags & FT_LOAD_NO_BITMAP) == 0 && sfnt->load_sbits ) |
| { |
| TT_SBit_Metrics metrics; |
| |
| error = sfnt->load_sbit_image( face, |
| size->root.metrics.x_ppem, |
| size->root.metrics.y_ppem, |
| glyph_index, |
| stream, |
| &glyph->bitmap, |
| &metrics ); |
| if ( !error ) |
| { |
| glyph->outline.n_points = 0; |
| glyph->outline.n_contours = 0; |
| |
| glyph->metrics.width = (TT_Pos)metrics.width << 6; |
| glyph->metrics.height = (TT_Pos)metrics.height << 6; |
| |
| glyph->metrics.horiBearingX = (TT_Pos)metrics.horiBearingX << 6; |
| glyph->metrics.horiBearingY = (TT_Pos)metrics.horiBearingY << 6; |
| glyph->metrics.horiAdvance = (TT_Pos)metrics.horiAdvance << 6; |
| |
| glyph->metrics.vertBearingX = (TT_Pos)metrics.vertBearingX << 6; |
| glyph->metrics.vertBearingY = (TT_Pos)metrics.vertBearingY << 6; |
| glyph->metrics.vertAdvance = (TT_Pos)metrics.vertAdvance << 6; |
| |
| glyph->format = ft_glyph_format_bitmap; |
| return error; |
| } |
| } |
| #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ |
| |
| if ( load_flags & FT_LOAD_NO_OUTLINE ) |
| return ( error ? error : TT_Err_Unavailable_Bitmap ); |
| |
| /* seek to the beginning of the glyph table. For Type 43 fonts */ |
| /* the table might be accessed from a Postscript stream or something */ |
| /* else... */ |
| error = face->goto_table( face, TTAG_glyf, stream, 0 ); |
| if (error) |
| { |
| FT_ERROR(( "TT.GLoad: could not access glyph table\n" )); |
| goto Exit; |
| } |
| |
| MEM_Set( &loader, 0, sizeof(loader) ); |
| |
| /* update the glyph zone bounds */ |
| zone = &((TT_Driver)face->root.driver)->zone; |
| error = FT_Update_GlyphZone( zone, |
| face->root.max_points, |
| face->root.max_contours ); |
| if (error) |
| { |
| FT_ERROR(( "TT.GLoad: could not update loader glyph zone\n" )); |
| goto Exit; |
| } |
| loader.base = *zone; |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| if ( size ) |
| { |
| /* query new execution context */ |
| loader.exec = size->debug ? size->context : TT_New_Context(face); |
| if ( !loader.exec ) |
| return TT_Err_Could_Not_Find_Context; |
| |
| TT_Load_Context( loader.exec, face, size ); |
| |
| /* load default graphics state - if needed */ |
| if ( size->GS.instruct_control & 2 ) |
| loader.exec->GS = tt_default_graphics_state; |
| } |
| #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */ |
| |
| /* clear all outline flags, except the "owner" one */ |
| glyph->outline.flags &= ft_outline_owner; |
| |
| if (size && size->root.metrics.y_ppem < 24 ) |
| glyph->outline.flags |= ft_outline_high_precision; |
| |
| /************************************************************************/ |
| /* let's initialise the rest of our loader now */ |
| loader.left_points = face->root.max_points; |
| loader.left_contours = face->root.max_contours; |
| loader.load_flags = load_flags; |
| |
| loader.face = face; |
| loader.size = size; |
| loader.glyph = glyph; |
| loader.stream = stream; |
| |
| loader.glyf_offset = FILE_Pos(); |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| /* when the cvt program has disabled hinting, the argument */ |
| /* is ignored. */ |
| if ( size && (size->GS.instruct_control & 1) ) |
| loader.load_flags |= FT_LOAD_NO_HINTING; |
| #endif |
| |
| /* Main loading loop */ |
| error = load_truetype_glyph( &loader, glyph_index ); |
| if (!error) |
| compute_glyph_metrics( &loader, glyph_index ); |
| |
| #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER |
| if ( !size || !size->debug ) |
| TT_Done_Context( loader.exec ); |
| #endif |
| |
| Exit: |
| return error; |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| /* END */ |
