daily pastebin goal
82%
SHARE
TWEET

root

a guest Jul 14th, 2010 403 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. From http://www.infinality.net/fedora/linux/13/SRPMS/freetype-subpixel-2.3.12-3.fc13.src.rpm
  2. and modified to patch freetype 2.4.0
  3. See http://www.infinality.net/blog/?p=67
  4. and http://forums.gentoo.org/viewtopic-p-6350322.html#6350322
  5.  
  6. Added:
  7. freetype-2.3.0-enable-spr.patch
  8. freetype-2.2.1-enable-valid.patch
  9. freetype-2.2.1-memcpy-fix.patch
  10. #define FT_CONFIG_OPTION_SYSTEM_ZLIB in include/freetype/config/ftoption.h
  11.  
  12.  
  13. diff -Naur freetype-2.4.0-orig//include/freetype/config/ftoption.h freetype-2.4.0/include/freetype/config/ftoption.h
  14. --- freetype-2.4.0-orig//include/freetype/config/ftoption.h     2010-07-05 11:38:55.000000000 +0700
  15. +++ freetype-2.4.0/include/freetype/config/ftoption.h   2010-07-14 17:46:36.000000000 +0700
  16. @@ -93,7 +93,7 @@
  17.    /* This is done to allow FreeType clients to run unmodified, forcing     */
  18.    /* them to display normal gray-level anti-aliased glyphs.                */
  19.    /*                                                                       */
  20. -/* #define FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
  21. +#define FT_CONFIG_OPTION_SUBPIXEL_RENDERING
  22.  
  23.  
  24.    /*************************************************************************/
  25. @@ -185,7 +185,7 @@
  26.    /*   Do not #undef this macro here since the build system might define   */
  27.    /*   it for certain configurations only.                                 */
  28.    /*                                                                       */
  29. -/* #define FT_CONFIG_OPTION_SYSTEM_ZLIB */
  30. +#define FT_CONFIG_OPTION_SYSTEM_ZLIB
  31.  
  32.  
  33.    /*************************************************************************/
  34. diff -Naur freetype-2.4.0-orig//include/freetype/freetype.h freetype-2.4.0/include/freetype/freetype.h
  35. --- freetype-2.4.0-orig//include/freetype/freetype.h    2010-07-13 02:27:14.000000000 +0700
  36. +++ freetype-2.4.0/include/freetype/freetype.h  2010-07-14 17:34:15.000000000 +0700
  37. @@ -2482,6 +2482,7 @@
  38.  #define FT_LOAD_MONOCHROME                   0x1000
  39.  #define FT_LOAD_LINEAR_DESIGN                0x2000
  40.  #define FT_LOAD_NO_AUTOHINT                  0x8000U
  41. +/*#define FT_LOAD_COMPATIBLE_WIDTHS            0x10000U*/
  42.  
  43.    /* */
  44.  
  45. diff -Naur freetype-2.4.0-orig//include/freetype/internal/ftobjs.h freetype-2.4.0/include/freetype/internal/ftobjs.h
  46. --- freetype-2.4.0-orig//include/freetype/internal/ftobjs.h     2009-07-03 20:28:24.000000000 +0700
  47. +++ freetype-2.4.0/include/freetype/internal/ftobjs.h   2010-07-14 17:34:15.000000000 +0700
  48. @@ -81,6 +81,13 @@
  49.  #define FT_PIX_ROUND( x )     FT_PIX_FLOOR( (x) + 32 )
  50.  #define FT_PIX_CEIL( x )      FT_PIX_FLOOR( (x) + 63 )
  51.  
  52. +#define FT_PIX_FLOOR_sph( x )     ( (x) & ~3 )
  53. +#define FT_PIX_ROUND_sph( x )     FT_PIX_FLOOR_sph( (x) + 2 )
  54. +#define FT_PIX_CEIL_sph( x )      FT_PIX_FLOOR_sph( (x) + 3 )
  55. +
  56. +#define FT_PIX_FLOOR_sphn( x, n )     ( (x) & ~(64 / n - 1) )
  57. +#define FT_PIX_ROUND_sphn( x, n )     FT_PIX_FLOOR_sph( (x) + 32 / n)
  58. +#define FT_PIX_CEIL_sphn( x, n )      FT_PIX_FLOOR_sph( (x) + 64 / n - 1)
  59.  
  60.    /*
  61.     *  Return the highest power of 2 that is <= value; this correspond to
  62. diff -Naur freetype-2.4.0-orig//modules.cfg freetype-2.4.0/modules.cfg
  63. --- freetype-2.4.0-orig//modules.cfg    2009-03-14 20:45:26.000000000 +0700
  64. +++ freetype-2.4.0/modules.cfg  2010-07-14 17:34:15.000000000 +0700
  65. @@ -110,7 +110,7 @@
  66.  AUX_MODULES += cache
  67.  
  68.  # TrueType GX/AAT table validation.  Needs ftgxval.c below.
  69. -# AUX_MODULES += gxvalid
  70. +AUX_MODULES += gxvalid
  71.  
  72.  # Support for streams compressed with gzip (files with suffix .gz).
  73.  #
  74. @@ -124,7 +124,7 @@
  75.  
  76.  # OpenType table validation.  Needs ftotval.c below.
  77.  #
  78. -# AUX_MODULES += otvalid
  79. +AUX_MODULES += otvalid
  80.  
  81.  # Auxiliary PostScript driver component to share common code.
  82.  #
  83. diff -Naur freetype-2.4.0-orig//src/psaux/psobjs.c freetype-2.4.0/src/psaux/psobjs.c
  84. --- freetype-2.4.0-orig//src/psaux/psobjs.c     2010-06-20 21:24:14.000000000 +0700
  85. +++ freetype-2.4.0/src/psaux/psobjs.c   2010-07-14 17:34:15.000000000 +0700
  86. @@ -183,6 +183,11 @@
  87.        return PSaux_Err_Invalid_Argument;
  88.      }
  89.  
  90. +    if ( length < 0 ) {
  91. +      FT_ERROR(( "ps_table_add: invalid length\n" ));
  92. +      return PSaux_Err_Invalid_Argument;
  93. +    }
  94. +
  95.      /* grow the base block if needed */
  96.      if ( table->cursor + length > table->capacity )
  97.      {
  98. diff -Naur freetype-2.4.0-orig//src/truetype/ttgload.c freetype-2.4.0/src/truetype/ttgload.c
  99. --- freetype-2.4.0-orig//src/truetype/ttgload.c 2010-06-29 15:27:12.000000000 +0700
  100. +++ freetype-2.4.0/src/truetype/ttgload.c       2010-07-14 17:34:15.000000000 +0700
  101. @@ -1659,7 +1659,6 @@
  102.      {
  103.        FT_Pos  advance = loader->linear;
  104.  
  105. -
  106.        /* the flag FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH was introduced to */
  107.        /* correctly support DynaLab fonts, which have an incorrect       */
  108.        /* `advance_Width_Max' field!  It is used, to my knowledge,       */
  109. @@ -1669,6 +1668,8 @@
  110.             ( loader->load_flags & FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ) == 0 )
  111.          advance = face->horizontal.advance_Width_Max;
  112.  
  113. +
  114. +
  115.        /* we need to return the advance in font units in linearHoriAdvance, */
  116.        /* it will be scaled later by the base layer.                        */
  117.        glyph->linearHoriAdvance = advance;
  118. @@ -1683,13 +1684,20 @@
  119.           IS_HINTED( loader->load_flags ) )
  120.      {
  121.        FT_Byte*  widthp;
  122. +      FT_Bool   subpixel;
  123. +      FT_Bool   compatible_widths;
  124. +
  125. +      subpixel =
  126. +        FT_BOOL( FT_LOAD_TARGET_MODE( loader->load_flags ) != FT_RENDER_MODE_MONO );
  127.  
  128. +      compatible_widths = FALSE;
  129. +        /*FT_BOOL( FT_LOAD_TARGET_MODE( loader->load_flags ) != FT_LOAD_COMPATIBLE_WIDTHS )*/
  130.  
  131.        widthp = tt_face_get_device_metrics( face,
  132.                                             size->root.metrics.x_ppem,
  133.                                             glyph_index );
  134.  
  135. -      if ( widthp )
  136. +      if ( (!subpixel && widthp) || compatible_widths )
  137.          glyph->metrics.horiAdvance = *widthp << 6;
  138.      }
  139.  
  140. @@ -1883,7 +1891,8 @@
  141.      {
  142.        TT_ExecContext  exec;
  143.        FT_Bool         grayscale;
  144. -
  145. +      FT_Bool         subpixel;
  146. +      FT_Bool         compatible_widths;
  147.  
  148.        if ( !size->cvt_ready )
  149.        {
  150. @@ -1901,10 +1910,31 @@
  151.        grayscale =
  152.          FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) != FT_RENDER_MODE_MONO );
  153.  
  154. +      subpixel =
  155. +        FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) != FT_RENDER_MODE_MONO );
  156. +
  157. +      compatible_widths = FALSE;
  158. +        /*FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) != FT_LOAD_COMPATIBLE_WIDTHS)*/;
  159. +
  160.        TT_Load_Context( exec, face, size );
  161.  
  162.        /* a change from mono to grayscale rendering (and vice versa) */
  163.        /* requires a re-execution of the CVT program                 */
  164. +      if ( compatible_widths != exec->compatible_widths )
  165. +      {
  166. +        FT_UInt  i;
  167. +
  168. +
  169. +        exec->compatible_widths = compatible_widths;
  170. +
  171. +        for ( i = 0; i < size->cvt_size; i++ )
  172. +          size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
  173. +        tt_size_run_prep( size );
  174. +      }
  175. +
  176. +
  177. +      /* a change from mono to grayscale rendering (and vice versa) */
  178. +      /* requires a re-execution of the CVT program                 */
  179.        if ( grayscale != exec->grayscale )
  180.        {
  181.          FT_UInt  i;
  182. @@ -1914,6 +1944,18 @@
  183.  
  184.          for ( i = 0; i < size->cvt_size; i++ )
  185.            size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
  186. +        tt_size_run_prep( size );
  187. +      }
  188. +
  189. +      if ( subpixel != exec->subpixel )
  190. +      {
  191. +        FT_UInt  i;
  192. +
  193. +
  194. +        exec->subpixel = subpixel;
  195. +
  196. +        for ( i = 0; i < size->cvt_size; i++ )
  197. +          size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale );
  198.          tt_size_run_prep( size );
  199.        }
  200.  
  201. diff -Naur freetype-2.4.0-orig//src/truetype/ttinterp.c freetype-2.4.0/src/truetype/ttinterp.c
  202. --- freetype-2.4.0-orig//src/truetype/ttinterp.c        2010-07-08 12:23:01.000000000 +0700
  203. +++ freetype-2.4.0/src/truetype/ttinterp.c      2010-07-14 17:34:15.000000000 +0700
  204. @@ -168,6 +168,9 @@
  205.  #define CUR_Func_round( d, c ) \
  206.            CUR.func_round( EXEC_ARG_ d, c )
  207.  
  208. +#define CUR_Func_round_sphn( d, c ) \
  209. +          CUR.func_round_sphn( EXEC_ARG_ d, c )
  210. +
  211.  #define CUR_Func_read_cvt( index ) \
  212.            CUR.func_read_cvt( EXEC_ARG_ index )
  213.  
  214. @@ -1836,7 +1839,7 @@
  215.  #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
  216.      FT_ASSERT( !CUR.face->unpatented_hinting );
  217.  #endif
  218. -
  219. +if (CUR.skip_x == 0){
  220.      v = CUR.GS.freeVector.x;
  221.  
  222.      if ( v != 0 )
  223. @@ -1847,7 +1850,8 @@
  224.  
  225.        zone->tags[point] |= FT_CURVE_TAG_TOUCH_X;
  226.      }
  227. -
  228. +}
  229. +if (CUR.skip_y == 0){
  230.      v = CUR.GS.freeVector.y;
  231.  
  232.      if ( v != 0 )
  233. @@ -1859,6 +1863,7 @@
  234.        zone->tags[point] |= FT_CURVE_TAG_TOUCH_Y;
  235.      }
  236.    }
  237. +  }
  238.  
  239.  
  240.    /*************************************************************************/
  241. @@ -1889,14 +1894,15 @@
  242.  #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
  243.      FT_ASSERT( !CUR.face->unpatented_hinting );
  244.  #endif
  245. -
  246. +if (CUR.skip_x == 0){
  247.      v = CUR.GS.freeVector.x;
  248.  
  249.      if ( v != 0 )
  250.        zone->org[point].x += TT_MULDIV( distance,
  251.                                         v * 0x10000L,
  252.                                         CUR.F_dot_P );
  253. -
  254. +}
  255. +if (CUR.skip_y==0){
  256.      v = CUR.GS.freeVector.y;
  257.  
  258.      if ( v != 0 )
  259. @@ -1904,7 +1910,7 @@
  260.                                         v * 0x10000L,
  261.                                         CUR.F_dot_P );
  262.    }
  263. -
  264. +  }
  265.  
  266.    /*************************************************************************/
  267.    /*                                                                       */
  268. @@ -1922,9 +1928,10 @@
  269.                            FT_F26Dot6    distance )
  270.    {
  271.      FT_UNUSED_EXEC;
  272. -
  273. +if (CUR.skip_x == 0){
  274.      zone->cur[point].x += distance;
  275.      zone->tags[point]  |= FT_CURVE_TAG_TOUCH_X;
  276. +}
  277.    }
  278.  
  279.  
  280. @@ -1934,11 +1941,11 @@
  281.                            FT_F26Dot6    distance )
  282.    {
  283.      FT_UNUSED_EXEC;
  284. -
  285. +if (CUR.skip_y ==0){
  286.      zone->cur[point].y += distance;
  287.      zone->tags[point]  |= FT_CURVE_TAG_TOUCH_Y;
  288.    }
  289. -
  290. +  }
  291.  
  292.    /*************************************************************************/
  293.    /*                                                                       */
  294. @@ -1956,8 +1963,9 @@
  295.                                 FT_F26Dot6    distance )
  296.    {
  297.      FT_UNUSED_EXEC;
  298. -
  299. +if (CUR.skip_x == 0){
  300.      zone->org[point].x += distance;
  301. +}
  302.    }
  303.  
  304.  
  305. @@ -1967,9 +1975,10 @@
  306.                                 FT_F26Dot6    distance )
  307.    {
  308.      FT_UNUSED_EXEC;
  309. -
  310. +if (CUR.skip_y == 0){
  311.      zone->org[point].y += distance;
  312.    }
  313. +  }
  314.  
  315.  
  316.    /*************************************************************************/
  317. @@ -2063,6 +2072,32 @@
  318.    }
  319.  
  320.  
  321. +    static FT_F26Dot6
  322. +  Round_To_Grid_sphn( EXEC_OP_ FT_F26Dot6  distance,
  323. +                          FT_F26Dot6  compensation )
  324. +  {
  325. +    FT_F26Dot6  val;
  326. +
  327. +    FT_UNUSED_EXEC;
  328. +
  329. +    if ( distance >= 0 )
  330. +    {
  331. +      val = distance + compensation + 32 / CUR.grid_factor;
  332. +      if ( distance && val > 0 )
  333. +        val &= ~(64 / CUR.grid_factor - 1);
  334. +      else
  335. +        val = 0;
  336. +    }
  337. +    else
  338. +    {
  339. +      val = -FT_PIX_ROUND_sphn( compensation - distance, CUR.grid_factor );
  340. +      if ( val > 0 )
  341. +        val = 0;
  342. +    }
  343. +    return  val;
  344. +  }
  345. +
  346. +
  347.    /*************************************************************************/
  348.    /*                                                                       */
  349.    /* <Function>                                                            */
  350. @@ -2105,6 +2140,32 @@
  351.    }
  352.  
  353.  
  354. +  static FT_F26Dot6
  355. +  Round_To_Half_Grid_sphn( EXEC_OP_ FT_F26Dot6  distance,
  356. +                               FT_F26Dot6  compensation )
  357. +  {
  358. +    FT_F26Dot6  val;
  359. +
  360. +    FT_UNUSED_EXEC;
  361. +
  362. +    if ( distance >= 0 )
  363. +    {
  364. +      val = FT_PIX_FLOOR_sphn( distance + compensation, CUR.grid_factor )
  365. +        + 32 / CUR.grid_factor;
  366. +      if ( distance && val < 0 )
  367. +        val = 0;
  368. +    }
  369. +    else
  370. +    {
  371. +      val = -( FT_PIX_FLOOR_sphn( compensation - distance, CUR.grid_factor )
  372. +        + 32 / CUR.grid_factor);
  373. +      if ( val > 0 )
  374. +        val = 0;
  375. +    }
  376. +
  377. +    return val;
  378. +  }
  379. +
  380.    /*************************************************************************/
  381.    /*                                                                       */
  382.    /* <Function>                                                            */
  383. @@ -2148,6 +2209,31 @@
  384.      return val;
  385.    }
  386.  
  387. +  static FT_F26Dot6
  388. +  Round_Down_To_Grid_sphn( EXEC_OP_ FT_F26Dot6  distance,
  389. +                               FT_F26Dot6  compensation )
  390. +  {
  391. +    FT_F26Dot6  val;
  392. +
  393. +    FT_UNUSED_EXEC;
  394. +
  395. +    if ( distance >= 0 )
  396. +    {
  397. +      val = distance + compensation;
  398. +      if ( distance && val > 0 )
  399. +        val &= ~(64 / CUR.grid_factor - 1);
  400. +      else
  401. +        val = 0;
  402. +    }
  403. +    else
  404. +    {
  405. +      val = -( ( compensation - distance ) & -(64 / CUR.grid_factor) );
  406. +      if ( val > 0 )
  407. +        val = 0;
  408. +    }
  409. +
  410. +    return val;
  411. +  }
  412.  
  413.    /*************************************************************************/
  414.    /*                                                                       */
  415. @@ -2193,6 +2279,33 @@
  416.    }
  417.  
  418.  
  419. +
  420. +  static FT_F26Dot6
  421. +  Round_Up_To_Grid_sphn( EXEC_OP_ FT_F26Dot6  distance,
  422. +                             FT_F26Dot6  compensation )
  423. +  {
  424. +    FT_F26Dot6  val;
  425. +
  426. +    FT_UNUSED_EXEC;
  427. +
  428. +    if ( distance >= 0 )
  429. +    {
  430. +      val = distance + compensation + (64 / CUR.grid_factor - 1);
  431. +      if ( distance && val > 0 )
  432. +        val &= ~(64 / CUR.grid_factor - 1);
  433. +      else
  434. +        val = 0;
  435. +    }
  436. +    else
  437. +    {
  438. +      val = - FT_PIX_CEIL_sphn( compensation - distance, CUR.grid_factor );
  439. +      if ( val > 0 )
  440. +        val = 0;
  441. +    }
  442. +
  443. +    return val;
  444. +  }
  445. +
  446.    /*************************************************************************/
  447.    /*                                                                       */
  448.    /* <Function>                                                            */
  449. @@ -2237,6 +2350,32 @@
  450.    }
  451.  
  452.  
  453. +
  454. +  static FT_F26Dot6
  455. +  Round_To_Double_Grid_sphn( EXEC_OP_ FT_F26Dot6  distance,
  456. +                                 FT_F26Dot6  compensation )
  457. +  {
  458. +    FT_F26Dot6 val;
  459. +
  460. +    FT_UNUSED_EXEC;
  461. +
  462. +    if ( distance >= 0 )
  463. +    {
  464. +      val = distance + compensation + 16 / CUR.grid_factor;
  465. +      if ( distance && val > 0 )
  466. +        val &= ~(32 / CUR.grid_factor - 1);
  467. +      else
  468. +        val = 0;
  469. +    }
  470. +    else
  471. +    {
  472. +      val = -FT_PAD_ROUND( compensation - distance, 32 / CUR.grid_factor );
  473. +      if ( val > 0 )
  474. +        val = 0;
  475. +    }
  476. +
  477. +    return val;
  478. +  }
  479.    /*************************************************************************/
  480.    /*                                                                       */
  481.    /* <Function>                                                            */
  482. @@ -2287,6 +2426,14 @@
  483.    }
  484.  
  485.  
  486. +
  487. +  static FT_F26Dot6
  488. +  Round_Super_sphn( EXEC_OP_ FT_F26Dot6  distance,
  489. +                        FT_F26Dot6  compensation  )
  490. +  {
  491. +    return distance;
  492. +  }
  493. +
  494.    /*************************************************************************/
  495.    /*                                                                       */
  496.    /* <Function>                                                            */
  497. @@ -2335,6 +2482,15 @@
  498.    }
  499.  
  500.  
  501. +
  502. +  static FT_F26Dot6
  503. +  Round_Super_45_sphn( EXEC_OP_ FT_F26Dot6  distance,
  504. +                        FT_F26Dot6  compensation  )
  505. +  {
  506. +
  507. +    return distance;
  508. +  }
  509. +
  510.    /*************************************************************************/
  511.    /*                                                                       */
  512.    /* <Function>                                                            */
  513. @@ -2357,30 +2513,37 @@
  514.  
  515.      case TT_Round_To_Grid:
  516.        CUR.func_round = (TT_Round_Func)Round_To_Grid;
  517. +      CUR.func_round_sphn = (TT_Round_Func)Round_To_Grid_sphn;
  518.        break;
  519.  
  520.      case TT_Round_Up_To_Grid:
  521.        CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
  522. +      CUR.func_round_sphn = (TT_Round_Func)Round_Up_To_Grid_sphn;
  523.        break;
  524.  
  525.      case TT_Round_Down_To_Grid:
  526.        CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
  527. +      CUR.func_round_sphn = (TT_Round_Func)Round_Down_To_Grid_sphn;
  528.        break;
  529.  
  530.      case TT_Round_To_Half_Grid:
  531.        CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
  532. +      CUR.func_round_sphn = (TT_Round_Func)Round_To_Half_Grid_sphn;
  533.        break;
  534.  
  535.      case TT_Round_To_Double_Grid:
  536.        CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
  537. +      CUR.func_round_sphn = (TT_Round_Func)Round_To_Double_Grid_sphn;
  538.        break;
  539.  
  540.      case TT_Round_Super:
  541.        CUR.func_round = (TT_Round_Func)Round_Super;
  542. +      CUR.func_round_sphn = (TT_Round_Func)Round_Super_sphn;
  543.        break;
  544.  
  545.      case TT_Round_Super_45:
  546.        CUR.func_round = (TT_Round_Func)Round_Super_45;
  547. +      CUR.func_round_sphn = (TT_Round_Func)Round_Super_45_sphn;
  548.        break;
  549.      }
  550.    }
  551. @@ -3031,44 +3194,52 @@
  552.  
  553.  #define DO_RTHG                                         \
  554.      CUR.GS.round_state = TT_Round_To_Half_Grid;         \
  555. -    CUR.func_round = (TT_Round_Func)Round_To_Half_Grid;
  556. +    CUR.func_round = (TT_Round_Func)Round_To_Half_Grid; \
  557. +    CUR.func_round_sphn = (TT_Round_Func)Round_To_Half_Grid_sphn;
  558.  
  559.  
  560.  #define DO_RTG                                     \
  561.      CUR.GS.round_state = TT_Round_To_Grid;         \
  562. -    CUR.func_round = (TT_Round_Func)Round_To_Grid;
  563. +    CUR.func_round = (TT_Round_Func)Round_To_Grid; \
  564. +    CUR.func_round_sphn = (TT_Round_Func)Round_To_Grid_sphn;
  565.  
  566.  
  567.  #define DO_RTDG                                           \
  568.      CUR.GS.round_state = TT_Round_To_Double_Grid;         \
  569. -    CUR.func_round = (TT_Round_Func)Round_To_Double_Grid;
  570. +    CUR.func_round = (TT_Round_Func)Round_To_Double_Grid; \
  571. +    CUR.func_round_sphn = (TT_Round_Func)Round_To_Double_Grid_sphn;
  572.  
  573.  
  574.  #define DO_RUTG                                       \
  575.      CUR.GS.round_state = TT_Round_Up_To_Grid;         \
  576. -    CUR.func_round = (TT_Round_Func)Round_Up_To_Grid;
  577. +    CUR.func_round = (TT_Round_Func)Round_Up_To_Grid; \
  578. +    CUR.func_round_sphn = (TT_Round_Func)Round_Up_To_Grid_sphn;
  579.  
  580.  
  581.  #define DO_RDTG                                         \
  582.      CUR.GS.round_state = TT_Round_Down_To_Grid;         \
  583. -    CUR.func_round = (TT_Round_Func)Round_Down_To_Grid;
  584. +    CUR.func_round = (TT_Round_Func)Round_Down_To_Grid; \
  585. +    CUR.func_round_sphn = (TT_Round_Func)Round_Down_To_Grid_sphn;
  586.  
  587.  
  588.  #define DO_ROFF                                 \
  589.      CUR.GS.round_state = TT_Round_Off;          \
  590. -    CUR.func_round = (TT_Round_Func)Round_None;
  591. +    CUR.func_round = (TT_Round_Func)Round_None; \
  592. +    CUR.func_round_sphn = (TT_Round_Func)Round_None;
  593.  
  594.  
  595.  #define DO_SROUND                                \
  596.      SET_SuperRound( 0x4000, args[0] );           \
  597.      CUR.GS.round_state = TT_Round_Super;         \
  598. -    CUR.func_round = (TT_Round_Func)Round_Super;
  599. +    CUR.func_round = (TT_Round_Func)Round_Super; \
  600. +    CUR.func_round_sphn = (TT_Round_Func)Round_Super_sphn;
  601.  
  602.  
  603.  #define DO_S45ROUND                                 \
  604.      SET_SuperRound( 0x2D41, args[0] );              \
  605.      CUR.GS.round_state = TT_Round_Super_45;         \
  606. -    CUR.func_round = (TT_Round_Func)Round_Super_45;
  607. +    CUR.func_round = (TT_Round_Func)Round_Super_45; \
  608. +    CUR.func_round_sphn = (TT_Round_Func)Round_Super_45_sphn;
  609.  
  610.  
  611.  #define DO_SLOOP                       \
  612. @@ -3296,7 +3467,9 @@
  613.           args[0] = 0;                  \
  614.       }                                 \
  615.       else                              \
  616. -       args[0] = CUR.storage[I];       \
  617. +        /* Subpixel Hinting- Typeman Dstroke and Istroke, Vacuform Rounds */ \
  618. +       if (CUR.subpixel && (I == 24 || I == 22 || I == 8)) args[0] = 0; \
  619. +       else args[0] = CUR.storage[I];  \
  620.     }
  621.  
  622.  
  623. @@ -5153,6 +5326,9 @@
  624.        }
  625.      }
  626.  
  627. +   /* Subpixel Hinting - Type 2 Vacuform Rounds - Arial Narrow */
  628. +   if (CUR.subpixel && FT_ABS(D) == 64) D += 1;
  629. +
  630.      args[0] = D;
  631.    }
  632.  
  633. @@ -5632,14 +5808,15 @@
  634.        return;
  635.      }
  636.  #endif
  637. -
  638. +if (CUR.skip_x == 0){
  639.      if ( CUR.GS.freeVector.x != 0 )
  640.      {
  641.        CUR.zp2.cur[point].x += dx;
  642.        if ( touch )
  643.          CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_X;
  644.      }
  645. -
  646. +}
  647. +if (CUR.skip_y == 0){
  648.      if ( CUR.GS.freeVector.y != 0 )
  649.      {
  650.        CUR.zp2.cur[point].y += dy;
  651. @@ -5647,7 +5824,7 @@
  652.          CUR.zp2.tags[point] |= FT_CURVE_TAG_TOUCH_Y;
  653.      }
  654.    }
  655. -
  656. +  }
  657.  
  658.    /*************************************************************************/
  659.    /*                                                                       */
  660. @@ -5862,7 +6039,18 @@
  661.          }
  662.        }
  663.        else
  664. -        MOVE_Zp2_Point( point, dx, dy, TRUE );
  665. +      {
  666. +        /* If freedom vector is Y, and point is touched, continue */
  667. +        if ( CUR.subpixel && CUR.GS.freeVector.y != 0 && CUR.iup_called == 0
  668. +          && ( ( CUR.pts.tags[point] & FT_CURVE_TAG_TOUCH_X ) != 0
  669. +            || ( CUR.pts.tags[point] & FT_CURVE_TAG_TOUCH_Y ) != 0 )
  670. +        ){
  671. +          MOVE_Zp2_Point( point, dx, dy, TRUE ); }
  672. +
  673. +        else if ( !CUR.subpixel || CUR.is_composite )
  674. +          MOVE_Zp2_Point( point, dx, dy, TRUE );
  675. +
  676. +      }
  677.  
  678.        CUR.GS.loop--;
  679.      }
  680. @@ -5907,6 +6095,15 @@
  681.      distance = CUR_Func_project( CUR.zp1.cur + point,
  682.                                   CUR.zp0.cur + CUR.GS.rp0 );
  683.  
  684. +    /* Subpixel Hinting - make MSIRP respect CVT cutin            */
  685. +    /* Fixes "k" issue with Arial                                 */
  686. +    /* Using 0 instead of CUR.GS.control_value_cutin/grid_factor  */
  687. +    /* fixes Helvetica Neue                                       */
  688. +    if (CUR.subpixel && CUR.GS.freeVector.x != 0
  689. +      && FT_ABS(distance - args[1]) >= 0 )
  690. +      distance = args[1];
  691. +
  692. +
  693.      CUR_Func_move( &CUR.zp1, point, args[1] - distance );
  694.  
  695.      CUR.GS.rp1 = CUR.GS.rp0;
  696. @@ -5945,7 +6142,10 @@
  697.      if ( ( CUR.opcode & 1 ) != 0 )
  698.      {
  699.        cur_dist = CUR_fast_project( &CUR.zp0.cur[point] );
  700. -      distance = CUR_Func_round( cur_dist,
  701. +      if (!CUR.subpixel || CUR.GS.freeVector.x == 0)
  702. +        distance = CUR_Func_round( cur_dist,
  703. +                                 CUR.tt_metrics.compensations[0] ) - cur_dist;
  704. +      else distance = CUR_Func_round_sphn( cur_dist,
  705.                                   CUR.tt_metrics.compensations[0] ) - cur_dist;
  706.      }
  707.      else
  708. @@ -6019,10 +6219,20 @@
  709.  
  710.      if ( ( CUR.opcode & 1 ) != 0 )   /* rounding and control cutin flag */
  711.      {
  712. -      if ( FT_ABS( distance - org_dist ) > CUR.GS.control_value_cutin )
  713. -        distance = org_dist;
  714.  
  715. -      distance = CUR_Func_round( distance, CUR.tt_metrics.compensations[0] );
  716. +      if ( !CUR.subpixel || CUR.GS.freeVector.x == 0 )
  717. +      {
  718. +        if ( FT_ABS( distance - org_dist ) > CUR.GS.control_value_cutin)
  719. +          distance = org_dist;
  720. +        distance = CUR_Func_round( distance, CUR.tt_metrics.compensations[0] );
  721. +      }
  722. +      else
  723. +      {
  724. +        if ( FT_ABS( distance - org_dist )
  725. +                > CUR.GS.control_value_cutin / CUR.grid_factor)
  726. +          distance = org_dist;
  727. +        distance = CUR_Func_round_sphn( distance, CUR.tt_metrics.compensations[0] );
  728. +      }
  729.      }
  730.  
  731.      CUR_Func_move( &CUR.zp0, point, distance - org_dist );
  732. @@ -6106,9 +6316,15 @@
  733.      /* round flag */
  734.  
  735.      if ( ( CUR.opcode & 4 ) != 0 )
  736. -      distance = CUR_Func_round(
  737. +    {
  738. +      if ( !CUR.subpixel || CUR.GS.freeVector.x == 0 )
  739. +        distance = CUR_Func_round(
  740. +                   org_dist,
  741. +                   CUR.tt_metrics.compensations[CUR.opcode & 3] );
  742. +      else distance = CUR_Func_round_sphn(
  743.                     org_dist,
  744.                     CUR.tt_metrics.compensations[CUR.opcode & 3] );
  745. +    }
  746.      else
  747.        distance = ROUND_None(
  748.                     org_dist,
  749. @@ -6116,17 +6332,36 @@
  750.  
  751.      /* minimum distance flag */
  752.  
  753. -    if ( ( CUR.opcode & 8 ) != 0 )
  754. -    {
  755. -      if ( org_dist >= 0 )
  756. +    /* Use 2/3 in x direction.  Better results than documented 1/2 */
  757. +    if (CUR.GS.freeVector.x != 0 && CUR.subpixel ){
  758. +      if ( ( CUR.opcode & 8 ) != 0 )
  759.        {
  760. -        if ( distance < CUR.GS.minimum_distance )
  761. -          distance = CUR.GS.minimum_distance;
  762. +        if ( org_dist >= 0 )
  763. +        {
  764. +          if ( distance < 2*CUR.GS.minimum_distance/3 )
  765. +            distance = 2*CUR.GS.minimum_distance/3;
  766. +        }
  767. +        else
  768. +        {
  769. +          if ( distance > -CUR.GS.minimum_distance/2 )
  770. +            distance = -CUR.GS.minimum_distance/2;
  771. +        }
  772.        }
  773. -      else
  774. +    }
  775. +    else
  776. +    {
  777. +      if ( ( CUR.opcode & 8 ) != 0 )
  778.        {
  779. -        if ( distance > -CUR.GS.minimum_distance )
  780. -          distance = -CUR.GS.minimum_distance;
  781. +        if ( org_dist >= 0 )
  782. +        {
  783. +          if ( distance < CUR.GS.minimum_distance )
  784. +            distance = CUR.GS.minimum_distance;
  785. +        }
  786. +        else
  787. +        {
  788. +          if ( distance > -CUR.GS.minimum_distance )
  789. +            distance = -CUR.GS.minimum_distance;
  790. +        }
  791.        }
  792.      }
  793.  
  794. @@ -6162,7 +6397,6 @@
  795.                  cur_dist,
  796.                  org_dist;
  797.  
  798. -
  799.      point    = (FT_UShort)args[0];
  800.      cvtEntry = (FT_ULong)( args[1] + 1 );
  801.  
  802. @@ -6223,41 +6457,84 @@
  803.  
  804.      /* control value cutin and round */
  805.  
  806. -    if ( ( CUR.opcode & 4 ) != 0 )
  807. +    if ( (!CUR.subpixel && ( CUR.opcode & 4 ) != 0) || CUR.subpixel )
  808.      {
  809.        /* XXX: UNDOCUMENTED!  Only perform cut-in test when both points */
  810.        /*      refer to the same zone.                                  */
  811.  
  812. -      if ( CUR.GS.gep0 == CUR.GS.gep1 )
  813. -        if ( FT_ABS( cvt_dist - org_dist ) >= CUR.GS.control_value_cutin )
  814. -          cvt_dist = org_dist;
  815. +      if ( (!CUR.subpixel && CUR.GS.gep0 == CUR.GS.gep1) || CUR.subpixel )
  816. +      {
  817. +        if ( (CUR.subpixel && CUR.GS.freeVector.x == 0) || !CUR.subpixel )
  818. +        {
  819. +          if ( FT_ABS(cvt_dist - org_dist)  >= CUR.GS.control_value_cutin  )
  820. +            cvt_dist = org_dist;
  821. +
  822. +          distance = CUR_Func_round(
  823. +            cvt_dist,
  824. +            CUR.tt_metrics.compensations[CUR.opcode & 3] );
  825. +        }
  826.  
  827. -      distance = CUR_Func_round(
  828. +        else if (CUR.subpixel)
  829. +        {
  830. +          if ( FT_ABS(cvt_dist - org_dist)
  831. +                >= CUR.GS.control_value_cutin / CUR.grid_factor )
  832. +                  cvt_dist = org_dist;
  833. +
  834. +          distance = CUR_Func_round_sphn(
  835.                     cvt_dist,
  836.                     CUR.tt_metrics.compensations[CUR.opcode & 3] );
  837. +        }
  838. +
  839. +      /* This fixes subpixel hinting italics (Verdana) but may be hacky */
  840. +        else
  841. +          distance = ROUND_None(
  842. +                   cvt_dist,
  843. +                   CUR.tt_metrics.compensations[CUR.opcode & 3] );
  844. +      }
  845.      }
  846. -    else
  847. +    else if (!CUR.subpixel){
  848.        distance = ROUND_None(
  849.                     cvt_dist,
  850.                     CUR.tt_metrics.compensations[CUR.opcode & 3] );
  851. +    }
  852.  
  853.      /* minimum distance test */
  854. -
  855. -    if ( ( CUR.opcode & 8 ) != 0 )
  856. +   if (CUR.GS.freeVector.x != 0 && CUR.subpixel)
  857.      {
  858. -      if ( org_dist >= 0 )
  859. +      if ( ( CUR.opcode & 8 ) != 0 )
  860.        {
  861. -        if ( distance < CUR.GS.minimum_distance )
  862. -          distance = CUR.GS.minimum_distance;
  863. +        if ( org_dist >= 0 )
  864. +        {
  865. +          if ( distance < 2 * CUR.GS.minimum_distance / 3 )
  866. +            distance = 2 * CUR.GS.minimum_distance / 3;
  867. +        }
  868. +        else
  869. +        {
  870. +          if ( distance > -2 * CUR.GS.minimum_distance / 3 )
  871. +            distance = -2 * CUR.GS.minimum_distance / 3;
  872. +        }
  873. +
  874.        }
  875. -      else
  876. +    }
  877. +    else
  878. +    {
  879. +      if ( ( CUR.opcode & 8 ) != 0 )
  880.        {
  881. -        if ( distance > -CUR.GS.minimum_distance )
  882. -          distance = -CUR.GS.minimum_distance;
  883. +        if ( org_dist >= 0 )
  884. +        {
  885. +          if ( distance < CUR.GS.minimum_distance )
  886. +            distance = CUR.GS.minimum_distance;
  887. +        }
  888. +        else
  889. +        {
  890. +          if ( distance > -CUR.GS.minimum_distance )
  891. +            distance = -CUR.GS.minimum_distance;
  892. +        }
  893.        }
  894. +
  895.      }
  896.  
  897. -    CUR_Func_move( &CUR.zp1, point, distance - cur_dist );
  898. +      CUR_Func_move( &CUR.zp1, point, distance - cur_dist );
  899.  
  900.      CUR.GS.rp1 = CUR.GS.rp0;
  901.  
  902. @@ -6726,6 +7003,7 @@
  903.  
  904.      FT_UNUSED_ARG;
  905.  
  906. +    CUR.iup_called = 1;
  907.  
  908.      /* ignore empty outlines */
  909.      if ( CUR.pts.n_contours == 0 )
  910. @@ -6820,7 +7098,7 @@
  911.      FT_UShort  A;
  912.      FT_ULong   C;
  913.      FT_Long    B;
  914. -
  915. +    FT_Byte    orig_round_state;
  916.  
  917.  #ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
  918.      /* Delta hinting is covered by US Patent 5159668. */
  919. @@ -6890,7 +7168,28 @@
  920.              B++;
  921.            B = B * 64 / ( 1L << CUR.GS.delta_shift );
  922.  
  923. -          CUR_Func_move( &CUR.zp0, A, B );
  924. +          /* This dirty hack fixes subpixel y-artifacts in trebuchet,  */
  925. +          /* verdana bold, ms sans serif, due to bi-level deltas in y  */
  926. +          /* direction, but breaks some glyphs (trebuchet e, times e,  */
  927. +          /* arial bold S.  Needs work.  */
  928. +
  929. +          if (0 && CUR.GS.freeVector.y != 0 && CUR.subpixel  )
  930. +          {
  931. +            orig_round_state= CUR.GS.round_state;
  932. +            COMPUTE_Round( TT_Round_Down_To_Grid );
  933. +            B = CUR_Func_round( B, CUR.tt_metrics.compensations[0] );
  934. +            COMPUTE_Round( orig_round_state );
  935. +          }
  936. +
  937. +          /* Only allow deltas under certain conditions */
  938. +          if ( CUR.subpixel && CUR.GS.freeVector.y != 0 && CUR.iup_called == 0
  939. +            &&  (( CUR.pts.tags[A] & FT_CURVE_TAG_TOUCH_X ) != 0
  940. +              || ( CUR.pts.tags[A] & FT_CURVE_TAG_TOUCH_Y ) != 0 )
  941. +             ){
  942. +            CUR_Func_move(&CUR.zp0, A, B); }
  943. +          else if ( !CUR.subpixel || CUR.is_composite )
  944. +            CUR_Func_move(&CUR.zp0, A, B);
  945. +
  946.          }
  947.        }
  948.        else
  949. @@ -7015,9 +7314,9 @@
  950.  
  951.      K = 0;
  952.  
  953. -    /* We return MS rasterizer version 1.7 for the font scaler. */
  954. +    /* We return MS rasterizer version 1.8 for the font scaler. */
  955.      if ( ( args[0] & 1 ) != 0 )
  956. -      K = 35;
  957. +      K = 37;
  958.  
  959.      /* Has the glyph been rotated? */
  960.      if ( ( args[0] & 2 ) != 0 && CUR.tt_metrics.rotated )
  961. @@ -7031,6 +7330,27 @@
  962.      if ( ( args[0] & 32 ) != 0 && CUR.grayscale )
  963.        K |= 1 << 12;
  964.  
  965. +    /* Are we hinting for subpixel? */
  966. +    if ( ( args[0] & 64 ) != 0 && CUR.subpixel )
  967. +      K |= 1 << 13;
  968. +
  969. +    /* Are we hinting for compatible_widths? */
  970. +    if ( ( args[0] & 128 ) != 0 && CUR.compatible_widths ){
  971. +      K |= 1 << 14;
  972. +      CUR.skip_x = 0;
  973. +    }
  974. +    else CUR.skip_x = 1;
  975. +    CUR.skip_y = 0;
  976. +
  977. +    /* Are we hinting for symmetrical_smoothing? */
  978. +    /*if ( ( args[0] & 256 ) != 0 && CUR.symmetrical_smoothing )*/
  979. +    /* Forcibly setting to 0 fixes PALATINO */
  980. +      K |= 0 << 15;
  981. +
  982. +    /* Are we hinting for bgr? */
  983. +    if ( ( args[0] & 512 ) != 0 && CUR.bgr )
  984. +      K |= 1 << 16;
  985. +
  986.      args[0] = K;
  987.    }
  988.  
  989. @@ -7404,6 +7724,13 @@
  990.  #ifdef TT_CONFIG_OPTION_STATIC_RASTER
  991.      cur = *exc;
  992.  #endif
  993. +    if (CUR.subpixel)
  994. +      /* 1/32 of a pixel in y direction */
  995. +      CUR.grid_factor = 32;
  996. +    else
  997. +      CUR.grid_factor = 1;
  998. +
  999. +    CUR.iup_called = 0;
  1000.  
  1001.      /* set CVT functions */
  1002.      CUR.tt_metrics.ratio = 0;
  1003. diff -Naur freetype-2.4.0-orig//src/truetype/ttinterp.h freetype-2.4.0/src/truetype/ttinterp.h
  1004. --- freetype-2.4.0-orig//src/truetype/ttinterp.h        2010-05-20 19:04:47.000000000 +0700
  1005. +++ freetype-2.4.0/src/truetype/ttinterp.h      2010-07-14 17:34:15.000000000 +0700
  1006. @@ -203,6 +203,7 @@
  1007.      FT_Long            F_dot_P;    /* dot product of freedom and projection */
  1008.                                     /* vectors                               */
  1009.      TT_Round_Func      func_round; /* current rounding function             */
  1010. +    TT_Round_Func      func_round_sphn; /* subpixel rounding fuction        */
  1011.  
  1012.      TT_Project_Func    func_project,   /* current projection function */
  1013.                         func_dualproj,  /* current dual proj. function */
  1014. @@ -215,7 +216,16 @@
  1015.      TT_Set_CVT_Func    func_write_cvt; /* write a cvt entry (in pixels) */
  1016.      TT_Set_CVT_Func    func_move_cvt;  /* incr a cvt entry (in pixels)  */
  1017.  
  1018. -    FT_Bool            grayscale;      /* are we hinting for grayscale? */
  1019. +    FT_Bool            grayscale;         /* are we hinting for grayscale?  */
  1020. +    FT_Bool            subpixel;          /* are we hinting for subpixel?   */
  1021. +    FT_Bool            compatible_widths; /* are we using compatible widths?*/
  1022. +    FT_Bool            symmetrical_smoothing; /* symmetrical_smoothing ?    */
  1023. +    FT_Bool            bgr;               /* are we using bgr, not rgb?     */
  1024. +
  1025. +    FT_Bool            grid_factor;    /* freedom vector resol (1 < 32) */
  1026. +    FT_Bool            iup_called;     /* IUP[] been called for this glyph? */
  1027. +    FT_Bool            skip_x;         /* Skip all x moves? */
  1028. +    FT_Bool            skip_y;         /* Skip all y moves? */
  1029.  
  1030.    } TT_ExecContextRec;
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top