Ignore:
Timestamp:
Jul 26, 2007, 6:17:07 AM (14 years ago)
Author:
Eugene Romanenko
Message:

PDF plugin: freetype library updated to version 2.3.5

Location:
trunk/poppler/freetype2/src/truetype
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/freetype2/src/truetype/ttdriver.c

    r182 r209  
    3030
    3131#include FT_SERVICE_TRUETYPE_ENGINE_H
     32#include FT_SERVICE_TRUETYPE_GLYF_H
    3233
    3334#include "ttdriver.h"
    3435#include "ttgload.h"
     36#include "ttpload.h"
    3537
    3638#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
     
    314316  };
    315317
     318  static const FT_Service_TTGlyfRec  tt_service_truetype_glyf =
     319  {
     320    (TT_Glyf_GetLocationFunc)tt_face_get_location
     321  };
     322
    316323  static const FT_ServiceDescRec  tt_services[] =
    317324  {
     
    321328#endif
    322329    { FT_SERVICE_ID_TRUETYPE_ENGINE, &tt_service_truetype_engine },
     330    { FT_SERVICE_ID_TT_GLYF,         &tt_service_truetype_glyf },
    323331    { NULL, NULL }
    324332  };
  • trunk/poppler/freetype2/src/truetype/ttgload.c

    r200 r209  
    109109      ( (SFNT_Service)face->sfnt )->get_metrics( face, 1, idx, tsb, ah );
    110110
    111 #if 1             /* Emperically determined, at variance with what MS said */
     111#if 1             /* Empirically determined, at variance with what MS said */
    112112
    113113    else
     
    245245    TT_Face         face       = (TT_Face)load->face;
    246246    FT_UShort       n_ins;
    247     FT_Int          n, n_points;
     247    FT_Int          n_points;
    248248
    249249    FT_Byte         *flag, *flag_limit;
     
    251251    FT_Vector       *vec, *vec_limit;
    252252    FT_Pos          x;
    253     FT_Short        *cont, *cont_limit;
     253    FT_Short        *cont, *cont_limit, prev_cont;
     254    FT_Int          xy_size = 0;
    254255
    255256
     
    264265
    265266    /* check space for contours array + instructions count */
    266     if ( n_contours >= 0xFFF || p + (n_contours + 1) * 2 > limit )
     267    if ( n_contours >= 0xFFF || p + ( n_contours + 1 ) * 2 > limit )
    267268      goto Invalid_Outline;
    268269
    269     for ( ; cont < cont_limit; cont++ )
     270    cont[0] = prev_cont = FT_NEXT_USHORT( p );
     271    for ( cont++; cont < cont_limit; cont++ )
     272    {
    270273      cont[0] = FT_NEXT_USHORT( p );
     274      if ( cont[0] <= prev_cont )
     275      {
     276        /* unordered contours: this is invalid */
     277        error = FT_Err_Invalid_Table;
     278        goto Fail;
     279      }
     280      prev_cont = cont[0];
     281    }
    271282
    272283    n_points = 0;
    273284    if ( n_contours > 0 )
     285    {
    274286      n_points = cont[-1] + 1;
     287      if ( n_points < 0 )
     288        goto Invalid_Outline;
     289    }
    275290
    276291    /* note that we will add four phantom points later */
     
    299314    if ( n_ins > face->max_profile.maxSizeOfInstructions )
    300315    {
    301       FT_TRACE0(( "TT_Load_Simple_Glyph: Too many instructions!\n" ));
     316      FT_TRACE0(( "TT_Load_Simple_Glyph: Too many instructions (%d)\n",
     317                  n_ins ));
    302318      error = TT_Err_Too_Many_Hints;
    303319      goto Fail;
     
    358374    x         = 0;
    359375
     376    if ( p + xy_size > limit )
     377      goto Invalid_Outline;
     378
    360379    for ( ; vec < vec_limit; vec++, flag++ )
    361380    {
    362381      FT_Pos  y = 0;
    363 
    364 
    365       if ( *flag & 2 )
     382      FT_Byte f = *flag;
     383
     384
     385      if ( f & 2 )
    366386      {
    367387        if ( p + 1 > limit )
     
    369389
    370390        y = (FT_Pos)FT_NEXT_BYTE( p );
    371         if ( ( *flag & 16 ) == 0 )
     391        if ( ( f & 16 ) == 0 )
    372392          y = -y;
    373393      }
    374       else if ( ( *flag & 16 ) == 0 )
     394      else if ( ( f & 16 ) == 0 )
    375395      {
    376396        if ( p + 2 > limit )
     
    382402      x     += y;
    383403      vec->x = x;
     404      *flag  = f & ~( 2 | 16 );
    384405    }
    385406
     
    394415    {
    395416      FT_Pos  y = 0;
    396 
    397 
    398       if ( *flag & 4 )
    399       {
    400         if ( p  +1 > limit )
     417      FT_Byte f = *flag;
     418
     419
     420      if ( f & 4 )
     421      {
     422        if ( p + 1 > limit )
    401423          goto Invalid_Outline;
    402424
    403425        y = (FT_Pos)FT_NEXT_BYTE( p );
    404         if ( ( *flag & 32 ) == 0 )
     426        if ( ( f & 32 ) == 0 )
    405427          y = -y;
    406428      }
    407       else if ( ( *flag & 32 ) == 0 )
     429      else if ( ( f & 32 ) == 0 )
    408430      {
    409431        if ( p + 2 > limit )
     
    415437      x     += y;
    416438      vec->y = x;
    417     }
    418 
    419     /* clear the touch tags */
    420     for ( n = 0; n < n_points; n++ )
    421       outline->tags[n] &= FT_CURVE_TAG_ON;
     439      *flag  = f & FT_CURVE_TAG_ON;
     440    }
    422441
    423442    outline->n_points   = (FT_UShort)n_points;
     
    573592                   FT_UInt       start_contour )
    574593  {
    575     zone->n_points   = (FT_UShort)( load->outline.n_points - start_point );
    576     zone->n_contours = (FT_Short) ( load->outline.n_contours - start_contour );
    577     zone->org        = load->extra_points + start_point;
    578     zone->cur        = load->outline.points + start_point;
    579     zone->orus       = load->extra_points2 + start_point;
    580     zone->tags       = (FT_Byte*)load->outline.tags + start_point;
    581     zone->contours   = (FT_UShort*)load->outline.contours + start_contour;
     594    zone->n_points    = (FT_UShort)( load->outline.n_points - start_point );
     595    zone->n_contours  = (FT_Short) ( load->outline.n_contours -
     596                                       start_contour );
     597    zone->org         = load->extra_points + start_point;
     598    zone->cur         = load->outline.points + start_point;
     599    zone->orus        = load->extra_points2 + start_point;
     600    zone->tags        = (FT_Byte*)load->outline.tags + start_point;
     601    zone->contours    = (FT_UShort*)load->outline.contours + start_contour;
    582602    zone->first_point = (FT_UShort)start_point;
    583603  }
     
    935955  /* <Description>                                                         */
    936956  /*    This is slightly different from TT_Process_Simple_Glyph, in that   */
    937   /*    it's sole purpose is to hint the glyph.  Thus this function is     */
     957  /*    its sole purpose is to hint the glyph.  Thus this function is      */
    938958  /*    only available when bytecode interpreter is enabled.               */
    939959  /*                                                                       */
     
    9851005      if ( n_ins > ((TT_Face)loader->face)->max_profile.maxSizeOfInstructions )
    9861006      {
    987         FT_TRACE0(( "Too many instructions (%d)\n", n_ins ));
     1007        FT_TRACE0(( "TT_Process_Composite_Glyph: Too many instructions (%d)\n",
     1008                    n_ins ));
    9881009
    9891010        return TT_Err_Too_Many_Hints;
     
    12851306    else if ( loader->n_contours == -1 )
    12861307    {
    1287       FT_UInt       start_point;
    1288       FT_UInt       start_contour;
    1289       FT_ULong      ins_pos;  /* position of composite instructions, if any */
     1308      FT_UInt   start_point;
     1309      FT_UInt   start_contour;
     1310      FT_ULong  ins_pos;  /* position of composite instructions, if any */
    12901311
    12911312
     
    13171338        /* for each component's translation */
    13181339
    1319         if ( (error = TT_Vary_Get_Glyph_Deltas(
    1320                         face,
    1321                         glyph_index,
    1322                         &deltas,
    1323                         gloader->current.num_subglyphs + 4 )) != 0 )
     1340        if ( ( error = TT_Vary_Get_Glyph_Deltas(
     1341                         face,
     1342                         glyph_index,
     1343                         &deltas,
     1344                         gloader->current.num_subglyphs + 4 )) != 0 )
    13241345          goto Exit;
    13251346
     
    13571378      /* `as is' in the glyph slot (the client application will be     */
    13581379      /* responsible for interpreting these data)...                   */
    1359       /*                                                               */
    13601380      if ( loader->load_flags & FT_LOAD_NO_RECURSE )
    13611381      {
     
    13711391
    13721392      {
    1373         FT_UInt      n, num_base_points;
    1374         FT_SubGlyph  subglyph       = 0;
    1375 
    1376         FT_UInt      num_points     = start_point;
    1377         FT_UInt      num_subglyphs  = gloader->current.num_subglyphs;
    1378         FT_UInt      num_base_subgs = gloader->base.num_subglyphs;
    1379 
     1393        FT_UInt           n, num_base_points;
     1394        FT_SubGlyph       subglyph       = 0;
     1395
     1396        FT_UInt           num_points     = start_point;
     1397        FT_UInt           num_subglyphs  = gloader->current.num_subglyphs;
     1398        FT_UInt           num_base_subgs = gloader->base.num_subglyphs;
     1399
     1400        FT_Stream         old_stream     = loader->stream;
     1401
     1402        TT_GraphicsState  saved_GS;
     1403
     1404
     1405        if ( loader->exec )
     1406          saved_GS = loader->exec->GS;
    13801407
    13811408        FT_GlyphLoader_Add( gloader );
     
    13861413          FT_Vector  pp[4];
    13871414
     1415
     1416          /* reinitialize graphics state */
     1417          if ( loader->exec )
     1418            loader->exec->GS = saved_GS;
    13881419
    13891420          /* Each time we call load_truetype_glyph in this loop, the   */
     
    14211452            continue;
    14221453
    1423           /* gloader->base.outline consists of three part:                  */
    1424           /* 0 -(1)-> start_point -(2)-> num_base_points -(3)-> n_points.   */
    1425           /*                                                                */
    1426           /* (1): exist from the beginning                                  */
    1427           /* (2): components that have been loaded so far                   */
    1428           /* (3): the newly loaded component                                */
     1454          /* gloader->base.outline consists of three parts:               */
     1455          /* 0 -(1)-> start_point -(2)-> num_base_points -(3)-> n_points. */
     1456          /*                                                              */
     1457          /* (1): exists from the beginning                               */
     1458          /* (2): components that have been loaded so far                 */
     1459          /* (3): the newly loaded component                              */
    14291460          TT_Process_Composite_Component( loader, subglyph, start_point,
    14301461                                          num_base_points );
    14311462        }
    14321463
     1464        loader->stream = old_stream;
    14331465
    14341466        /* process the glyph */
     
    14491481    else
    14501482    {
    1451       /* invalid composite count ( negative but not -1 ) */
     1483      /* invalid composite count (negative but not -1) */
    14521484      error = TT_Err_Invalid_Outline;
    14531485      goto Exit;
     
    14771509
    14781510  static FT_Error
    1479   compute_glyph_metrics( TT_Loader   loader,
    1480                          FT_UInt     glyph_index )
     1511  compute_glyph_metrics( TT_Loader  loader,
     1512                         FT_UInt    glyph_index )
    14811513  {
    14821514    FT_BBox       bbox;
     
    14961528      bbox = loader->bbox;
    14971529
    1498     /* get the device-independent horizontal advance.  It is scaled later */
    1499     /* by the base layer.                                                 */
     1530    /* get the device-independent horizontal advance; it is scaled later */
     1531    /* by the base layer.                                                */
    15001532    {
    15011533      FT_Pos  advance = loader->linear;
     
    17571789      }
    17581790
    1759       /* see if the cvt program has disabled hinting */
     1791      /* see whether the cvt program has disabled hinting */
    17601792      if ( exec->GS.instruct_control & 1 )
    17611793        load_flags |= FT_LOAD_NO_HINTING;
    17621794
    1763       /* load default graphics state - if needed */
     1795      /* load default graphics state -- if needed */
    17641796      if ( exec->GS.instruct_control & 2 )
    17651797        exec->GS = tt_default_graphics_state;
     
    17721804#endif /* TT_USE_BYTECODE_INTERPRETER */
    17731805
    1774     /* seek to the beginning of the glyph table.  For Type 42 fonts      */
     1806    /* seek to the beginning of the glyph table -- for Type 42 fonts     */
    17751807    /* the table might be accessed from a Postscript stream or something */
    17761808    /* else...                                                           */
     
    18501882  {
    18511883    TT_Face       face;
    1852     FT_Stream     stream;
    18531884    FT_Error      error;
    18541885    TT_LoaderRec  loader;
     
    18561887
    18571888    face   = (TT_Face)glyph->face;
    1858     stream = face->root.stream;
    18591889    error  = TT_Err_Ok;
    18601890
     
    18901920    glyph->outline.flags = 0;
    18911921
    1892     /* Main loading loop */
     1922    /* main loading loop */
    18931923    error = load_truetype_glyph( &loader, glyph_index, 0 );
    18941924    if ( !error )
  • trunk/poppler/freetype2/src/truetype/ttinterp.c

    r200 r209  
    1717
    1818
    19   /* define FIX_BYTECODE to implement the bytecode interpreter fixes */
    20   /* needed to match Windows behaviour more accurately               */
    21 /* #define  FIX_BYTECODE */
    22 
    23 
    2419#include <ft2build.h>
    2520#include FT_INTERNAL_DEBUG_H
     
    164159          Ins_Goto_CodeRange( EXEC_ARG_ range, ip )
    165160
    166 #define CUR_Func_project( x, y ) \
    167           CUR.func_project( EXEC_ARG_ x, y )
    168 
    169161#define CUR_Func_move( z, p, d ) \
    170162          CUR.func_move( EXEC_ARG_ z, p, d )
     
    173165          CUR.func_move_orig( EXEC_ARG_ z, p, d )
    174166
    175 #define CUR_Func_dualproj( x, y ) \
    176           CUR.func_dualproj( EXEC_ARG_ x, y )
    177 
    178167#define CUR_Func_round( d, c ) \
    179168          CUR.func_round( EXEC_ARG_ d, c )
     
    211200#define MOVE_Zp2_Point( a, b, c, t ) \
    212201          Move_Zp2_Point( EXEC_ARG_ a, b, c, t )
     202
     203
     204#define CUR_Func_project( v1, v2 )  \
     205          CUR.func_project( EXEC_ARG_ (v1)->x - (v2)->x, (v1)->y - (v2)->y )
     206
     207#define CUR_Func_dualproj( v1, v2 )  \
     208          CUR.func_dualproj( EXEC_ARG_ (v1)->x - (v2)->x, (v1)->y - (v2)->y )
     209
     210#define CUR_fast_project( v ) \
     211          CUR.func_project( EXEC_ARG_ (v)->x, (v)->y )
     212
     213#define CUR_fast_dualproj( v ) \
     214          CUR.func_dualproj( EXEC_ARG_ (v)->x, (v)->y )
    213215
    214216
     
    619621    exec->pts.n_points   = 0;
    620622    exec->pts.n_contours = 0;
     623
     624    exec->zp1 = exec->pts;
     625    exec->zp2 = exec->pts;
     626    exec->zp0 = exec->pts;
    621627
    622628    exec->instruction_trap = FALSE;
     
    11261132  };
    11271133
    1128   static
    1129   const FT_Vector  Null_Vector = {0,0};
    1130 
    1131 
    11321134#undef PACK
    11331135
    1134 
    1135 #undef  NULL_Vector
    1136 #define NULL_Vector  (FT_Vector*)&Null_Vector
    1137 
     1136#if 1
     1137
     1138  static FT_Int32
     1139  TT_MulFix14( FT_Int32  a,
     1140               FT_Int    b )
     1141  {
     1142    FT_Int32   sign;
     1143    FT_UInt32  ah, al, mid, lo, hi;
     1144
     1145
     1146    sign = a ^ b;
     1147
     1148    if ( a < 0 )
     1149      a = -a;
     1150    if ( b < 0 )
     1151      b = -b;
     1152
     1153    ah = (FT_UInt32)( ( a >> 16 ) & 0xFFFFU );
     1154    al = (FT_UInt32)( a & 0xFFFFU );
     1155
     1156    lo    = al * b;
     1157    mid   = ah * b;
     1158    hi    = mid >> 16;
     1159    mid   = ( mid << 16 ) + ( 1 << 13 ); /* rounding */
     1160    lo   += mid;
     1161    if ( lo < mid )
     1162      hi += 1;
     1163
     1164    mid = ( lo >> 14 ) | ( hi << 18 );
     1165
     1166    return sign >= 0 ? (FT_Int32)mid : -(FT_Int32)mid;
     1167  }
     1168
     1169#else
    11381170
    11391171  /* compute (a*b)/2^14 with maximal accuracy and rounding */
     
    11601192
    11611193    l   = lo + 0x2000U;
    1162     hi += (l < lo);
     1194    hi += l < lo;
    11631195
    11641196    return ( hi << 18 ) | ( l >> 14 );
    11651197  }
     1198#endif
    11661199
    11671200
     
    18521885    FT_F26Dot6  val;
    18531886
    1854 
    18551887    FT_UNUSED_EXEC;
     1888
    18561889
    18571890    if ( distance >= 0 )
     
    21232156    }
    21242157
    2125     if ( (selector & 0x0F) == 0 )
     2158    if ( ( selector & 0x0F ) == 0 )
    21262159      CUR.threshold = CUR.period - 1;
    21272160    else
     
    21512184  /*                                                                       */
    21522185  static FT_F26Dot6
    2153   Project( EXEC_OP_ FT_Vector*  v1,
    2154                     FT_Vector*  v2 )
     2186  Project( EXEC_OP_ FT_Pos  dx,
     2187                    FT_Pos  dy )
    21552188  {
    21562189#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
     
    21582191#endif
    21592192
    2160     return TT_DotFix14( v1->x - v2->x,
    2161                         v1->y - v2->y,
     2193    return TT_DotFix14( dx, dy,
    21622194                        CUR.GS.projVector.x,
    21632195                        CUR.GS.projVector.y );
    21642196  }
     2197
    21652198
    21662199  /*************************************************************************/
     
    21812214  /*                                                                       */
    21822215  static FT_F26Dot6
    2183   Dual_Project( EXEC_OP_ FT_Vector*  v1,
    2184                          FT_Vector*  v2 )
    2185   {
    2186     return TT_DotFix14( v1->x - v2->x,
    2187                         v1->y - v2->y,
     2216  Dual_Project( EXEC_OP_ FT_Pos  dx,
     2217                         FT_Pos  dy )
     2218  {
     2219    return TT_DotFix14( dx, dy,
    21882220                        CUR.GS.dualVector.x,
    21892221                        CUR.GS.dualVector.y );
     
    22082240  /*                                                                       */
    22092241  static FT_F26Dot6
    2210   Project_x( EXEC_OP_ FT_Vector*  v1,
    2211                       FT_Vector*  v2 )
     2242  Project_x( EXEC_OP_ FT_Pos  dx,
     2243                      FT_Pos  dy )
    22122244  {
    22132245    FT_UNUSED_EXEC;
    2214 
    2215     return ( v1->x - v2->x );
     2246    FT_UNUSED( dy );
     2247
     2248    return dx;
    22162249  }
    22172250
     
    22342267  /*                                                                       */
    22352268  static FT_F26Dot6
    2236   Project_y( EXEC_OP_ FT_Vector*  v1,
    2237                       FT_Vector*  v2 )
     2269  Project_y( EXEC_OP_ FT_Pos  dx,
     2270                      FT_Pos  dy )
    22382271  {
    22392272    FT_UNUSED_EXEC;
    2240 
    2241    return ( v1->y - v2->y );
     2273    FT_UNUSED( dx );
     2274
     2275    return dy;
    22422276  }
    22432277
     
    46204654
    46214655
    4622     L = (FT_UShort)(CUR.opcode - 0xB0 + 1);
     4656    L = (FT_UShort)( CUR.opcode - 0xB0 + 1 );
    46234657
    46244658    if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
     
    46454679
    46464680
    4647     L = (FT_UShort)(CUR.opcode - 0xB8 + 1);
     4681    L = (FT_UShort)( CUR.opcode - 0xB8 + 1 );
    46484682
    46494683    if ( BOUNDS( L, CUR.stackSize + 1 - CUR.top ) )
     
    47024736    {
    47034737      if ( CUR.opcode & 1 )
    4704         R = CUR_Func_dualproj( CUR.zp2.org + L, NULL_Vector );
     4738        R = CUR_fast_dualproj( &CUR.zp2.org[L] );
    47054739      else
    4706         R = CUR_Func_project( CUR.zp2.cur + L, NULL_Vector );
     4740        R = CUR_fast_project( &CUR.zp2.cur[L] );
    47074741    }
    47084742
     
    47374771    }
    47384772
    4739     K = CUR_Func_project( CUR.zp2.cur + L, NULL_Vector );
     4773    K = CUR_fast_project( &CUR.zp2.cur[L] );
    47404774
    47414775    CUR_Func_move( &CUR.zp2, L, args[1] - K );
     
    47884822        D = CUR_Func_project( CUR.zp0.cur + L, CUR.zp1.cur + K );
    47894823      else
    4790       {
    4791 
    4792 #ifdef FIX_BYTECODE
    4793 
    4794         FT_Vector  vec1, vec2;
    4795 
    4796 
    4797         if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
    4798           FT_ARRAY_COPY( CUR.twilight.orus,
    4799                          CUR.twilight.org,
    4800                          CUR.twilight.n_points );
    4801 
    4802         /* get scaled orus coordinates */
    4803         vec1 = CUR.zp0.orus[L];
    4804         vec2 = CUR.zp1.orus[K];
    4805 
    4806         vec1.x = TT_MULFIX( vec1.x, CUR.metrics.x_scale );
    4807         vec1.y = TT_MULFIX( vec1.y, CUR.metrics.y_scale );
    4808         vec2.x = TT_MULFIX( vec2.x, CUR.metrics.x_scale );
    4809         vec2.y = TT_MULFIX( vec2.y, CUR.metrics.y_scale );
    4810 
    4811         D = CUR_Func_dualproj( &vec1, &vec2 );
    4812 
    4813 #else
    4814 
    48154824        D = CUR_Func_dualproj( CUR.zp0.org + L, CUR.zp1.org + K );
    4816 
    4817 #endif /* FIX_BYTECODE */
    4818       }
    48194825    }
    48204826
     
    50695075
    50705076#if 0
    5071     if ( (args[0] & 0x100) != 0 && CUR.metrics.pointSize <= A )
     5077    if ( ( args[0] & 0x100 ) != 0 && CUR.metrics.pointSize <= A )
    50725078      CUR.GS.scan_control = TRUE;
    50735079#endif
    50745080
    5075     if ( (args[0] & 0x200) != 0 && CUR.tt_metrics.rotated )
     5081    if ( ( args[0] & 0x200 ) != 0 && CUR.tt_metrics.rotated )
    50765082      CUR.GS.scan_control = TRUE;
    50775083
    5078     if ( (args[0] & 0x400) != 0 && CUR.tt_metrics.stretched )
     5084    if ( ( args[0] & 0x400 ) != 0 && CUR.tt_metrics.stretched )
    50795085      CUR.GS.scan_control = TRUE;
    50805086
    50815087#if 0
    5082     if ( (args[0] & 0x800) != 0 && CUR.metrics.pointSize > A )
     5088    if ( ( args[0] & 0x800 ) != 0 && CUR.metrics.pointSize > A )
    50835089      CUR.GS.scan_control = FALSE;
    50845090#endif
    50855091
    5086     if ( (args[0] & 0x1000) != 0 && CUR.tt_metrics.rotated )
     5092    if ( ( args[0] & 0x1000 ) != 0 && CUR.tt_metrics.rotated )
    50875093      CUR.GS.scan_control = FALSE;
    50885094
    5089     if ( (args[0] & 0x2000) != 0 && CUR.tt_metrics.stretched )
     5095    if ( ( args[0] & 0x2000 ) != 0 && CUR.tt_metrics.stretched )
    50905096      CUR.GS.scan_control = FALSE;
    50915097  }
     
    55925598    CUR.GS.rp2 = point;
    55935599
    5594     if ( (CUR.opcode & 1) != 0 )
     5600    if ( ( CUR.opcode & 1 ) != 0 )
    55955601      CUR.GS.rp0 = point;
    55965602  }
     
    56245630    if ( ( CUR.opcode & 1 ) != 0 )
    56255631    {
    5626       cur_dist = CUR_Func_project( CUR.zp0.cur + point, NULL_Vector );
     5632      cur_dist = CUR_fast_project( &CUR.zp0.cur[point] );
    56275633      distance = CUR_Func_round( cur_dist,
    56285634                                 CUR.tt_metrics.compensations[0] ) - cur_dist;
     
    56645670    }
    56655671
    5666     /* UNDOCUMENTED!                                     */
     5672    /* XXX: UNDOCUMENTED!                                */
    56675673    /*                                                   */
    56685674    /* The behaviour of an MIAP instruction is quite     */
    56695675    /* different when used in the twilight zone.         */
    56705676    /*                                                   */
    5671     /* First, no control value cutin test is performed   */
     5677    /* First, no control value cut-in test is performed  */
    56725678    /* as it would fail anyway.  Second, the original    */
    56735679    /* point, i.e. (org_x,org_y) of zp0.point, is set    */
     
    56955701    }
    56965702
    5697     org_dist = CUR_Func_project( CUR.zp0.cur + point, NULL_Vector );
     5703    org_dist = CUR_fast_project( &CUR.zp0.cur[point] );
    56985704
    56995705    if ( ( CUR.opcode & 1 ) != 0 )   /* rounding and control cutin flag */
     
    57385744    /*      twilight zone?                                  */
    57395745
    5740 #ifdef FIX_BYTECODE
    5741 
    5742     {
    5743       FT_Vector  vec1, vec2;
    5744 
    5745 
    5746       if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
    5747         FT_ARRAY_COPY( CUR.twilight.orus,
    5748                        CUR.twilight.org,
    5749                        CUR.twilight.n_points );
    5750 
    5751       vec1 = CUR.zp1.orus[point];
    5752       vec2 = CUR.zp0.orus[CUR.GS.rp0];
    5753 
    5754       vec1.x = TT_MULFIX( vec1.x, CUR.metrics.x_scale );
    5755       vec1.y = TT_MULFIX( vec1.y, CUR.metrics.y_scale );
    5756 
    5757       vec2.x = TT_MULFIX( vec2.x, CUR.metrics.x_scale );
    5758       vec2.y = TT_MULFIX( vec2.y, CUR.metrics.y_scale );
    5759 
    5760       org_dist = CUR_Func_dualproj( &vec1, &vec2 );
    5761     }
    5762 
    5763 #else
    5764 
    5765     org_dist = CUR_Func_dualproj( CUR.zp1.org + point,
    5766                                   CUR.zp0.org + CUR.GS.rp0 );
    5767 
    5768 #endif /* FIX_BYTECODE */
     5746    /* XXX: UNDOCUMENTED: twilight zone special case */
     5747
     5748    if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
     5749    {
     5750      FT_Vector*  vec1 = &CUR.zp1.org[point];
     5751      FT_Vector*  vec2 = &CUR.zp0.org[CUR.GS.rp0];
     5752
     5753
     5754      org_dist = CUR_Func_dualproj( vec1, vec2 );
     5755    }
     5756    else
     5757    {
     5758      FT_Vector*  vec1 = &CUR.zp1.orus[point];
     5759      FT_Vector*  vec2 = &CUR.zp0.orus[CUR.GS.rp0];
     5760
     5761
     5762      if ( CUR.metrics.x_scale == CUR.metrics.y_scale )
     5763      {
     5764        /* this should be faster */
     5765        org_dist = CUR_Func_dualproj( vec1, vec2 );
     5766        org_dist = TT_MULFIX( org_dist, CUR.metrics.x_scale );
     5767      }
     5768      else
     5769      {
     5770        FT_Vector  vec;
     5771
     5772
     5773        vec.x = TT_MULFIX( vec1->x - vec2->x, CUR.metrics.x_scale );
     5774        vec.y = TT_MULFIX( vec1->y - vec2->y, CUR.metrics.y_scale );
     5775
     5776        org_dist = CUR_fast_dualproj( &vec );
     5777      }
     5778    }
    57695779
    57705780    /* single width cut-in test */
     
    58795889                             TT_MulFix14( cvt_dist, CUR.GS.freeVector.y );
    58805890
    5881       CUR.zp1.cur[point] = CUR.zp1.org[point];
    5882     }
    5883 
    5884     org_dist = CUR_Func_dualproj( CUR.zp1.org + point,
    5885                                   CUR.zp0.org + CUR.GS.rp0 );
    5886 
    5887     cur_dist = CUR_Func_project( CUR.zp1.cur + point,
    5888                                  CUR.zp0.cur + CUR.GS.rp0 );
     5891      CUR.zp1.cur[point] = CUR.zp0.cur[point];
     5892    }
     5893
     5894    org_dist = CUR_Func_dualproj( &CUR.zp1.org[point],
     5895                                  &CUR.zp0.org[CUR.GS.rp0] );
     5896    cur_dist = CUR_Func_project ( &CUR.zp1.cur[point],
     5897                                  &CUR.zp0.cur[CUR.GS.rp0] );
    58895898
    58905899    /* auto-flip test */
     
    59405949
    59415950    /* XXX: UNDOCUMENTED! */
    5942 
    59435951    CUR.GS.rp2 = point;
    59445952  }
     
    61186126  /* Stack:        uint32... -->                                           */
    61196127  /*                                                                       */
     6128
     6129  /* SOMETIMES, DUMBER CODE IS BETTER CODE */
     6130
    61206131  static void
    61216132  Ins_IP( INS_ARG )
    61226133  {
    6123     FT_F26Dot6  org_a, org_b, org_x,
    6124                 cur_a, cur_b, cur_x,
    6125                 distance = 0;
    6126     FT_UShort   point;
     6134    FT_F26Dot6  old_range, cur_range;
     6135    FT_Vector*  orus_base;
     6136    FT_Vector*  cur_base;
     6137    FT_Int      twilight;
    61276138
    61286139    FT_UNUSED_ARG;
     
    61356146    }
    61366147
    6137 #ifdef FIX_BYTECODE
    6138 
    6139     /* We need to deal in a special way with the twilight zone.  The easiest
    6140      * solution is simply to copy the coordinates from `org' to `orus'
    6141      * whenever someone tries to perform intersections based on some of its
    6142      * points.
    6143      *
    6144      * Otherwise, by definition, value of CUR.twilight[n] is (0,0),
    6145      * whatever value of `n'.
     6148    /*
     6149     * We need to deal in a special way with the twilight zone.
     6150     * Otherwise, by definition, the value of CUR.twilight.orus[n] is (0,0),
     6151     * for every n.
    61466152     */
    6147     if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 || CUR.GS.gep2 == 0 )
    6148     {
    6149       FT_ARRAY_COPY( CUR.twilight.orus,
    6150                      CUR.twilight.org,
    6151                      CUR.twilight.n_points );
    6152     }
    6153 
    6154 #endif /* FIX_BYTECODE */
    6155 
    6156     /* XXX: There are some glyphs in some braindead but popular  */
    6157     /*      fonts out there (e.g. [aeu]grave in monotype.ttf)    */
    6158     /*      calling IP[] with bad values of rp[12].              */
    6159     /*      Do something sane when this odd thing happens.       */
    6160 
     6153    twilight = CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 || CUR.GS.gep2 == 0;
     6154
     6155    if ( BOUNDS( CUR.GS.rp1, CUR.zp0.n_points ) )
     6156    {
     6157      if ( CUR.pedantic_hinting )
     6158        CUR.error = TT_Err_Invalid_Reference;
     6159      return;
     6160    }
     6161
     6162    if ( twilight )
     6163      orus_base = &CUR.zp0.org[CUR.GS.rp1];
     6164    else
     6165      orus_base = &CUR.zp0.orus[CUR.GS.rp1];
     6166
     6167    cur_base = &CUR.zp0.cur[CUR.GS.rp1];
     6168
     6169    /* XXX: There are some glyphs in some braindead but popular */
     6170    /*      fonts out there (e.g. [aeu]grave in monotype.ttf)   */
     6171    /*      calling IP[] with bad values of rp[12].             */
     6172    /*      Do something sane when this odd thing happens.      */
    61616173    if ( BOUNDS( CUR.GS.rp1, CUR.zp0.n_points ) ||
    61626174         BOUNDS( CUR.GS.rp2, CUR.zp1.n_points ) )
    61636175    {
    6164       org_a = cur_a = 0;
    6165       org_b = cur_b = 0;
     6176      old_range = 0;
     6177      cur_range = 0;
    61666178    }
    61676179    else
    61686180    {
    6169 
    6170 #ifdef FIX_BYTECODE
    6171 
    6172       FT_Vector  vec1, vec2;
    6173 
    6174 
    6175       vec1   = CUR.zp0.orus[CUR.GS.rp1];
    6176       vec2   = CUR.zp1.orus[CUR.GS.rp2];
    6177       vec1.x = TT_MULFIX( vec1.x, CUR.metrics.x_scale );
    6178       vec1.y = TT_MULFIX( vec1.y, CUR.metrics.y_scale );
    6179       vec2.x = TT_MULFIX( vec2.x, CUR.metrics.x_scale );
    6180       vec2.y = TT_MULFIX( vec2.y, CUR.metrics.y_scale );
    6181 
    6182       org_a = CUR_Func_dualproj( &vec1, NULL_Vector );
    6183       org_b = CUR_Func_dualproj( &vec2, NULL_Vector );
    6184 
    6185 #else
    6186 
    6187       org_a = CUR_Func_dualproj( CUR.zp0.org + CUR.GS.rp1, NULL_Vector );
    6188       org_b = CUR_Func_dualproj( CUR.zp1.org + CUR.GS.rp2, NULL_Vector );
    6189 
    6190 #endif /* FIX_BYTECODE */
    6191 
    6192       cur_a = CUR_Func_project( CUR.zp0.cur + CUR.GS.rp1, NULL_Vector );
    6193       cur_b = CUR_Func_project( CUR.zp1.cur + CUR.GS.rp2, NULL_Vector );
    6194     }
    6195 
    6196     while ( CUR.GS.loop > 0 )
    6197     {
    6198       CUR.args--;
    6199 
    6200       point = (FT_UShort)CUR.stack[CUR.args];
     6181      if ( twilight )
     6182        old_range = CUR_Func_dualproj( &CUR.zp1.org[CUR.GS.rp2],
     6183                                       orus_base );
     6184      else
     6185        old_range = CUR_Func_dualproj( &CUR.zp1.orus[CUR.GS.rp2],
     6186                                       orus_base );
     6187
     6188      cur_range = CUR_Func_project ( &CUR.zp1.cur[CUR.GS.rp2], cur_base );
     6189    }
     6190
     6191    for ( ; CUR.GS.loop > 0; --CUR.GS.loop )
     6192    {
     6193      FT_UInt     point = (FT_UInt)CUR.stack[--CUR.args];
     6194      FT_F26Dot6  org_dist, cur_dist, new_dist;
     6195
     6196
     6197      /* check point bounds */
    62016198      if ( BOUNDS( point, CUR.zp2.n_points ) )
    62026199      {
     
    62066203          return;
    62076204        }
     6205        continue;
    62086206      }
     6207
     6208      if ( twilight )
     6209        org_dist = CUR_Func_dualproj( &CUR.zp2.org[point], orus_base );
    62096210      else
    6210       {
    6211 
    6212 #ifdef FIX_BYTECODE
    6213 
    6214         FT_Vector  vec;
    6215 
    6216 
    6217         vec   = CUR.zp2.orus[point];
    6218         vec.x = TT_MULFIX( vec.x, CUR.metrics.x_scale );
    6219         vec.y = TT_MULFIX( vec.y, CUR.metrics.y_scale );
    6220 
    6221         org_x = CUR_Func_dualproj( &vec, NULL_Vector );
    6222 
    6223 #else
    6224 
    6225         org_x = CUR_Func_dualproj( CUR.zp2.org + point, NULL_Vector );
    6226 
    6227 #endif /* FIX_BYTECODE */
    6228 
    6229         cur_x = CUR_Func_project ( CUR.zp2.cur + point, NULL_Vector );
    6230 
    6231         if ( ( org_a <= org_b && org_x <= org_a ) ||
    6232              ( org_a >  org_b && org_x >= org_a ) )
    6233 
    6234           distance = ( cur_a - org_a ) + ( org_x - cur_x );
    6235 
    6236         else if ( ( org_a <= org_b  &&  org_x >= org_b ) ||
    6237                   ( org_a >  org_b  &&  org_x <  org_b ) )
    6238 
    6239           distance = ( cur_b - org_b ) + ( org_x - cur_x );
    6240 
    6241         else if ( org_b != org_a )
    6242            /* note: it seems that rounding this value isn't a good */
    6243            /*       idea (cf. width of capital `S' in Times)       */
    6244 
    6245            distance = TT_MULDIV( cur_b - cur_a,
    6246                                  org_x - org_a,
    6247                                  org_b - org_a ) + ( cur_a - cur_x );
    6248 
    6249         CUR_Func_move( &CUR.zp2, point, distance );
    6250       }
    6251 
    6252       CUR.GS.loop--;
    6253     }
    6254 
     6211        org_dist = CUR_Func_dualproj( &CUR.zp2.orus[point], orus_base );
     6212
     6213      cur_dist = CUR_Func_project ( &CUR.zp2.cur[point], cur_base );
     6214      new_dist = ( old_range != 0 )
     6215                   ? TT_MULDIV( org_dist, cur_range, old_range )
     6216                   : cur_dist;
     6217
     6218      CUR_Func_move( &CUR.zp2, (FT_UShort)point, new_dist - cur_dist );
     6219    }
    62556220    CUR.GS.loop = 1;
    62566221    CUR.new_top = CUR.args;
     
    62986263    FT_Vector*  curs;   /* arrays                          */
    62996264    FT_Vector*  orus;
     6265    FT_UInt     max_points;
    63006266
    63016267  } IUP_WorkerRec, *IUP_Worker;
     
    63366302
    63376303    if ( p1 > p2 )
     6304      return;
     6305
     6306    if ( BOUNDS( ref1, worker->max_points ) ||
     6307         BOUNDS( ref2, worker->max_points ) )
    63386308      return;
    63396309
     
    64376407
    64386408
     6409    /* ignore empty outlines */
     6410    if ( CUR.pts.n_contours == 0 )
     6411      return;
     6412
    64396413    if ( CUR.opcode & 1 )
    64406414    {
     
    64516425      V.orus = (FT_Vector*)( (FT_Pos*)CUR.pts.orus + 1 );
    64526426    }
     6427    V.max_points = CUR.pts.n_points;
    64536428
    64546429    contour = 0;
     
    64606435      first_point = point;
    64616436
    6462       while ( point <= end_point && (CUR.pts.tags[point] & mask) == 0 )
     6437      while ( point <= end_point && ( CUR.pts.tags[point] & mask ) == 0 )
    64636438        point++;
    64646439
  • trunk/poppler/freetype2/src/truetype/ttinterp.h

    r150 r209  
    55/*    TrueType bytecode interpreter (specification).                       */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    1919#ifndef __TTINTERP_H__
    2020#define __TTINTERP_H__
    21 
    2221
    2322#include <ft2build.h>
     
    8079  /* Distance projection along one of the projection vectors */
    8180  typedef FT_F26Dot6
    82   (*TT_Project_Func)( EXEC_OP_ FT_Vector*  v1,
    83                                FT_Vector*  v2 );
     81  (*TT_Project_Func)( EXEC_OP_ FT_Pos   dx,
     82                               FT_Pos   dy );
    8483
    8584  /* reading a cvt value.  Take care of non-square pixels if necessary */
  • trunk/poppler/freetype2/src/truetype/ttobjs.c

    r200 r209  
    284284        for ( nn = 0; trick_names[nn] != NULL; nn++ )
    285285        {
    286           if ( ttface->family_name                                    &&
    287                ft_strcmp( ttface->family_name, trick_names[nn] ) == 0 )
     286          if ( ttface->family_name                               &&
     287               ft_strstr( ttface->family_name, trick_names[nn] ) )
    288288          {
    289289            unpatented_hinting = 1;
     
    596596    /* Set default metrics */
    597597    {
    598       FT_Size_Metrics*  metrics  = &size->root.metrics;
     598      FT_Size_Metrics*  metrics  = &size->metrics;
    599599      TT_Size_Metrics*  metrics2 = &size->ttmetrics;
    600 
    601600
    602601      metrics->x_ppem = 0;
     
    695694
    696695      error = tt_size_run_prep( size );
     696      if ( !error )
     697          size->cvt_ready = 1;
    697698    }
    698699  Exit:
     
    700701  }
    701702
    702 #else /* !TT_USE_BYTECODE_INTERPRETER */
    703 
    704   FT_LOCAL_DEF( FT_Error )
    705   tt_size_ready_bytecode( TT_Size  size )
    706   {
    707     FT_UNUSED( size );
    708     return 0;
    709   }
    710 
    711 #endif /* !TT_USE_BYTECODE_INTERPRETER */
     703#endif /* TT_USE_BYTECODE_INTERPRETER */
    712704
    713705
  • trunk/poppler/freetype2/src/truetype/ttobjs.h

    r182 r209  
    424424  tt_size_run_prep( TT_Size  size );
    425425
     426  FT_LOCAL( FT_Error )
     427  tt_size_ready_bytecode( TT_Size  size );
     428
    426429#endif /* TT_USE_BYTECODE_INTERPRETER */
    427430
    428431  FT_LOCAL( FT_Error )
    429432  tt_size_reset( TT_Size  size );
    430 
    431   FT_LOCAL( FT_Error )
    432   tt_size_ready_bytecode( TT_Size  size );
    433433
    434434
Note: See TracChangeset for help on using the changeset viewer.