| /***************************************************************************/ |
| /* */ |
| /* 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> |
| #include <ttinterp.h> |
| |
| |
| /* 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 |
| |
| |
| #undef SCALE_X |
| #define SCALE_X( distance ) FT_MulFix( distance, exec->metrics.x_scale ) |
| |
| #undef SCALE_Y |
| #define SCALE_Y( distance ) FT_MulFix( distance, exec->metrics.y_scale ) |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Get_Metrics */ |
| /* */ |
| /* <Description> */ |
| /* 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). */ |
| /* */ |
| /* <Input> */ |
| /* header :: A pointer to either the horizontal or vertical metrics */ |
| /* structure. */ |
| /* */ |
| /* index :: The glyph index. */ |
| /* */ |
| /* <Output> */ |
| /* bearing :: The bearing, either left side or top side. */ |
| /* */ |
| /* advance :: The advance width resp. advance height. */ |
| /* */ |
| /* <Note> */ |
| /* This function will much probably move to another component in the */ |
| /* near future, but I haven't decided which yet. */ |
| /* */ |
| LOCAL_FUNC |
| void TT_Get_Metrics( TT_HoriHeader* header, |
| TT_UShort 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; |
| } |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* Get_HMetrics */ |
| /* */ |
| /* <Description> */ |
| /* 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. */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target source face. */ |
| /* */ |
| /* index :: The glyph index. */ |
| /* */ |
| /* check :: If set, handle monospaced fonts. */ |
| /* */ |
| /* <Output> */ |
| /* lsb :: The left side bearing. */ |
| /* */ |
| /* aw :: The advance width. */ |
| /* */ |
| static |
| void Get_HMetrics( TT_Face face, |
| TT_UShort 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; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* Get_Advance_Widths */ |
| /* */ |
| /* <Description> */ |
| /* Returns the advance width table for a given pixel size if it is */ |
| /* found in the font's `hdmx' table (if any). */ |
| /* */ |
| /* <Input> */ |
| /* face :: A handle to the target source face. */ |
| /* */ |
| /* ppem :: The pixel size. */ |
| /* */ |
| /* <Return> */ |
| /* A pointer to the advance with table. NULL if it doesn't exist. */ |
| /* */ |
| 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 ) ) |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* translate_array */ |
| /* */ |
| /* <Description> */ |
| /* Translates an array of coordinates. */ |
| /* */ |
| /* <Input> */ |
| /* n :: The number of points to translate. */ |
| /* */ |
| /* delta_x :: The horizontal coordinate of the shift vector. */ |
| /* */ |
| /* delta_y :: The vertical coordinate of the shift vector. */ |
| /* */ |
| /* <InOut> */ |
| /* coords :: The vector array to translate. */ |
| /* */ |
| static |
| void translate_array( TT_UShort n, |
| TT_Vector* coords, |
| TT_Pos delta_x, |
| TT_Pos delta_y ) |
| { |
| TT_UShort 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; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* mount_zone */ |
| /* */ |
| /* <Description> */ |
| /* Mounts one glyph zone on top of another. This is needed to */ |
| /* assemble composite glyphs. */ |
| /* */ |
| /* <Input> */ |
| /* source :: The source glyph zone. */ |
| /* */ |
| /* <Output> */ |
| /* target :: The target glyph zone. */ |
| /* */ |
| static |
| void mount_zone( TT_GlyphZone* source, |
| TT_GlyphZone* target ) |
| { |
| TT_UShort np; |
| TT_Short nc; |
| |
| |
| np = source->n_points; |
| nc = source->n_contours; |
| |
| target->org = source->org + np; |
| target->cur = source->cur + np; |
| target->touch = source->touch + np; |
| |
| target->contours = source->contours + nc; |
| |
| target->n_points = 0; |
| target->n_contours = 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_Glyph( TT_ExecContext exec, |
| FT_Stream stream, |
| TT_ULong byte_count, |
| TT_Short n_contours, |
| TT_Short left_contours, |
| TT_UShort left_points, |
| TT_UInt load_flags, |
| TT_SubGlyphRec* subg, |
| TT_Bool debug ) |
| { |
| TT_Error error; |
| TT_GlyphZone* pts; |
| TT_Short k; |
| TT_UShort j; |
| TT_UShort n_points, n_ins; |
| TT_Face face; |
| TT_Byte* flag; |
| TT_Vector* vec; |
| TT_F26Dot6 x, y; |
| |
| TT_Vector *pp1, *pp2; |
| |
| |
| face = exec->face; |
| |
| /*********************************************************************/ |
| /* simple check */ |
| |
| if ( n_contours > left_contours ) |
| { |
| FT_TRACE0(( "ERROR: Glyph index %ld has %d contours > left %d\n", |
| subglyph.index, |
| n_contours, |
| left_contours )); |
| return TT_Err_Too_Many_Contours; |
| } |
| |
| /* preparing the execution context */ |
| mount_zone( &subg->zone, &exec->pts ); |
| |
| |
| /*********************************************************************/ |
| /* reading the contours endpoints */ |
| |
| if ( ACCESS_Frame( byte_count ) ) |
| return error; |
| |
| for ( k = 0; k < n_contours; k++ ) |
| exec->pts.contours[k] = GET_UShort(); |
| |
| n_points = 0; |
| if ( n_contours > 0 ) |
| n_points = exec->pts.contours[n_contours - 1] + 1; |
| |
| |
| /*********************************************************************/ |
| /* reading the bytecode instructions */ |
| |
| n_ins = GET_UShort(); |
| |
| if ( n_points > left_points ) |
| { |
| FT_TRACE0(( "ERROR: Too many points in glyph %ld\n", subg->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; |
| } |
| MEM_Copy( exec->glyphIns, stream->cursor, n_ins ); |
| stream->cursor += n_ins; |
| |
| error = TT_Set_CodeRange( exec, tt_coderange_glyph, |
| exec->glyphIns, n_ins ); |
| if (error) goto Fail; |
| |
| |
| /*********************************************************************/ |
| /* reading the point flags */ |
| |
| j = 0; |
| flag = exec->pts.touch; |
| |
| while ( j < n_points ) |
| { |
| TT_Byte c, cnt; |
| |
| flag[j] = c = GET_Byte(); |
| j++; |
| |
| if ( c & 8 ) |
| { |
| cnt = GET_Byte(); |
| |
| while( cnt > 0 ) |
| { |
| flag[j++] = c; |
| cnt--; |
| } |
| } |
| } |
| |
| /*********************************************************************/ |
| /* reading the X coordinates */ |
| |
| x = 0; |
| vec = exec->pts.org; |
| |
| for ( j = 0; j < n_points; j++ ) |
| { |
| if ( flag[j] & 2 ) |
| { |
| if ( flag[j] & 16 ) |
| x += GET_Byte(); |
| else |
| x -= GET_Byte(); |
| } |
| else |
| { |
| if ( (flag[j] & 16) == 0 ) |
| x += GET_Short(); |
| } |
| |
| vec[j].x = x; |
| } |
| |
| |
| /*********************************************************************/ |
| /* reading the YX coordinates */ |
| |
| y = 0; |
| |
| for ( j = 0; j < n_points; j++ ) |
| { |
| if ( flag[j] & 4 ) |
| { |
| if ( flag[j] & 32 ) |
| y += GET_Byte(); |
| else |
| y -= GET_Byte(); |
| } |
| else |
| { |
| if ( (flag[j] & 32) == 0 ) |
| y += GET_Short(); |
| } |
| |
| vec[j].y = y; |
| } |
| |
| 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. */ |
| |
| /* pp1 = xMin - lsb */ |
| pp1 = vec + n_points; |
| pp1->x = subg->bbox.xMin - subg->left_bearing; |
| pp1->y = 0; |
| |
| /* pp2 = pp1 + aw */ |
| pp2 = pp1 + 1; |
| pp2->x = pp1->x + subg->advance; |
| pp2->y = 0; |
| |
| /* clear the touch flags */ |
| for ( j = 0; j < n_points; j++ ) |
| exec->pts.touch[j] &= FT_Curve_Tag_On; |
| |
| exec->pts.touch[n_points ] = 0; |
| exec->pts.touch[n_points + 1] = 0; |
| |
| /* Note that we return two more points that are not */ |
| /* part of the glyph outline. */ |
| |
| n_points += 2; |
| |
| /* now eventually scale and hint the glyph */ |
| |
| pts = &exec->pts; |
| pts->n_points = n_points; |
| pts->n_contours = n_contours; |
| |
| if (load_flags & FT_LOAD_NO_SCALE) |
| { |
| /* no scaling, just copy the orig arrays into the cur ones */ |
| org_to_cur( n_points, pts ); |
| } |
| else |
| { |
| /* first scale the glyph points */ |
| for ( j = 0; j < n_points; j++ ) |
| { |
| pts->org[j].x = SCALE_X( pts->org[j].x ); |
| pts->org[j].y = SCALE_Y( pts->org[j].y ); |
| } |
| |
| /* if hinting, round pp1, and shift the glyph accordingly */ |
| if ( subg->is_hinted ) |
| { |
| x = pts->org[n_points - 2].x; |
| x = ((x + 32) & -64) - x; |
| translate_array( n_points, pts->org, x, 0 ); |
| |
| org_to_cur( n_points, pts ); |
| |
| pts->cur[n_points - 1].x = (pts->cur[n_points - 1].x + 32) & -64; |
| |
| /* now consider hinting */ |
| if ( n_ins > 0 ) |
| { |
| exec->is_composite = FALSE; |
| exec->pedantic_hinting = load_flags & FT_LOAD_PEDANTIC; |
| |
| error = TT_Run_Context( exec, debug ); |
| if ( error && exec->pedantic_hinting ) |
| return error; |
| } |
| } |
| else |
| org_to_cur( n_points, pts ); |
| } |
| |
| /* save glyph phantom points */ |
| if ( !subg->preserve_pps ) |
| { |
| subg->pp1 = pts->cur[n_points - 2]; |
| subg->pp2 = pts->cur[n_points - 1]; |
| } |
| |
| return TT_Err_Ok; |
| |
| Fail: |
| FORGET_Frame(); |
| return error; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* Load_Composite_End */ |
| /* */ |
| /* <Description> */ |
| /* Finalizes the loading process of a composite glyph element. This */ |
| /* function is used for the `Load_End' state of TT_Load_Glyph(). */ |
| /* */ |
| static |
| TT_Error Load_Composite_End( TT_UShort n_points, |
| TT_Short n_contours, |
| TT_ExecContext exec, |
| TT_SubGlyphRec* subg, |
| FT_Stream stream, |
| TT_UInt load_flags, |
| TT_Bool debug ) |
| { |
| TT_Error error; |
| |
| TT_UShort k, n_ins; |
| TT_GlyphZone* pts; |
| |
| if ( subg->is_hinted && |
| subg->element_flag & WE_HAVE_INSTR ) |
| { |
| if ( READ_UShort( n_ins ) ) /* read size of instructions */ |
| return error; |
| |
| FT_TRACE4(( "Instructions size = %d\n", n_ins )); |
| |
| if ( n_ins > exec->face->max_profile.maxSizeOfInstructions ) |
| { |
| FT_TRACE0(( "Too many instructions in composite glyph %ld\n", |
| subg->index )); |
| return TT_Err_Too_Many_Ins; |
| } |
| |
| if ( FILE_Read( exec->glyphIns, n_ins ) ) |
| return error; |
| |
| error = TT_Set_CodeRange( exec, |
| tt_coderange_glyph, |
| exec->glyphIns, |
| n_ins ); |
| if ( error ) |
| return error; |
| } |
| else |
| n_ins = 0; |
| |
| |
| /* prepare the execution context */ |
| n_points += 2; |
| exec->pts = subg->zone; |
| pts = &exec->pts; |
| |
| pts->n_points = n_points; |
| pts->n_contours = n_contours; |
| |
| /* add phantom points */ |
| pts->cur[n_points - 2] = subg->pp1; |
| pts->cur[n_points - 1] = subg->pp2; |
| |
| pts->touch[n_points - 1] = 0; |
| pts->touch[n_points - 2] = 0; |
| |
| /* if hinting, round the phantom points */ |
| if ( subg->is_hinted ) |
| { |
| pts->cur[n_points - 2].x = ((subg->pp1.x + 32) & -64); |
| pts->cur[n_points - 1].x = ((subg->pp2.x + 32) & -64); |
| } |
| |
| for ( k = 0; k < n_points; k++ ) |
| pts->touch[k] &= FT_Curve_Tag_On; |
| |
| cur_to_org( n_points, pts ); |
| |
| /* now consider hinting */ |
| if ( subg->is_hinted && n_ins > 0 ) |
| { |
| exec->is_composite = TRUE; |
| exec->pedantic_hinting = load_flags & FT_LOAD_PEDANTIC; |
| |
| error = TT_Run_Context( exec, debug ); |
| if ( error && exec->pedantic_hinting ) |
| return error; |
| } |
| |
| /* save glyph origin and advance points */ |
| subg->pp1 = pts->cur[n_points - 2]; |
| subg->pp2 = pts->cur[n_points - 1]; |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* Init_Glyph_Component */ |
| /* */ |
| /* <Description> */ |
| /* Initializes a glyph component for further processing. */ |
| /* */ |
| static |
| void Init_Glyph_Component( TT_SubGlyphRec* element, |
| TT_SubGlyphRec* original, |
| TT_ExecContext exec ) |
| { |
| element->index = -1; |
| element->is_scaled = FALSE; |
| element->is_hinted = FALSE; |
| |
| if ( original ) |
| mount_zone( &original->zone, &element->zone ); |
| else |
| element->zone = exec->pts; |
| |
| element->zone.n_contours = 0; |
| element->zone.n_points = 0; |
| |
| element->arg1 = 0; |
| element->arg2 = 0; |
| |
| element->element_flag = 0; |
| element->preserve_pps = FALSE; |
| |
| element->transform.xx = 1 << 16; |
| element->transform.xy = 0; |
| element->transform.yx = 0; |
| element->transform.yy = 1 << 16; |
| |
| element->transform.ox = 0; |
| element->transform.oy = 0; |
| |
| element->left_bearing = 0; |
| element->advance = 0; |
| } |
| |
| |
| /*************************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Glyph */ |
| /* */ |
| /* <Description> */ |
| /* A function used to load a single glyph within a given glyph slot, */ |
| /* for a given size. */ |
| /* */ |
| /* <Input> */ |
| /* glyph :: A handle to a target slot object where the glyph */ |
| /* will be loaded. */ |
| /* */ |
| /* size :: A handle to the source face size at which the glyph */ |
| /* must be scaled/loaded. */ |
| /* */ |
| /* glyph_index :: The index of the glyph in the font file. */ |
| /* */ |
| /* load_flags :: A flag indicating what to load for this glyph. The */ |
| /* FT_LOAD_XXX constants can be used to control the */ |
| /* glyph loading process (e.g., whether the outline */ |
| /* should be scaled, whether to load bitmaps or not, */ |
| /* whether to hint the outline, etc). */ |
| /* <Output> */ |
| /* result :: A set of bit flags indicating the type of data that */ |
| /* was loaded in the glyph slot (outline or bitmap, */ |
| /* etc). */ |
| /* */ |
| /* You can set this field to 0 if you don't want this */ |
| /* information. */ |
| /* */ |
| /* <Return> */ |
| /* FreeType error code. 0 means success. */ |
| /* */ |
| LOCAL_FUNC |
| TT_Error TT_Load_Glyph( TT_Size size, |
| TT_GlyphSlot glyph, |
| TT_UShort glyph_index, |
| TT_UInt load_flags ) |
| { |
| typedef enum TPhases_ |
| { |
| Load_Exit, |
| Load_Glyph, |
| Load_Header, |
| Load_Simple, |
| Load_Composite, |
| Load_End |
| |
| } TPhases; |
| |
| TT_Error error = 0; |
| FT_Stream stream; |
| |
| TT_Face face; |
| |
| TT_UShort num_points; |
| TT_Short num_contours; |
| TT_UShort left_points; |
| TT_Short left_contours; |
| |
| TT_ULong load_top; |
| TT_Long k, l; |
| TT_Int new_flags; |
| TT_UShort index; |
| TT_UShort u; |
| TT_Long count; |
| |
| TT_Long glyph_offset, offset; |
| |
| TT_F26Dot6 x, y, nx, ny; |
| |
| TT_Fixed xx, xy, yx, yy; |
| TT_BBox bbox; |
| |
| TT_ExecContext exec; |
| |
| TT_SubGlyphRec *subglyph, *subglyph2; |
| |
| TT_GlyphZone base_pts; |
| |
| TPhases phase; |
| TT_Byte* widths; |
| |
| SFNT_Interface* sfnt; |
| |
| /* first of all, check arguments */ |
| if ( !glyph ) |
| return TT_Err_Invalid_Glyph_Handle; |
| |
| face = (TT_Face)glyph->face; |
| if ( !face ) |
| return TT_Err_Invalid_Glyph_Handle; |
| |
| sfnt = (SFNT_Interface*)face->sfnt; |
| stream = face->root.stream; |
| count = 0; |
| |
| if ( glyph_index >= face->root.num_glyphs ) |
| return TT_Err_Invalid_Glyph_Index; |
| |
| if ( !size || (load_flags & FT_LOAD_NO_SCALE) ) |
| { |
| size = NULL; |
| load_flags |= FT_LOAD_NO_SCALE | |
| FT_LOAD_NO_HINTING | |
| FT_LOAD_NO_BITMAP; |
| } |
| |
| /* 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; |
| } |
| } |
| |
| if ( load_flags & FT_LOAD_NO_OUTLINE ) |
| return ( error ? error : TT_Err_Unavailable_Bitmap ); |
| |
| error = face->goto_table( face, TTAG_glyf, stream, 0 ); |
| if (error) |
| { |
| FT_ERROR(( "TT.GLoad: could not access glyph table\n" )); |
| return error; |
| } |
| |
| glyph_offset = FILE_Pos(); |
| |
| /* query new execution context */ |
| |
| if ( size && size->debug ) |
| exec = size->context; |
| else |
| exec = TT_New_Context( face ); |
| |
| if ( !exec ) |
| return TT_Err_Could_Not_Find_Context; |
| |
| TT_Load_Context( exec, face, size ); |
| |
| if ( size ) |
| { |
| /* load default graphics state - if needed */ |
| if ( size->GS.instruct_control & 2 ) |
| exec->GS = tt_default_graphics_state; |
| |
| glyph->outline.high_precision = ( size->root.metrics.y_ppem < 24 ); |
| } |
| |
| /* save its critical pointers, as they'll be modified during load */ |
| base_pts = exec->pts; |
| |
| /* init variables */ |
| left_points = face->root.max_points; /* remove phantom points */ |
| left_contours = face->root.max_contours; |
| |
| num_points = 0; |
| num_contours = 0; |
| |
| load_top = 0; |
| subglyph = exec->loadStack; |
| |
| Init_Glyph_Component( subglyph, NULL, exec ); |
| |
| subglyph->index = glyph_index; |
| subglyph->is_hinted = !(load_flags & FT_LOAD_NO_HINTING); |
| |
| /* when the cvt program has disabled hinting, the argument */ |
| /* is ignored. */ |
| if ( size && (size->GS.instruct_control & 1) ) |
| subglyph->is_hinted = FALSE; |
| |
| /* Main loading loop */ |
| |
| phase = Load_Glyph; |
| index = 0; |
| |
| while ( phase != Load_Exit ) |
| { |
| subglyph = exec->loadStack + load_top; |
| |
| switch ( phase ) |
| { |
| |
| /************************************************************/ |
| /* */ |
| /* Load_Glyph state */ |
| /* */ |
| /* reading a glyph's generic data, checking whether the */ |
| /* glyph is cached already (not implemented yet) */ |
| /* */ |
| /* exit states: Load_Header and Load_End */ |
| /* */ |
| case Load_Glyph: |
| /* check glyph index and table */ |
| |
| index = (TT_UInt)subglyph->index; |
| if ( index >= face->root.num_glyphs ) |
| { |
| error = TT_Err_Invalid_Glyph_Index; |
| goto Fail; |
| } |
| |
| /* get horizontal metrics */ |
| { |
| TT_Short left_bearing; |
| TT_UShort advance_width; |
| |
| |
| Get_HMetrics( face, index, TRUE, |
| &left_bearing, |
| &advance_width ); |
| |
| subglyph->left_bearing = left_bearing; |
| subglyph->advance = advance_width; |
| } |
| |
| phase = Load_Header; |
| break; |
| |
| /************************************************************/ |
| /* */ |
| /* Load_Header state */ |
| /* */ |
| /* reading a glyph's generic header to determine whether */ |
| /* it is a simple or composite glyph */ |
| /* */ |
| /* exit states: Load_Simple and Load_Composite */ |
| /* */ |
| case Load_Header: |
| /* load glyph */ |
| |
| offset = face->glyph_locations[index]; |
| count = 0; |
| if (index < face->num_locations-1) |
| count = face->glyph_locations[index+1] - offset; |
| |
| if ( index < ( face->num_locations - 1 ) && count == 0 ) |
| { |
| /* as described by Frederic Loyer, these are spaces, and */ |
| /* not the unknown glyph. */ |
| |
| num_contours = 0; |
| num_points = 0; |
| |
| subglyph->bbox.xMin = 0; |
| subglyph->bbox.xMax = 0; |
| subglyph->bbox.yMin = 0; |
| subglyph->bbox.yMax = 0; |
| |
| subglyph->pp1.x = 0; |
| subglyph->pp2.x = subglyph->advance; |
| |
| if ( !(load_flags & FT_LOAD_NO_SCALE) ) |
| subglyph->pp2.x = SCALE_X( subglyph->pp2.x ); |
| |
| exec->glyphSize = 0; |
| phase = Load_End; |
| break; |
| } |
| |
| offset = glyph_offset + offset; |
| |
| /* read first glyph header */ |
| if ( FILE_Seek( offset ) || |
| ACCESS_Frame( 10L ) ) |
| goto Fail_File; |
| |
| num_contours = GET_Short(); |
| |
| subglyph->bbox.xMin = GET_Short(); |
| subglyph->bbox.yMin = GET_Short(); |
| subglyph->bbox.xMax = GET_Short(); |
| subglyph->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", |
| subglyph->bbox.xMin, |
| subglyph->bbox.xMax )); |
| FT_TRACE6(( " yMin: %4d yMax: %4d\n", |
| subglyph->bbox.yMin, |
| subglyph->bbox.yMax )); |
| FT_TRACE6(( "-" )); |
| |
| count -= 10; |
| |
| if ( num_contours > left_contours ) |
| { |
| FT_TRACE0(( "ERROR: Too many contours for glyph %ld\n", index )); |
| error = TT_Err_Too_Many_Contours; |
| goto Fail; |
| } |
| |
| subglyph->pp1.x = subglyph->bbox.xMin - subglyph->left_bearing; |
| subglyph->pp1.y = 0; |
| subglyph->pp2.x = subglyph->pp1.x + subglyph->advance; |
| if (!(load_flags & FT_LOAD_NO_SCALE)) |
| { |
| subglyph->pp1.x = SCALE_X( subglyph->pp1.x ); |
| subglyph->pp2.x = SCALE_X( subglyph->pp2.x ); |
| } |
| |
| /* is it a simple glyph ? */ |
| if ( num_contours > 0 ) |
| phase = Load_Simple; |
| else |
| phase = Load_Composite; |
| |
| break; |
| |
| /************************************************************/ |
| /* */ |
| /* Load_Simple state */ |
| /* */ |
| /* reading a simple glyph (num_contours must be set to */ |
| /* the glyph's number of contours.) */ |
| /* */ |
| /* exit state: Load_End */ |
| /* */ |
| case Load_Simple: |
| new_flags = load_flags; |
| |
| /* disable hinting when scaling */ |
| if ( !subglyph->is_hinted ) |
| new_flags |= FT_LOAD_NO_HINTING; |
| |
| error = Load_Simple_Glyph( exec, |
| stream, |
| count, |
| num_contours, |
| left_contours, |
| left_points, |
| new_flags, |
| subglyph, |
| (TT_Bool)(size && size->debug && |
| load_top == 0) ); |
| if ( error ) |
| goto Fail; |
| |
| /* Note: We could have put the simple loader source there */ |
| /* but the code is fat enough already :-) */ |
| |
| num_points = exec->pts.n_points - 2; |
| |
| phase = Load_End; |
| |
| break; |
| |
| /************************************************************/ |
| /* */ |
| /* Load_Composite state */ |
| /* */ |
| /* reading a composite glyph header and pushing a new */ |
| /* load element on the stack. */ |
| /* */ |
| /* exit state: Load_Glyph */ |
| /* */ |
| case Load_Composite: |
| |
| /* create a new element on the stack */ |
| load_top++; |
| |
| if ( load_top > face->max_components ) |
| { |
| error = TT_Err_Invalid_Composite; |
| goto Fail; |
| } |
| |
| subglyph2 = exec->loadStack + load_top; |
| |
| Init_Glyph_Component( subglyph2, subglyph, NULL ); |
| subglyph2->is_hinted = subglyph->is_hinted; |
| |
| /* now read composite header */ |
| |
| if ( ACCESS_Frame( 4L ) ) |
| goto Fail_File; |
| |
| subglyph->element_flag = new_flags = GET_UShort(); |
| |
| subglyph2->index = GET_UShort(); |
| |
| FORGET_Frame(); |
| |
| k = 1+1; |
| |
| if ( new_flags & ARGS_ARE_WORDS ) |
| k *= 2; |
| |
| if ( new_flags & WE_HAVE_A_SCALE ) |
| k += 2; |
| |
| else if ( new_flags & WE_HAVE_AN_XY_SCALE ) |
| k += 4; |
| |
| else if ( new_flags & WE_HAVE_A_2X2 ) |
| k += 8; |
| |
| if ( ACCESS_Frame( k ) ) |
| goto Fail_File; |
| |
| if ( new_flags & ARGS_ARE_WORDS ) |
| { |
| k = GET_Short(); |
| l = GET_Short(); |
| } |
| else |
| { |
| k = GET_Char(); |
| l = GET_Char(); |
| } |
| |
| subglyph->arg1 = k; |
| subglyph->arg2 = l; |
| |
| if ( new_flags & ARGS_ARE_XY_VALUES ) |
| { |
| subglyph->transform.ox = k; |
| subglyph->transform.oy = l; |
| } |
| |
| xx = 1 << 16; |
| xy = 0; |
| yx = 0; |
| yy = 1 << 16; |
| |
| if ( new_flags & WE_HAVE_A_SCALE ) |
| { |
| xx = (TT_Fixed)GET_Short() << 2; |
| yy = xx; |
| subglyph2->is_scaled = TRUE; |
| } |
| else if ( new_flags & WE_HAVE_AN_XY_SCALE ) |
| { |
| xx = (TT_Fixed)GET_Short() << 2; |
| yy = (TT_Fixed)GET_Short() << 2; |
| subglyph2->is_scaled = TRUE; |
| } |
| else if ( new_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; |
| subglyph2->is_scaled = TRUE; |
| } |
| |
| FORGET_Frame(); |
| |
| subglyph->transform.xx = xx; |
| subglyph->transform.xy = xy; |
| subglyph->transform.yx = yx; |
| subglyph->transform.yy = yy; |
| |
| k = FT_MulFix( xx, yy ) - FT_MulFix( xy, yx ); |
| |
| /* disable hinting in case of scaling/slanting */ |
| if ( ABS( k ) != (1 << 16) ) |
| subglyph2->is_hinted = FALSE; |
| |
| subglyph->file_offset = FILE_Pos(); |
| |
| phase = Load_Glyph; |
| |
| break; |
| |
| /************************************************************/ |
| /* */ |
| /* Load_End state */ |
| /* */ |
| /* after loading a glyph, apply transformation and offset */ |
| /* where necessary, pop element and continue or stop */ |
| /* process. */ |
| /* */ |
| /* exit states: Load_Composite and Load_Exit */ |
| /* */ |
| case Load_End: |
| if ( load_top > 0 ) |
| { |
| subglyph2 = subglyph; |
| |
| load_top--; |
| subglyph = exec->loadStack + load_top; |
| |
| /* check advance width and left side bearing */ |
| |
| if ( !subglyph->preserve_pps && |
| subglyph->element_flag & USE_MY_METRICS ) |
| { |
| subglyph->left_bearing = subglyph2->left_bearing; |
| subglyph->advance = subglyph2->advance; |
| |
| subglyph->pp1 = subglyph2->pp1; |
| subglyph->pp2 = subglyph2->pp2; |
| |
| subglyph->preserve_pps = TRUE; |
| } |
| |
| /* apply scale */ |
| |
| if ( subglyph2->is_scaled ) |
| { |
| TT_Vector* cur = subglyph2->zone.cur; |
| TT_Vector* org = subglyph2->zone.org; |
| |
| |
| for ( u = 0; u < num_points; u++ ) |
| { |
| 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; |
| |
| cur++; |
| org++; |
| } |
| } |
| |
| /* adjust counts */ |
| |
| for ( k = 0; k < num_contours; k++ ) |
| subglyph2->zone.contours[k] += subglyph->zone.n_points; |
| |
| subglyph->zone.n_points += num_points; |
| subglyph->zone.n_contours += num_contours; |
| |
| left_points -= num_points; |
| left_contours -= num_contours; |
| |
| /* apply offset */ |
| |
| if ( !(subglyph->element_flag & ARGS_ARE_XY_VALUES) ) |
| { |
| k = subglyph->arg1; |
| l = subglyph->arg2; |
| |
| if ( k >= subglyph->zone.n_points || |
| l >= num_points ) |
| { |
| error = TT_Err_Invalid_Composite; |
| goto Fail; |
| } |
| |
| l += subglyph->zone.n_points; |
| |
| x = subglyph->zone.cur[k].x - subglyph->zone.cur[l].x; |
| y = subglyph->zone.cur[k].y - subglyph->zone.cur[l].y; |
| } |
| else |
| { |
| x = subglyph->transform.ox; |
| y = subglyph->transform.oy; |
| |
| if (!(load_flags & FT_LOAD_NO_SCALE)) |
| { |
| x = SCALE_X( x ); |
| y = SCALE_Y( y ); |
| } |
| } |
| |
| if ( subglyph->element_flag & ROUND_XY_TO_GRID ) |
| { |
| x = (x + 32) & -64; |
| y = (y + 32) & -64; |
| } |
| |
| translate_array( num_points, subglyph2->zone.cur, x, y ); |
| |
| cur_to_org( num_points, &subglyph2->zone ); |
| |
| num_points = subglyph->zone.n_points; |
| num_contours = subglyph->zone.n_contours; |
| |
| /* check for last component */ |
| |
| if ( FILE_Seek( subglyph->file_offset ) ) |
| goto Fail_File; |
| |
| if ( subglyph->element_flag & MORE_COMPONENTS ) |
| phase = Load_Composite; |
| else |
| { |
| error = Load_Composite_End( num_points, |
| num_contours, |
| exec, |
| subglyph, |
| stream, |
| load_flags, |
| (TT_Bool)(size && size->debug && |
| load_top == 0) ); |
| if ( error ) |
| goto Fail; |
| |
| phase = Load_End; |
| } |
| } |
| else |
| phase = Load_Exit; |
| |
| break; |
| |
| case Load_Exit: |
| break; |
| } |
| } |
| |
| /* finally, copy the points arrays to the glyph object */ |
| |
| exec->pts = base_pts; |
| |
| for ( u = 0; u < num_points; u++ ) |
| { |
| glyph->outline.points[u] = exec->pts.cur[u]; |
| glyph->outline.flags [u] = exec->pts.touch[u]; |
| } |
| |
| for ( k = 0; k < num_contours; k++ ) |
| glyph->outline.contours[k] = exec->pts.contours[k]; |
| |
| glyph->outline.n_points = num_points; |
| glyph->outline.n_contours = num_contours; |
| glyph->outline.second_pass = TRUE; |
| |
| /* translate array so that (0,0) is the glyph's origin */ |
| translate_array( num_points, glyph->outline.points, |
| -subglyph->pp1.x, 0 ); |
| |
| FT_Get_Outline_CBox( &glyph->outline, &bbox ); |
| |
| if ( subglyph->is_hinted ) |
| { |
| /* 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 = subglyph->left_bearing; |
| advance = subglyph->advance; |
| |
| if ( face->postscript.isFixedPitch ) |
| advance = face->horizontal.advance_Width_Max; |
| |
| if ( !(load_flags & FT_LOAD_NO_SCALE) ) |
| { |
| left_bearing = SCALE_X( left_bearing ); |
| advance = SCALE_X( advance ); |
| } |
| |
| glyph->metrics2.horiBearingX = left_bearing; |
| glyph->metrics2.horiAdvance = advance; |
| } |
| |
| glyph->metrics.horiBearingX = bbox.xMin; |
| glyph->metrics.horiBearingY = bbox.yMax; |
| glyph->metrics.horiAdvance = subglyph->pp2.x - subglyph->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 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); |
| } |
| } |
| |
| /* scale the metrics */ |
| if ( !(load_flags & FT_LOAD_NO_SCALE) ) |
| { |
| top = SCALE_Y( top_bearing ); |
| advance = SCALE_X( advance_height ); |
| } |
| else |
| { |
| top = top_bearing; |
| 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 ( subglyph->is_hinted ) |
| { |
| 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 ( !exec->face->postscript.isFixedPitch && size && |
| subglyph->is_hinted ) |
| { |
| widths = Get_Advance_Widths( exec->face, |
| exec->size->root.metrics.x_ppem ); |
| if ( widths ) |
| glyph->metrics.horiAdvance = widths[glyph_index] << 6; |
| } |
| |
| glyph->outline.dropout_mode = (TT_Char)exec->GS.scan_type; |
| |
| /* set glyph dimensions */ |
| glyph->metrics.width = bbox.xMax - bbox.xMin; |
| glyph->metrics.height = bbox.yMax - bbox.yMin; |
| |
| glyph->format = ft_glyph_format_outline; |
| |
| error = TT_Err_Ok; |
| |
| Fail_File: |
| Fail: |
| |
| /* reset the execution context */ |
| exec->pts = base_pts; |
| |
| if ( !size || !size->debug ) |
| TT_Done_Context( exec ); |
| |
| return error; |
| } |
| |
| |
| /* END */ |
