Ignore:
Timestamp:
Dec 3, 2006, 7:29:08 PM (15 years ago)
Author:
Eugene Romanenko
Message:

update to latest freetype cvs, (closes #76)

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

Legend:

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

    r150 r165  
    55/*    FreeType TrueType driver component (body only).                      */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2004 by                                           */
     7/*  Copyright 1996-2001, 2004, 2006 by                                     */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2525#include "ttobjs.c"     /* object manager      */
    2626
    27 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     27#ifdef TT_USE_BYTECODE_INTERPRETER
    2828#include "ttinterp.c"
    2929#endif
  • trunk/poppler/freetype2/src/truetype/ttdriver.c

    r150 r165  
    244244    TT_GlyphSlot  slot = (TT_GlyphSlot)ttslot;
    245245    TT_Size       size = (TT_Size)ttsize;
     246    FT_Face       face = ttslot->face;
    246247    FT_Error      error;
    247248
     
    252253    if ( !size )
    253254      return TT_Err_Invalid_Size_Handle;
     255
     256    if ( !face || glyph_index >= (FT_UInt)face->num_glyphs )
     257      return TT_Err_Invalid_Argument;
    254258
    255259    if ( load_flags & ( FT_LOAD_NO_RECURSE | FT_LOAD_NO_SCALE ) )
     
    295299  static const FT_Service_TrueTypeEngineRec  tt_service_truetype_engine =
    296300  {
    297 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     301#ifdef TT_USE_BYTECODE_INTERPRETER
    298302
    299303#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
     
    303307#endif
    304308
    305 #else /* !TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     309#else /* !TT_USE_BYTECODE_INTERPRETER */
    306310
    307311    FT_TRUETYPE_ENGINE_TYPE_NONE
    308312
    309 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     313#endif /* TT_USE_BYTECODE_INTERPRETER */
    310314  };
    311315
     
    355359      FT_MODULE_FONT_DRIVER        |
    356360      FT_MODULE_DRIVER_SCALABLE    |
    357 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     361#ifdef TT_USE_BYTECODE_INTERPRETER
    358362      FT_MODULE_DRIVER_HAS_HINTER,
    359363#else
  • trunk/poppler/freetype2/src/truetype/ttgload.c

    r150 r165  
    189189      return error;
    190190
     191    loader->cursor = stream->cursor;
     192    loader->limit  = stream->limit;
     193
    191194    return TT_Err_Ok;
    192195  }
     
    206209  TT_Load_Glyph_Header( TT_Loader  loader )
    207210  {
    208     FT_Stream  stream   = loader->stream;
    209     FT_Int     byte_len = loader->byte_len - 10;
    210 
    211 
    212     if ( byte_len < 0 )
     211    FT_Byte*  p     = loader->cursor;
     212    FT_Byte*  limit = loader->limit;
     213
     214
     215    if ( p + 10 > limit )
    213216      return TT_Err_Invalid_Outline;
    214217
    215     loader->n_contours = FT_GET_SHORT();
    216 
    217     loader->bbox.xMin = FT_GET_SHORT();
    218     loader->bbox.yMin = FT_GET_SHORT();
    219     loader->bbox.xMax = FT_GET_SHORT();
    220     loader->bbox.yMax = FT_GET_SHORT();
     218    loader->n_contours = FT_NEXT_SHORT( p );
     219
     220    loader->bbox.xMin = FT_NEXT_SHORT( p );
     221    loader->bbox.yMin = FT_NEXT_SHORT( p );
     222    loader->bbox.xMax = FT_NEXT_SHORT( p );
     223    loader->bbox.yMax = FT_NEXT_SHORT( p );
    221224
    222225    FT_TRACE5(( "  # of contours: %d\n", loader->n_contours ));
     
    225228    FT_TRACE5(( "  yMin: %4d  yMax: %4d\n", loader->bbox.yMin,
    226229                                            loader->bbox.yMax ));
    227     loader->byte_len = byte_len;
     230    loader->cursor = p;
    228231
    229232    return TT_Err_Ok;
     
    235238  {
    236239    FT_Error        error;
    237     FT_Stream       stream     = load->stream;
     240    FT_Byte*        p          = load->cursor;
     241    FT_Byte*        limit      = load->limit;
    238242    FT_GlyphLoader  gloader    = load->gloader;
    239243    FT_Int          n_contours = load->n_contours;
     
    242246    FT_UShort       n_ins;
    243247    FT_Int          n, n_points;
    244     FT_Int          byte_len   = load->byte_len;
    245248
    246249    FT_Byte         *flag, *flag_limit;
     
    261264
    262265    /* check space for contours array + instructions count */
    263     byte_len -= 2 * ( n_contours + 1 );
    264     if ( byte_len < 0 )
     266    if ( n_contours >= 0xFFF || p + (n_contours + 1) * 2 > limit )
    265267      goto Invalid_Outline;
    266268
    267269    for ( ; cont < cont_limit; cont++ )
    268       cont[0] = FT_GET_USHORT();
     270      cont[0] = FT_NEXT_USHORT( p );
    269271
    270272    n_points = 0;
     
    288290    load->glyph->control_data = 0;
    289291
    290     n_ins = FT_GET_USHORT();
     292    if ( p + 2 > limit )
     293      goto Invalid_Outline;
     294
     295    n_ins = FT_NEXT_USHORT( p );
    291296
    292297    FT_TRACE5(( "  Instructions size: %u\n", n_ins ));
     
    299304    }
    300305
    301     byte_len -= (FT_Int)n_ins;
    302     if ( byte_len < 0 )
     306    if ( ( limit - p ) < n_ins )
    303307    {
    304308      FT_TRACE0(( "TT_Load_Simple_Glyph: Instruction count mismatch!\n" ));
     
    307311    }
    308312
    309 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     313#ifdef TT_USE_BYTECODE_INTERPRETER
    310314
    311315    if ( IS_HINTED( load->load_flags ) )
     
    314318      load->glyph->control_data = load->exec->glyphIns;
    315319
    316       FT_MEM_COPY( load->exec->glyphIns, stream->cursor, (FT_Long)n_ins );
    317     }
    318 
    319 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
    320 
    321     stream->cursor += (FT_Int)n_ins;
     320      FT_MEM_COPY( load->exec->glyphIns, p, (FT_Long)n_ins );
     321    }
     322
     323#endif /* TT_USE_BYTECODE_INTERPRETER */
     324
     325    p += n_ins;
    322326
    323327    /* reading the point tags */
     
    329333    while ( flag < flag_limit )
    330334    {
    331       if ( --byte_len < 0 )
     335      if ( p + 1 > limit )
    332336        goto Invalid_Outline;
    333337
    334       *flag++ = c = FT_GET_BYTE();
     338      *flag++ = c = FT_NEXT_BYTE( p );
    335339      if ( c & 8 )
    336340      {
    337         if ( --byte_len < 0 )
     341        if ( p + 1 > limit )
    338342          goto Invalid_Outline;
    339343
    340         count = FT_GET_BYTE();
     344        count = FT_NEXT_BYTE( p );
    341345        if ( flag + (FT_Int)count > flag_limit )
    342346          goto Invalid_Outline;
     
    346350      }
    347351    }
    348 
    349     /* check that there is enough room to load the coordinates */
    350     for ( flag = (FT_Byte*)outline->tags; flag < flag_limit; flag++ )
    351     {
    352       if ( *flag & 2 )
    353         byte_len -= 1;
    354       else if ( ( *flag & 16 ) == 0 )
    355         byte_len -= 2;
    356 
    357       if ( *flag & 4 )
    358         byte_len -= 1;
    359       else if ( ( *flag & 32 ) == 0 )
    360         byte_len -= 2;
    361     }
    362 
    363     if ( byte_len < 0 )
    364       goto Invalid_Outline;
    365352
    366353    /* reading the X coordinates */
     
    378365      if ( *flag & 2 )
    379366      {
    380         y = (FT_Pos)FT_GET_BYTE();
     367        if ( p + 1 > limit )
     368          goto Invalid_Outline;
     369
     370        y = (FT_Pos)FT_NEXT_BYTE( p );
    381371        if ( ( *flag & 16 ) == 0 )
    382372          y = -y;
    383373      }
    384374      else if ( ( *flag & 16 ) == 0 )
    385         y = (FT_Pos)FT_GET_SHORT();
     375      {
     376        if ( p + 2 > limit )
     377          goto Invalid_Outline;
     378
     379        y = (FT_Pos)FT_NEXT_SHORT( p );
     380      }
    386381
    387382      x     += y;
     
    403398      if ( *flag & 4 )
    404399      {
    405         y = (FT_Pos)FT_GET_BYTE();
     400        if ( p  +1 > limit )
     401          goto Invalid_Outline;
     402
     403        y = (FT_Pos)FT_NEXT_BYTE( p );
    406404        if ( ( *flag & 32 ) == 0 )
    407405          y = -y;
    408406      }
    409407      else if ( ( *flag & 32 ) == 0 )
    410         y = (FT_Pos)FT_GET_SHORT();
     408      {
     409        if ( p + 2 > limit )
     410          goto Invalid_Outline;
     411
     412        y = (FT_Pos)FT_NEXT_SHORT( p );
     413      }
    411414
    412415      x     += y;
     
    421424    outline->n_contours = (FT_Short) n_contours;
    422425
    423     load->byte_len = byte_len;
     426    load->cursor = p;
    424427
    425428  Fail:
     
    436439  {
    437440    FT_Error        error;
    438     FT_Stream       stream  = loader->stream;
     441    FT_Byte*        p       = loader->cursor;
     442    FT_Byte*        limit   = loader->limit;
    439443    FT_GlyphLoader  gloader = loader->gloader;
    440444    FT_SubGlyph     subglyph;
    441445    FT_UInt         num_subglyphs;
    442     FT_Int          byte_len = loader->byte_len;
    443446
    444447
     
    448451    {
    449452      FT_Fixed  xx, xy, yy, yx;
     453      FT_UInt   count;
    450454
    451455
     
    456460
    457461      /* check space */
    458       byte_len -= 4;
    459       if ( byte_len < 0 )
     462      if ( p + 4 > limit )
    460463        goto Invalid_Composite;
    461464
     
    464467      subglyph->arg1 = subglyph->arg2 = 0;
    465468
    466       subglyph->flags = FT_GET_USHORT();
    467       subglyph->index = FT_GET_USHORT();
     469      subglyph->flags = FT_NEXT_USHORT( p );
     470      subglyph->index = FT_NEXT_USHORT( p );
    468471
    469472      /* check space */
    470       byte_len -= 2;
     473      count = 2;
    471474      if ( subglyph->flags & ARGS_ARE_WORDS )
    472         byte_len -= 2;
     475        count += 2;
    473476      if ( subglyph->flags & WE_HAVE_A_SCALE )
    474         byte_len -= 2;
     477        count += 2;
    475478      else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
    476         byte_len -= 4;
     479        count += 4;
    477480      else if ( subglyph->flags & WE_HAVE_A_2X2 )
    478         byte_len -= 8;
    479 
    480       if ( byte_len < 0 )
     481        count += 8;
     482
     483      if ( p + count > limit )
    481484        goto Invalid_Composite;
    482485
     
    484487      if ( subglyph->flags & ARGS_ARE_WORDS )
    485488      {
    486         subglyph->arg1 = FT_GET_SHORT();
    487         subglyph->arg2 = FT_GET_SHORT();
     489        subglyph->arg1 = FT_NEXT_SHORT( p );
     490        subglyph->arg2 = FT_NEXT_SHORT( p );
    488491      }
    489492      else
    490493      {
    491         subglyph->arg1 = FT_GET_CHAR();
    492         subglyph->arg2 = FT_GET_CHAR();
     494        subglyph->arg1 = FT_NEXT_CHAR( p );
     495        subglyph->arg2 = FT_NEXT_CHAR( p );
    493496      }
    494497
     
    499502      if ( subglyph->flags & WE_HAVE_A_SCALE )
    500503      {
    501         xx = (FT_Fixed)FT_GET_SHORT() << 2;
     504        xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
    502505        yy = xx;
    503506      }
    504507      else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE )
    505508      {
    506         xx = (FT_Fixed)FT_GET_SHORT() << 2;
    507         yy = (FT_Fixed)FT_GET_SHORT() << 2;
     509        xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
     510        yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
    508511      }
    509512      else if ( subglyph->flags & WE_HAVE_A_2X2 )
    510513      {
    511         xx = (FT_Fixed)FT_GET_SHORT() << 2;
    512         yx = (FT_Fixed)FT_GET_SHORT() << 2;
    513         xy = (FT_Fixed)FT_GET_SHORT() << 2;
    514         yy = (FT_Fixed)FT_GET_SHORT() << 2;
     514        xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
     515        yx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
     516        xy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
     517        yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2;
    515518      }
    516519
     
    526529    gloader->current.num_subglyphs = num_subglyphs;
    527530
    528 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
    529 
    530     {
     531#ifdef TT_USE_BYTECODE_INTERPRETER
     532
     533    {
     534      FT_Stream  stream = loader->stream;
     535
     536
    531537      /* we must undo the FT_FRAME_ENTER in order to point to the */
    532538      /* composite instructions, if we find some.               */
     
    534540      /*                                                        */
    535541      loader->ins_pos = (FT_ULong)( FT_STREAM_POS() +
    536                                     stream->cursor - stream->limit );
     542                                    p - limit );
    537543    }
    538544
    539545#endif
    540546
    541     loader->byte_len = byte_len;
     547    loader->cursor = p;
    542548
    543549  Fail:
     
    571577    zone->org        = load->extra_points + start_point;
    572578    zone->cur        = load->outline.points + start_point;
     579    zone->orus       = load->extra_points2 + start_point;
    573580    zone->tags       = (FT_Byte*)load->outline.tags + start_point;
    574581    zone->contours   = (FT_UShort*)load->outline.contours + start_contour;
     582    zone->first_point = (FT_UShort)start_point;
    575583  }
    576584
     
    585593  /*    the zone is supposed to include four phantom points.               */
    586594  /*                                                                       */
    587 #define cur_to_org( n, zone ) \
    588           FT_ARRAY_COPY( (zone)->org, (zone)->cur, (n) )
    589 
    590595  static FT_Error
    591596  TT_Hint_Glyph( TT_Loader  loader,
     
    595600    FT_Pos        origin;
    596601
    597 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     602#ifdef TT_USE_BYTECODE_INTERPRETER
    598603    FT_UInt       n_ins;
    599604#else
     
    602607
    603608
    604 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     609#ifdef TT_USE_BYTECODE_INTERPRETER
    605610    n_ins = loader->glyph->control_len;
    606611#endif
     
    611616      translate_array( zone->n_points, zone->cur, origin, 0 );
    612617
    613 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     618#ifdef TT_USE_BYTECODE_INTERPRETER
    614619    /* save original point positioin in org */
    615620    if ( n_ins > 0 )
    616       cur_to_org( zone->n_points, zone );
     621      FT_ARRAY_COPY( zone->org, zone->cur, zone->n_points );
    617622#endif
    618623
     
    623628      FT_PIX_ROUND( zone->cur[zone->n_points - 1].y );
    624629
    625 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     630#ifdef TT_USE_BYTECODE_INTERPRETER
    626631
    627632    if ( n_ins > 0 )
     
    726731#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
    727732
     733    if ( IS_HINTED( loader->load_flags ) )
     734    {
     735      tt_prepare_zone( &loader->zone, &gloader->current, 0, 0 );
     736
     737      FT_ARRAY_COPY( loader->zone.orus, loader->zone.cur,
     738                     loader->zone.n_points + 4 );
     739    }
     740
    728741    /* scale the glyph */
    729742    if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 )
     
    749762    if ( IS_HINTED( loader->load_flags ) )
    750763    {
    751       tt_prepare_zone( &loader->zone, &gloader->current, 0, 0 );
    752764      loader->zone.n_points += 4;
    753765
     
    933945    FT_Error     error;
    934946    FT_Outline*  outline;
     947    FT_UInt      i;
    935948
    936949
     
    954967    outline->tags[outline->n_points + 3] = 0;
    955968
    956 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     969#ifdef TT_USE_BYTECODE_INTERPRETER
    957970
    958971    {
     
    9901003    tt_prepare_zone( &loader->zone, &loader->gloader->base,
    9911004                     start_point, start_contour );
     1005
     1006    /* Some points are likely touched during execution of  */
     1007    /* instructions on components.  So let's untouch them. */
     1008    for ( i = start_point; i < loader->zone.n_points; i++ )
     1009      loader->zone.tags[i] &= ~( FT_CURVE_TAG_TOUCH_X |
     1010                                 FT_CURVE_TAG_TOUCH_Y );
     1011
    9921012    loader->zone.n_points += 4;
    9931013
     
    14161436        if ( IS_HINTED( loader->load_flags ) &&
    14171437
    1418 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     1438#ifdef TT_USE_BYTECODE_INTERPRETER
    14191439
    14201440             subglyph->flags & WE_HAVE_INSTR &&
     
    16961716    FT_MEM_ZERO( loader, sizeof ( TT_LoaderRec ) );
    16971717
    1698 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     1718#ifdef TT_USE_BYTECODE_INTERPRETER
    16991719
    17001720    /* load execution context */
    17011721    {
    17021722      TT_ExecContext  exec;
     1723      FT_Bool         grayscale;
    17031724
    17041725
     
    17091730        return TT_Err_Could_Not_Find_Context;
    17101731
     1732      grayscale =
     1733        FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) != FT_RENDER_MODE_MONO );
     1734
    17111735      TT_Load_Context( exec, face, size );
     1736
     1737      /* a change from mono to grayscale rendering (and vice versa) */
     1738      /* requires a re-execution of the CVT program                 */
     1739      if ( grayscale != exec->grayscale )
     1740      {
     1741        FT_UInt  i;
     1742
     1743
     1744        exec->grayscale = grayscale;
     1745
     1746        for ( i = 0; i < size->cvt_size; i++ )
     1747          size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
     1748        tt_size_run_prep( size );
     1749      }
    17121750
    17131751      /* see if the cvt program has disabled hinting */
     
    17201758
    17211759      exec->pedantic_hinting = FT_BOOL( load_flags & FT_LOAD_PEDANTIC );
    1722       exec->grayscale =
    1723         FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) != FT_LOAD_TARGET_MONO );
    1724 
    17251760      loader->exec = exec;
    17261761      loader->instructions = exec->glyphIns;
    17271762    }
    17281763
    1729 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     1764#endif /* TT_USE_BYTECODE_INTERPRETER */
    17301765
    17311766    /* seek to the beginning of the glyph table.  For Type 42 fonts      */
  • trunk/poppler/freetype2/src/truetype/ttgload.h

    r150 r165  
    55/*    TrueType Glyph Loader (specification).                               */
    66/*                                                                         */
    7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005 by                         */
     7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
    88/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
    99/*                                                                         */
     
    2424#include "ttobjs.h"
    2525
    26 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     26#ifdef TT_USE_BYTECODE_INTERPRETER
    2727#include "ttinterp.h"
    2828#endif
  • trunk/poppler/freetype2/src/truetype/ttinterp.c

    r150 r165  
    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
    1924#include <ft2build.h>
    2025#include FT_INTERNAL_DEBUG_H
     
    2833
    2934
    30 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     35#ifdef TT_USE_BYTECODE_INTERPRETER
    3136
    3237
     
    47824787        D = CUR_Func_project( CUR.zp0.cur + L, CUR.zp1.cur + K );
    47834788      else
     4789      {
     4790
     4791#ifdef FIX_BYTECODE
     4792
     4793        FT_Vector  vec1, vec2;
     4794
     4795
     4796        if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
     4797          FT_ARRAY_COPY( CUR.twilight.orus,
     4798                         CUR.twilight.org,
     4799                         CUR.twilight.n_points );
     4800
     4801        /* get scaled orus coordinates */
     4802        vec1 = CUR.zp0.orus[L];
     4803        vec2 = CUR.zp1.orus[K];
     4804
     4805        vec1.x = TT_MULFIX( vec1.x, CUR.metrics.x_scale );
     4806        vec1.y = TT_MULFIX( vec1.y, CUR.metrics.y_scale );
     4807        vec2.x = TT_MULFIX( vec2.x, CUR.metrics.x_scale );
     4808        vec2.y = TT_MULFIX( vec2.y, CUR.metrics.y_scale );
     4809
     4810        D = CUR_Func_dualproj( &vec1, &vec2 );
     4811
     4812#else
     4813
    47844814        D = CUR_Func_dualproj( CUR.zp0.org + L, CUR.zp1.org + K );
     4815
     4816#endif /* FIX_BYTECODE */
     4817      }
    47854818    }
    47864819
     
    53805413      first_point = 0;
    53815414    else
    5382       first_point = (FT_UShort)(CUR.pts.contours[contour - 1] + 1);
    5383 
    5384     last_point = CUR.pts.contours[contour];
     5415      first_point = (FT_UShort)( CUR.pts.contours[contour - 1] + 1 -
     5416                                 CUR.pts.first_point );
     5417
     5418    last_point = CUR.pts.contours[contour] - CUR.pts.first_point;
    53855419
    53865420    /* XXX: this is probably wrong... at least it prevents memory */
     
    56955729    /*      twilight zone?                                  */
    56965730
     5731#ifdef FIX_BYTECODE
     5732
     5733    {
     5734      FT_Vector  vec1, vec2;
     5735
     5736
     5737      if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 )
     5738        FT_ARRAY_COPY( CUR.twilight.orus,
     5739                       CUR.twilight.org,
     5740                       CUR.twilight.n_points );
     5741
     5742      vec1 = CUR.zp1.orus[point];
     5743      vec2 = CUR.zp0.orus[CUR.GS.rp0];
     5744
     5745      vec1.x = TT_MULFIX( vec1.x, CUR.metrics.x_scale );
     5746      vec1.y = TT_MULFIX( vec1.y, CUR.metrics.y_scale );
     5747
     5748      vec2.x = TT_MULFIX( vec2.x, CUR.metrics.x_scale );
     5749      vec2.y = TT_MULFIX( vec2.y, CUR.metrics.y_scale );
     5750
     5751      org_dist = CUR_Func_dualproj( &vec1, &vec2 );
     5752    }
     5753
     5754#else
     5755
    56975756    org_dist = CUR_Func_dualproj( CUR.zp1.org + point,
    56985757                                  CUR.zp0.org + CUR.GS.rp0 );
    56995758
    5700     /* single width cutin test */
     5759#endif /* FIX_BYTECODE */
     5760
     5761    /* single width cut-in test */
    57015762
    57025763    if ( FT_ABS( org_dist - CUR.GS.single_width_value ) <
     
    60536114    FT_F26Dot6  org_a, org_b, org_x,
    60546115                cur_a, cur_b, cur_x,
    6055                 distance;
     6116                distance = 0;
    60566117    FT_UShort   point;
    60576118
     
    60646125      return;
    60656126    }
     6127
     6128#ifdef FIX_BYTECODE
     6129
     6130    /* We need to deal in a special way with the twilight zone.  The easiest
     6131     * solution is simply to copy the coordinates from `org' to `orus'
     6132     * whenever someone tries to perform intersections based on some of its
     6133     * points.
     6134     *
     6135     * Otherwise, by definition, value of CUR.twilight[n] is (0,0),
     6136     * whatever value of `n'.
     6137     */
     6138    if ( CUR.GS.gep0 == 0 || CUR.GS.gep1 == 0 || CUR.GS.gep2 == 0 )
     6139    {
     6140      FT_ARRAY_COPY( CUR.twilight.orus,
     6141                     CUR.twilight.org,
     6142                     CUR.twilight.n_points );
     6143    }
     6144
     6145#endif /* FIX_BYTECODE */
    60666146
    60676147    /* XXX: There are some glyphs in some braindead but popular  */
     
    60786158    else
    60796159    {
     6160
     6161#ifdef FIX_BYTECODE
     6162
     6163      FT_Vector  vec1, vec2;
     6164
     6165
     6166      vec1   = CUR.zp0.orus[CUR.GS.rp1];
     6167      vec2   = CUR.zp1.orus[CUR.GS.rp2];
     6168      vec1.x = TT_MULFIX( vec1.x, CUR.metrics.x_scale );
     6169      vec1.y = TT_MULFIX( vec1.y, CUR.metrics.y_scale );
     6170      vec2.x = TT_MULFIX( vec2.x, CUR.metrics.x_scale );
     6171      vec2.y = TT_MULFIX( vec2.y, CUR.metrics.y_scale );
     6172
     6173      org_a = CUR_Func_dualproj( &vec1, NULL_Vector );
     6174      org_b = CUR_Func_dualproj( &vec2, NULL_Vector );
     6175
     6176#else
     6177
    60806178      org_a = CUR_Func_dualproj( CUR.zp0.org + CUR.GS.rp1, NULL_Vector );
    60816179      org_b = CUR_Func_dualproj( CUR.zp1.org + CUR.GS.rp2, NULL_Vector );
     6180
     6181#endif /* FIX_BYTECODE */
    60826182
    60836183      cur_a = CUR_Func_project( CUR.zp0.cur + CUR.GS.rp1, NULL_Vector );
     
    61006200      else
    61016201      {
     6202
     6203#ifdef FIX_BYTECODE
     6204
     6205        FT_Vector  vec;
     6206
     6207
     6208        vec   = CUR.zp2.orus[point];
     6209        vec.x = TT_MULFIX( vec.x, CUR.metrics.x_scale );
     6210        vec.y = TT_MULFIX( vec.y, CUR.metrics.y_scale );
     6211
     6212        org_x = CUR_Func_dualproj( &vec, NULL_Vector );
     6213
     6214#else
     6215
    61026216        org_x = CUR_Func_dualproj( CUR.zp2.org + point, NULL_Vector );
     6217
     6218#endif /* FIX_BYTECODE */
     6219
    61036220        cur_x = CUR_Func_project ( CUR.zp2.cur + point, NULL_Vector );
    61046221
     
    61136230          distance = ( cur_b - org_b ) + ( org_x - cur_x );
    61146231
    6115         else
     6232        else if ( org_b != org_a )
    61166233           /* note: it seems that rounding this value isn't a good */
    61176234           /*       idea (cf. width of capital `S' in Times)       */
     
    61676284
    61686285  /* Local variables for Ins_IUP: */
    6169   struct  LOC_Ins_IUP
     6286  typedef struct
    61706287  {
    61716288    FT_Vector*  orgs;   /* original and current coordinate */
    61726289    FT_Vector*  curs;   /* arrays                          */
    6173   };
    6174 
    6175 
    6176   static void
    6177   Shift( FT_UInt              p1,
    6178          FT_UInt              p2,
    6179          FT_UInt              p,
    6180          struct LOC_Ins_IUP*  LINK )
     6290    FT_Vector*  orus;
     6291
     6292  } IUP_WorkerRec, *IUP_Worker;
     6293
     6294
     6295  static void
     6296  _iup_worker_shift( IUP_Worker  worker,
     6297                     FT_UInt     p1,
     6298                     FT_UInt     p2,
     6299                     FT_UInt     p )
    61816300  {
    61826301    FT_UInt     i;
    6183     FT_F26Dot6  x;
    6184 
    6185 
    6186     x = LINK->curs[p].x - LINK->orgs[p].x;
    6187 
    6188     for ( i = p1; i < p; i++ )
    6189       LINK->curs[i].x += x;
    6190 
    6191     for ( i = p + 1; i <= p2; i++ )
    6192       LINK->curs[i].x += x;
    6193   }
    6194 
    6195 
    6196   static void
    6197   Interp( FT_UInt              p1,
    6198           FT_UInt              p2,
    6199           FT_UInt              ref1,
    6200           FT_UInt              ref2,
    6201           struct LOC_Ins_IUP*  LINK )
     6302    FT_F26Dot6  dx;
     6303
     6304
     6305    dx = worker->curs[p].x - worker->orgs[p].x;
     6306    if ( dx != 0 )
     6307    {
     6308      for ( i = p1; i < p; i++ )
     6309        worker->curs[i].x += dx;
     6310
     6311      for ( i = p + 1; i <= p2; i++ )
     6312        worker->curs[i].x += dx;
     6313    }
     6314  }
     6315
     6316
     6317  static void
     6318  _iup_worker_interpolate( IUP_Worker  worker,
     6319                           FT_UInt     p1,
     6320                           FT_UInt     p2,
     6321                           FT_UInt     ref1,
     6322                           FT_UInt     ref2 )
    62026323  {
    62036324    FT_UInt     i;
    6204     FT_F26Dot6  x, x1, x2, d1, d2;
     6325    FT_F26Dot6  orus1, orus2, org1, org2, delta1, delta2;
    62056326
    62066327
     
    62086329      return;
    62096330
    6210     x1 = LINK->orgs[ref1].x;
    6211     d1 = LINK->curs[ref1].x - LINK->orgs[ref1].x;
    6212     x2 = LINK->orgs[ref2].x;
    6213     d2 = LINK->curs[ref2].x - LINK->orgs[ref2].x;
    6214 
    6215     if ( x1 == x2 )
    6216     {
     6331    orus1 = worker->orus[ref1].x;
     6332    orus2 = worker->orus[ref2].x;
     6333
     6334    if ( orus1 > orus2 )
     6335    {
     6336      FT_F26Dot6  tmp_o;
     6337      FT_UInt     tmp_r;
     6338
     6339
     6340      tmp_o = orus1;
     6341      orus1 = orus2;
     6342      orus2 = tmp_o;
     6343
     6344      tmp_r = ref1;
     6345      ref1  = ref2;
     6346      ref2  = tmp_r;
     6347    }
     6348
     6349    org1   = worker->orgs[ref1].x;
     6350    org2   = worker->orgs[ref2].x;
     6351    delta1 = worker->curs[ref1].x - org1;
     6352    delta2 = worker->curs[ref2].x - org2;
     6353
     6354    if ( orus1 == orus2 )
     6355    {
     6356      /* simple shift of untouched points */
    62176357      for ( i = p1; i <= p2; i++ )
    62186358      {
    6219         x = LINK->orgs[i].x;
    6220 
    6221         if ( x <= x1 )
    6222           x += d1;
     6359        FT_F26Dot6  x = worker->orgs[i].x;
     6360
     6361
     6362        if ( x <= org1 )
     6363          x += delta1;
    62236364        else
    6224           x += d2;
    6225 
    6226         LINK->curs[i].x = x;
     6365          x += delta2;
     6366
     6367        worker->curs[i].x = x;
    62276368      }
    6228       return;
    6229     }
    6230 
    6231     if ( x1 < x2 )
    6232     {
     6369    }
     6370    else
     6371    {
     6372      FT_Fixed  scale       = 0;
     6373      FT_Bool   scale_valid = 0;
     6374
     6375
     6376      /* interpolation */
    62336377      for ( i = p1; i <= p2; i++ )
    62346378      {
    6235         x = LINK->orgs[i].x;
    6236 
    6237         if ( x <= x1 )
    6238           x += d1;
     6379        FT_F26Dot6  x = worker->orgs[i].x;
     6380
     6381
     6382        if ( x <= org1 )
     6383          x += delta1;
     6384
     6385        else if ( x >= org2 )
     6386          x += delta2;
     6387
    62396388        else
    62406389        {
    6241           if ( x >= x2 )
    6242             x += d2;
    6243           else
    6244             x = LINK->curs[ref1].x +
    6245                   TT_MULDIV( x - x1,
    6246                              LINK->curs[ref2].x - LINK->curs[ref1].x,
    6247                              x2 - x1 );
     6390          if ( !scale_valid )
     6391          {
     6392            scale_valid = 1;
     6393            scale       = TT_MULDIV( org2 + delta2 - ( org1 + delta1 ),
     6394                                     0x10000, orus2 - orus1 );
     6395          }
     6396
     6397          x = ( org1 + delta1 ) +
     6398              TT_MULFIX( worker->orus[i].x - orus1, scale );
    62486399        }
    6249         LINK->curs[i].x = x;
     6400        worker->curs[i].x = x;
    62506401      }
    6251       return;
    6252     }
    6253 
    6254     /* x2 < x1 */
    6255 
    6256     for ( i = p1; i <= p2; i++ )
    6257     {
    6258       x = LINK->orgs[i].x;
    6259       if ( x <= x2 )
    6260         x += d2;
    6261       else
    6262       {
    6263         if ( x >= x1 )
    6264           x += d1;
    6265         else
    6266           x = LINK->curs[ref1].x +
    6267               TT_MULDIV( x - x1,
    6268                          LINK->curs[ref2].x - LINK->curs[ref1].x,
    6269                          x2 - x1 );
    6270       }
    6271       LINK->curs[i].x = x;
    62726402    }
    62736403  }
     
    62836413  Ins_IUP( INS_ARG )
    62846414  {
    6285     struct LOC_Ins_IUP  V;
    6286     FT_Byte             mask;
     6415    IUP_WorkerRec  V;
     6416    FT_Byte        mask;
    62876417
    62886418    FT_UInt   first_point;   /* first point of contour        */
     
    63036433      V.orgs = CUR.pts.org;
    63046434      V.curs = CUR.pts.cur;
     6435      V.orus = CUR.pts.orus;
    63056436    }
    63066437    else
     
    63096440      V.orgs = (FT_Vector*)( (FT_Pos*)CUR.pts.org + 1 );
    63106441      V.curs = (FT_Vector*)( (FT_Pos*)CUR.pts.cur + 1 );
     6442      V.orus = (FT_Vector*)( (FT_Pos*)CUR.pts.orus + 1 );
    63116443    }
    63126444
     
    63166448    do
    63176449    {
    6318       end_point   = CUR.pts.contours[contour];
     6450      end_point   = CUR.pts.contours[contour] - CUR.pts.first_point;
    63196451      first_point = point;
    63206452
     
    63346466          {
    63356467            if ( point > 0 )
    6336               Interp( cur_touched + 1,
    6337                       point - 1,
    6338                       cur_touched,
    6339                       point,
    6340                       &V );
     6468              _iup_worker_interpolate( &V,
     6469                                       cur_touched + 1,
     6470                                       point - 1,
     6471                                       cur_touched,
     6472                                       point );
    63416473            cur_touched = point;
    63426474          }
     
    63466478
    63476479        if ( cur_touched == first_touched )
    6348           Shift( first_point, end_point, cur_touched, &V );
     6480          _iup_worker_shift( &V, first_point, end_point, cur_touched );
    63496481        else
    63506482        {
    6351           Interp( (FT_UShort)( cur_touched + 1 ),
    6352                   end_point,
    6353                   cur_touched,
    6354                   first_touched,
    6355                   &V );
     6483          _iup_worker_interpolate( &V,
     6484                                   (FT_UShort)( cur_touched + 1 ),
     6485                                   end_point,
     6486                                   cur_touched,
     6487                                   first_touched );
    63566488
    63576489          if ( first_touched > 0 )
    6358             Interp( first_point,
    6359                     first_touched - 1,
    6360                     cur_touched,
    6361                     first_touched,
    6362                     &V );
     6490            _iup_worker_interpolate( &V,
     6491                                     first_point,
     6492                                     first_touched - 1,
     6493                                     cur_touched,
     6494                                     first_touched );
    63636495        }
    63646496      }
     
    63826514    FT_Long    B;
    63836515
     6516
    63846517#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
    63856518    /* Delta hinting is covered by US Patent 5159668. */
    63866519    if ( CUR.face->unpatented_hinting )
    6387       {
    6388       FT_Long n = args[0] * 2;
     6520    {
     6521      FT_Long  n = args[0] * 2;
     6522
     6523
    63896524      if ( CUR.args < n )
    63906525      {
     
    65876722    /* Are we hinting for grayscale? */
    65886723    if ( ( args[0] & 32 ) != 0 && CUR.grayscale )
    6589       K |= (1 << 12);
     6724      K |= 1 << 12;
    65906725
    65916726    args[0] = K;
     
    76857820
    76867821
    7687 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     7822#endif /* TT_USE_BYTECODE_INTERPRETER */
    76887823
    76897824
  • trunk/poppler/freetype2/src/truetype/ttobjs.c

    r150 r165  
    3030#include "tterrors.h"
    3131
    32 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     32#ifdef TT_USE_BYTECODE_INTERPRETER
    3333#include "ttinterp.h"
    3434#endif
     
    5252
    5353
    54 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     54#ifdef TT_USE_BYTECODE_INTERPRETER
    5555
    5656  /*************************************************************************/
     
    8484      FT_FREE( zone->cur );
    8585      FT_FREE( zone->org );
     86      FT_FREE( zone->orus );
    8687
    8788      zone->max_points   = zone->n_points   = 0;
     
    127128    if ( FT_NEW_ARRAY( zone->org,      maxPoints   ) ||
    128129         FT_NEW_ARRAY( zone->cur,      maxPoints   ) ||
     130         FT_NEW_ARRAY( zone->orus,     maxPoints   ) ||
    129131         FT_NEW_ARRAY( zone->tags,     maxPoints   ) ||
    130132         FT_NEW_ARRAY( zone->contours, maxContours ) )
     
    140142    return error;
    141143  }
    142 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     144#endif /* TT_USE_BYTECODE_INTERPRETER */
    143145
    144146
     
    204206    }
    205207
    206 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     208#ifdef TT_USE_BYTECODE_INTERPRETER
    207209    face->root.face_flags |= FT_FACE_FLAG_HINTER;
    208210#endif
     
    245247    }
    246248
    247 #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
    248 
    249     /* Determine whether unpatented hinting is to be used for this face. */
    250     face->unpatented_hinting = FT_BOOL
    251        ( library->debug_hooks[ FT_DEBUG_HOOK_UNPATENTED_HINTING ] != NULL );
    252 
    253     {
    254       int  i;
    255 
     249#if defined( TT_CONFIG_OPTION_UNPATENTED_HINTING    ) && \
     250    !defined( TT_CONFIG_OPTION_BYTECODE_INTERPRETER )
     251
     252    {
     253      FT_Bool  unpatented_hinting;
     254      int      i;
     255
     256
     257      /* Determine whether unpatented hinting is to be used for this face. */
     258      unpatented_hinting = FT_BOOL
     259        ( library->debug_hooks[FT_DEBUG_HOOK_UNPATENTED_HINTING] != NULL );
    256260
    257261      for ( i = 0; i < num_params && !face->unpatented_hinting; i++ )
    258262        if ( params[i].tag == FT_PARAM_TAG_UNPATENTED_HINTING )
    259           face->unpatented_hinting = TRUE;
    260     }
    261 
    262 #endif /* TT_CONFIG_OPTION_UNPATENTED_HINTING */
     263          unpatented_hinting = TRUE;
     264
     265      /* Compare the face with a list of well-known `tricky' fonts. */
     266      /* This list shall be expanded as we find more of them.       */
     267      if ( !unpatented_hinting )
     268      {
     269        static const char* const  trick_names[] =
     270        {
     271          "DFKaiSho-SB",     /* dfkaisb.ttf */
     272          "DFKai-SB",        /* kaiu.ttf */
     273          "HuaTianSongTi?",  /* htst3.ttf */
     274          "MingLiU",         /* mingliu.ttf & mingliu.ttc */
     275          "PMingLiU",        /* mingliu.ttc */
     276          "MingLi43",        /* mingli.ttf */
     277          NULL
     278        };
     279        int  nn;
     280
     281
     282        /* Note that we only check the face name at the moment; it might */
     283        /* be worth to do more checks for a few special cases.           */
     284        for ( nn = 0; trick_names[nn] != NULL; nn++ )
     285        {
     286          if ( ttface->family_name                                    &&
     287               ft_strcmp( ttface->family_name, trick_names[nn] ) == 0 )
     288          {
     289            unpatented_hinting = 1;
     290            break;
     291          }
     292        }
     293      }
     294
     295      ttface->internal->ignore_unpatented_hinter = !unpatented_hinting;
     296    }
     297
     298#endif /* TT_CONFIG_OPTION_UNPATENTED_HINTING &&
     299          !TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
    263300
    264301    /* initialize standard glyph loading routines */
     
    330367  /*************************************************************************/
    331368
    332 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     369#ifdef TT_USE_BYTECODE_INTERPRETER
    333370
    334371  /*************************************************************************/
     
    480517  }
    481518
    482 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     519#endif /* TT_USE_BYTECODE_INTERPRETER */
    483520
    484521
     
    503540    FT_Error  error = TT_Err_Ok;
    504541
    505 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     542#ifdef TT_USE_BYTECODE_INTERPRETER
    506543
    507544    TT_Face    face   = (TT_Face)size->root.face;
     
    588625      tt_size_done( ttsize );
    589626
    590 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     627#endif /* TT_USE_BYTECODE_INTERPRETER */
    591628
    592629    size->ttmetrics.valid = FALSE;
     
    613650    TT_Size    size = (TT_Size)ttsize;
    614651
    615 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     652#ifdef TT_USE_BYTECODE_INTERPRETER
    616653
    617654    FT_Memory  memory = size->root.face->memory;
     
    727764
    728765
    729 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     766#ifdef TT_USE_BYTECODE_INTERPRETER
    730767
    731768    {
     
    756793    }
    757794
    758 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     795#endif /* TT_USE_BYTECODE_INTERPRETER */
    759796
    760797    if ( !error )
     
    783820  {
    784821
    785 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     822#ifdef TT_USE_BYTECODE_INTERPRETER
    786823
    787824    TT_Driver  driver = (TT_Driver)ttdriver;
     
    815852  tt_driver_done( FT_Module  ttdriver )     /* TT_Driver */
    816853  {
    817 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     854#ifdef TT_USE_BYTECODE_INTERPRETER
    818855    TT_Driver  driver = (TT_Driver)ttdriver;
    819856
  • trunk/poppler/freetype2/src/truetype/ttobjs.h

    r150 r165  
    110110
    111111
    112 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     112#ifdef TT_USE_BYTECODE_INTERPRETER
    113113
    114114  FT_LOCAL( void )
     
    121121                    TT_GlyphZone  zone );
    122122
    123 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     123#endif /* TT_USE_BYTECODE_INTERPRETER */
    124124
    125125
     
    325325    FT_ULong           strike_index;      /* 0xFFFFFFFF to indicate invalid */
    326326
    327 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     327#ifdef TT_USE_BYTECODE_INTERPRETER
    328328
    329329    FT_UInt            num_function_defs; /* number of function definitions */
     
    359359    TT_ExecContext     context;
    360360
    361 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     361#endif /* TT_USE_BYTECODE_INTERPRETER */
    362362
    363363  } TT_SizeRec;
     
    413413  tt_size_done( FT_Size  ttsize );          /* TT_Size */
    414414
    415 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     415#ifdef TT_USE_BYTECODE_INTERPRETER
    416416
    417417  FT_LOCAL( FT_Error )
     
    421421  tt_size_run_prep( TT_Size  size );
    422422
    423 #endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     423#endif /* TT_USE_BYTECODE_INTERPRETER */
    424424
    425425  FT_LOCAL( FT_Error )
  • trunk/poppler/freetype2/src/truetype/ttpload.c

    r150 r165  
    335335                    FT_Stream  stream )
    336336  {
    337 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     337#ifdef TT_USE_BYTECODE_INTERPRETER
    338338
    339339    FT_Error   error;
     
    384384    return error;
    385385
    386 #else /* !TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     386#else /* !TT_USE_BYTECODE_INTERPRETER */
    387387
    388388    FT_UNUSED( face   );
     
    416416                     FT_Stream  stream )
    417417  {
    418 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     418#ifdef TT_USE_BYTECODE_INTERPRETER
    419419
    420420    FT_Error  error;
     
    446446    return error;
    447447
    448 #else /* !TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     448#else /* !TT_USE_BYTECODE_INTERPRETER */
    449449
    450450    FT_UNUSED( face   );
     
    478478                     FT_Stream  stream )
    479479  {
    480 #ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
     480#ifdef TT_USE_BYTECODE_INTERPRETER
    481481
    482482    FT_Error  error;
     
    507507    return error;
    508508
    509 #else /* !TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
     509#else /* !TT_USE_BYTECODE_INTERPRETER */
    510510
    511511    FT_UNUSED( face   );
     
    563563    record_size = FT_NEXT_ULONG( p );
    564564
    565     if ( version != 0 || num_records > 255 || record_size > 0x40000 )
     565    /* The maximum number of bytes in an hdmx device record is the */
     566    /* maximum number of glyphs + 2; this is 0xFFFF + 2; this is   */
     567    /* the reason why `record_size' is a long (which we read as    */
     568    /* unsigned long for convenience).  In practice, two bytes     */
     569    /* sufficient to hold the size value.                          */
     570    /*                                                             */
     571    /* There are at least two fonts, HANNOM-A and HANNOM-B version */
     572    /* 2.0 (2005), which get this wrong: The upper two bytes of    */
     573    /* the size value are set to 0xFF instead of 0x00.  We catch   */
     574    /* and fix this.                                               */
     575
     576    if ( record_size >= 0xFFFF0000UL )
     577      record_size &= 0xFFFFU;
     578
     579    /* The limit for `num_records' is a heuristic value. */
     580
     581    if ( version != 0 || num_records > 255 || record_size > 0x10001L )
    566582    {
    567583      error = TT_Err_Invalid_File_Format;
     
    639655    FT_FRAME_EXIT();
    640656
     657    /* The maximum number of bytes in an hdmx device record is the */
     658    /* maximum number of glyphs + 2; this is 0xFFFF + 2; this is   */
     659    /* the reason why `record_size' is a long.  In practice, two   */
     660    /* bytes sufficient to hold the size value.                    */
     661    /*                                                             */
     662    /* There are at least two fonts, HANNOM-A and HANNOM-B version */
     663    /* 2.0 (2005), which get this wrong: The upper two bytes of    */
     664    /* the size value are set to 0xFF instead of 0x00.  We catch   */
     665    /* and fix this.                                               */
     666
     667    if ( (FT_ULong)record_size >= 0xFFFF0000UL )
     668      record_size = (FT_Long)( (FT_ULong)record_size & 0xFFFFU );
     669
    641670    if ( record_size < 0 || num_records < 0 )
    642671      return TT_Err_Invalid_File_Format;
     
    644673    /* Only recognize format 0 */
    645674    if ( hdmx->version != 0 )
    646       goto Exit;
     675      return TT_Err_Invalid_File_Format;
    647676
    648677    /* we can't use FT_QNEW_ARRAY here; otherwise tt_face_free_hdmx */
Note: See TracChangeset for help on using the changeset viewer.