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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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
Note: See TracChangeset for help on using the changeset viewer.