Subversion Repositories planix.SVN

/* Copyright (C) 2003 artofcode LLC.  All rights reserved.

  This software is provided AS-IS with no warranty, either express or

  implied.

  This software is distributed under license and may not be copied,

  modified or distributed except as expressly authorized under the terms

  of the license contained in the file LICENSE in this distribution.

  For more information about licensing, please refer to

  http://www.ghostscript.com/licensing/. For information on

  commercial licensing, go to http://www.artifex.com/licensing/ or

  contact Artifex Software, Inc., 101 Lucas Valley Road #110,

  San Rafael, CA  94903, U.S.A., +1(415)492-9861.

*/

/* $Id: gxhintn.c,v 1.61 2005/09/04 20:42:53 leonardo Exp $ */

/* Type 1 hinter, a new algorithm */

#include "memory_.h"

#include "math_.h"

#include "gx.h"

#include "gxfixed.h"

#include "gxarith.h"

#include "gstypes.h"

#include "gxmatrix.h"

#include "gxpath.h"

#include "gxfont.h"

#include "gxfont1.h"

#include "gxtype1.h"

#include "gxhintn.h"

#include "gzpath.h"

#include "gserrors.h"

#include "vdtrace.h"

/*  todo :

    - Diagonal stems are not hinted;

    - Some fonts have no StdHW, StdWW. Adobe appears to autohint them.

    - Measure Adobe's flattness parameter.

    - Test Adobe compatibility for rotated/skewed glyphs.

 */

/*  Stem processing basics :

    (See the glyph AE in Times-Roman by Adobe.)

    0. This supposes that glyph is transformed to device space

       with a random matrix.

       All outline poles and all hint commands are stored in arrays

       before staring the exact processing.

       HR pole is pole before which stem replacement happens.

    1. Stem hints may be primary ones (defined in the beginning of charstring),

       and secondary ones (defined at HR poles). Consider that

       secondary stem hints may be redundant (see AE in Times-Roman).

       Secondary stems are HIGHER priority than basic ones.

    2. The range of secondary stem command is from its HR pole to next HR pole.

       The range of primary stem command is entire glyph.

    3. The TT interpreter aligned stem3 with centering the middle stem.

    4. If a stem boundary corresponds to a pole aligned with an alignment zone,

       pass aligned coordinate to the stem command. 

       Use the stem boundary longitude middle point for alignment with

       skewed or rotated matrix. Use standard stem width for computing 

       opposite coordinates.

    5. If several stems have a same boundary coordinate,

       this boundary gets more priority when aligned.

    6. Considering each set of repeating stem commands as a stem complex, pass

       aligned coordinates to opposite boundaries of stem commands.

    7. Pass aligned boundary coordinate to poles within stem command range.

       Note that this will pass aligned coordinates back to poles,

       from which stem alignment was taken.

    8. Interpolate unaligned poles.

    9. After the alignment is done, it is desirable to check for 

       anomalous negative contours and fix them, but we have no

       good algorithm for this. The rasterizer must be tolerant

       to such contours (which may have self-crosses, self-contacts,

       or may change to opposite direction).

*/

/*  Dotsection processing basics :

    If stem replacement occures, dotsection to be ignored.

    To check this properly, we test whether extremal poles of contour 

    were actually aligned with stem hints.

    If a contour was aligned with stem hints by both X and Y,

    no special processing required.

    Otherwise if dotsection center falls near vstem axis,

    we align it by X with the axis. Otherwise we align

    it by X to half-pixel. Then we align the center by Y to

    half-pixel, and shift entire contour to satisfy 

    the alignment of the center.

*/

/*  vstem3/hstem3 processing basics :

    They are handled by the type 1,2 interpreters (gstype1.c, gstype2.c).

 */

/*  flex processing basics :

    With type 1 it is handled with t1_hinter__flex_* functions.

    With type 2 it is handled by gstype2.c .

 */

#define VD_DRAW_IMPORT 0 /* CAUTION: with 1 can't close DC on import error */

#define VD_SCALE  (4.0 / 4096.0)

#define VD_SHIFT_X 50

#define VD_SHIFT_Y 100

#define VD_PAINT_POLE_IDS 1

#define VD_IMPORT_COLOR RGB(255, 0, 0)

#define ADOBE_OVERSHOOT_COMPATIBILIY 0

#define ADOBE_SHIFT_CHARPATH 0

/*  The CONTRAST_STEMS option aligns one of two stem boundaries 

    to integral pixel boundary when AlignToPixels = 0.

    It gives more contrast stems, because a bigger part

    of boldness is concentrated in smaller number of pixels.

*/

#define CONTRAST_STEMS 1

static const char *s_pole_array = "t1_hinter pole array";

static const char *s_zone_array = "t1_hinter zone array";

static const char *s_hint_array = "t1_hinter hint array";

static const char *s_contour_array = "t1_hinter contour array";

static const char *s_hint_range_array = "t1_hinter hint_range array";

static const char *s_stem_snap_array = "t1_hinter stem_snap array";

#define member_prt(type, ptr, offset) (type *)((char *)(ptr) + (offset))

typedef int32_t int24;

#define HAVE_INT64_T

private const unsigned int split_bits = 12;

private const unsigned int max_coord_bits = 24; /* = split_bits * 2 */

private const unsigned int matrix_bits = 19; /* <= sizeof(int) * 8 - 1 - split_bits */

private const unsigned int g2o_bitshift = 12; /* <= matrix_bits + max_coord_bits - (sizeof(int) * 8 + 1) */

private const int32_t FFFFF000 = ~(int32_t)0xFFF; /* = ~(((int32_t)1 << split_bits) - 1) */

/* Constants above must satisfy expressions given in comments. */

/* Computes (a*b)>>s, s <= 12 */

private inline int32_t mul_shift(int24 a, int19 b, unsigned int s) 

{   

#ifdef HAVE_INT64_T

    return ( (int64_t)a * (int64_t)b ) >> s; /* unrounded result */

#else

    { /* 32 bit fallback */

        int32_t aa = a & FFFFF000, a0 = a - aa, a1 = aa >> s;

        return ((a0 * b) >> s) + a1 * b; /* unrounded result */

    }

#endif

}

/* Computes (a*b)>>s, s <= 12, with rounding */

private inline int32_t mul_shift_round(int24 a, int19 b, unsigned int s) 

{

#ifdef HAVE_INT64_T

    return (( ( (int64_t)a * (int64_t)b ) >> (s - 1)) + 1) >> 1;

#else

    { /* 32 bit version */

        int32_t aa = a & FFFFF000, a0 = a - aa, a1 = aa >> s;

        return ((((a0 * b) >> (s - 1)) + 1) >> 1) + a1 * b; /* rounded result */

    }

#endif

}

private inline int32_t shift_rounded(int32_t v, unsigned int s)

{   return ((v >> (s - 1)) + 1) >> 1;

}

private inline int32_t Max(int32_t a, int32_t b)

{   return a > b ? a : b;

}

private inline int32_t Min(int32_t a, int32_t b)

{   return a < b ? a : b;

}

private inline long rshift(long a, int b)

{   return b > 0 ? a << b : a >> -b;

}

private inline ulong urshift(ulong a, int b)

{   return b > 0 ? a << b : a >> -b;

}

/*---------------------- members of matrix classes -------------------------*/

private inline void double_matrix__set(double_matrix * this, const gs_matrix_fixed * m)

{   this->xx = m->xx;

    this->xy = m->xy;

    this->yx = m->yx;

    this->yy = m->yy;

}

private inline int double_matrix__invert_to(const double_matrix * this, double_matrix * m)

{   double det = this->xx * this->yy - this->xy * this->yx;

    if (fabs(det) * 1000000 < fabs(this->xx) + fabs(this->xy) + fabs(this->yx) + fabs(this->yy))

	return_error(gs_error_rangecheck);

    m->xx =  this->yy / det;

    m->xy = -this->xy / det;

    m->yx = -this->yx / det;

    m->yy =  this->xx / det;

    return 0;

}

private void fraction_matrix__drop_bits(fraction_matrix * this, unsigned int bits)

{   this->xx = shift_rounded(this->xx, bits);

    this->xy = shift_rounded(this->xy, bits);

    this->yx = shift_rounded(this->yx, bits);

    this->yy = shift_rounded(this->yy, bits);       

    this->denominator >>= bits;

    this->bitshift -= bits;

}

private void fraction_matrix__set(fraction_matrix * this, const double_matrix * pmat)

{   double axx = fabs(pmat->xx), axy = fabs(pmat->xy);

    double ayx = fabs(pmat->xx), ayy = fabs(pmat->xy);

    double scale = max(axx + axy, ayx + ayy);

    int matrix_exp, m;

    double unused = frexp(scale, &matrix_exp);

    this->bitshift = matrix_bits - matrix_exp;

    this->denominator = 1 << this->bitshift;

    /* Round towards zero for a better view of mirrored characters : */

    this->xx = (int32_t)(pmat->xx * this->denominator + 0.5);

    this->xy = (int32_t)(pmat->xy * this->denominator + 0.5);

    this->yx = (int32_t)(pmat->yx * this->denominator + 0.5);

    this->yy = (int32_t)(pmat->yy * this->denominator + 0.5);

    m = Max(Max(any_abs(this->xx), any_abs(this->xy)), Max(any_abs(this->yx), any_abs(this->yy)));

    unused = frexp(m, &matrix_exp);

    if (matrix_exp > matrix_bits)

        fraction_matrix__drop_bits(this, matrix_exp - matrix_bits);

}

private inline int fraction_matrix__to_double(const fraction_matrix * this, double_matrix * pmat)

{   

    if (this->denominator == 0)

	return_error(gs_error_rangecheck);

    pmat->xx = (double)this->xx / this->denominator;

    pmat->xy = (double)this->xy / this->denominator;

    pmat->yx = (double)this->yx / this->denominator;

    pmat->yy = (double)this->yy / this->denominator;

    return 0;

}

private int fraction_matrix__invert_to(const fraction_matrix * this, fraction_matrix * pmat)

{   double_matrix m, M;

    int code;

    code = fraction_matrix__to_double(this, &M);

    if (code < 0)

	return code;

    code = double_matrix__invert_to(&M, &m);

    if (code < 0)

	return code;

    fraction_matrix__set(pmat, &m);

    return 0;

}

private inline int32_t fraction_matrix__transform_x(fraction_matrix *this, int24 x, int24 y, unsigned int s)

{   return mul_shift_round(x, this->xx, s) + mul_shift_round(y, this->yx, s);

}

private inline int32_t fraction_matrix__transform_y(fraction_matrix *this, int24 x, int24 y, unsigned int s)

{   return mul_shift_round(x, this->xy, s) + mul_shift_round(y, this->yy, s);

}

/*--------------------------- friends ------------------------------*/

private inline int ranger_step_f(int i, int beg, int end)

{   return (i == end ? beg : i + 1);

}

private inline int ranger_step_b(int i, int beg, int end)

{   return (i == beg ? end : i - 1);

}

private inline fixed o2d(const t1_hinter *h, t1_hinter_space_coord v)

{   

    int s = h->g2o_fraction_bits - _fixed_shift;

    if (s >= 1)

	return ((v >> (h->g2o_fraction_bits - _fixed_shift - 1)) + 1) >> 1;

    else if (s == 0)

	return v;

    else

	return v << -s;

}

private inline fixed d2o(const t1_hinter *h, t1_hinter_space_coord v)

{   int s = h->g2o_fraction_bits - _fixed_shift;

    if (s >= 0)

	return v << s;

    else

	return v >> -s;

}

private inline void g2o(t1_hinter * h, t1_glyph_space_coord gx, t1_glyph_space_coord gy, t1_hinter_space_coord *ox, t1_hinter_space_coord *oy)

{   *ox = fraction_matrix__transform_x(&h->ctmf, gx, gy, g2o_bitshift);

    *oy = fraction_matrix__transform_y(&h->ctmf, gx, gy, g2o_bitshift);

}

private inline t1_hinter_space_coord g2o_dist(t1_glyph_space_coord gd, int19 coef)

{   return mul_shift(gd, coef, g2o_bitshift);

}

private inline void g2d(t1_hinter * h, t1_glyph_space_coord gx, t1_glyph_space_coord gy, fixed *dx, fixed *dy)

{   *dx = fraction_matrix__transform_x(&h->ctmf, gx, gy, g2o_bitshift);

    *dy = fraction_matrix__transform_y(&h->ctmf, gx, gy, g2o_bitshift);

    *dx = o2d(h, *dx);

    *dy = o2d(h, *dy);

    *dx += h->orig_dx;

    *dy += h->orig_dy;

}

private inline void o2g(t1_hinter * h, t1_hinter_space_coord ox, t1_hinter_space_coord oy, t1_glyph_space_coord *gx, t1_glyph_space_coord *gy)

{   *gx = fraction_matrix__transform_x(&h->ctmi, ox, oy, split_bits);

    *gy = fraction_matrix__transform_y(&h->ctmi, ox, oy, split_bits);

    *gx = shift_rounded(*gx, h->g2o_fraction_bits + h->ctmi.bitshift - _fixed_shift - split_bits);

    *gy = shift_rounded(*gy, h->g2o_fraction_bits + h->ctmi.bitshift - _fixed_shift - split_bits);

}

private inline t1_glyph_space_coord o2g_dist(t1_hinter * h, t1_hinter_space_coord od, int19 coef)

{   return shift_rounded(mul_shift(od, coef, split_bits), h->g2o_fraction_bits + h->ctmi.bitshift - _fixed_shift - split_bits);

}

private inline void o2g_float(t1_hinter * h, t1_hinter_space_coord ox, t1_hinter_space_coord oy, t1_glyph_space_coord *gx, t1_glyph_space_coord *gy)

{   *gx = (long)(((double)ox * h->ctmi.xx + (double)oy * h->ctmi.yx) * fixed_scale / h->g2o_fraction / h->ctmi.denominator);

    *gy = (long)(((double)ox * h->ctmi.xy + (double)oy * h->ctmi.yy) * fixed_scale / h->g2o_fraction / h->ctmi.denominator);

}

/* --------------------- t1_hint class members ---------------------*/

private void t1_hint__set_aligned_coord(t1_hint * this, t1_glyph_space_coord gc, t1_pole * pole, enum t1_align_type align, int quality)

{   t1_glyph_space_coord g = (this->type == hstem ? pole->gy : pole->gx); 

#if FINE_STEM_COMPLEXES

    if (any_abs(this->g0 - g) < any_abs(this->g1 - g)) {

        if (this->aligned0 <= align && this->q0 > quality)

            this->ag0 = gc, this->aligned0 = align, this->q0 = quality;

    } else {

        if (this->aligned1 <= align && this->q1 > quality)

            this->ag1 = gc, this->aligned1 = align, this->q1 = quality;

    }

#else

    if (any_abs(this->g0 - g) < any_abs(this->g1 - g)) {

        if (this->aligned0 < align && this->q0 > quality)

            this->ag0 = gc, this->aligned0 = align, this->q0 = quality;

    } else {

        if (this->aligned1 < align && this->q1 > quality)

            this->ag1 = gc, this->aligned1 = align, this->q1 = quality;

    }

#endif

}

/* --------------------- t1_hinter class members - debug graphics --------------------*/

private void t1_hinter__paint_glyph(t1_hinter * this, bool aligned)

{

#ifdef VD_TRACE

#define X(j) *member_prt(t1_glyph_space_coord, &this->pole[j], offset_x)

#define Y(j) *member_prt(t1_glyph_space_coord, &this->pole[j], offset_y)

    t1_glyph_space_coord *p_x = (aligned ? &this->pole[0].ax : &this->pole[0].gx);

    t1_glyph_space_coord *p_y = (aligned ? &this->pole[0].ay : &this->pole[0].gy);

    int offset_x = (char *)p_x - (char *)&this->pole[0];

    int offset_y = (char *)p_y - (char *)&this->pole[0];

    int i, j;

    char buf[15];

    if (!vd_enabled)

	return;

#   if VD_PAINT_POLE_IDS

    for(i = 0; i < this->contour_count; i++) {

        int beg_pole = this->contour[i];

        int end_pole = this->contour[i + 1] - 2;

        for(j = beg_pole; j <= end_pole; j++) {

            vd_circle(X(j), Y(j), 3, RGB(0,0,255));

            sprintf(buf, "%d", j);

            vd_text(this->pole[j].gx, this->pole[j].gy, buf, RGB(0,0,0));

            if (this->pole[j + 1].type == offcurve)

                j+=2;

        }

    }

#   endif

    vd_setcolor(aligned ? RGB(0,255,0) : RGB(0,0,255));

    for(i = 0; i < this->contour_count; i++) {

        int beg_pole = this->contour[i];

        int end_pole = this->contour[i + 1] - 2;

        vd_moveto(X(beg_pole), Y(beg_pole));

        for(j = beg_pole + 1; j <= end_pole; j++) {

            if (this->pole[j].type == oncurve) {

                vd_lineto(X(j), Y(j));

            } else {

                int jj = (j + 2 > end_pole ? beg_pole : j + 2);

                vd_curveto(X(j), Y(j), X(j + 1), Y(j + 1), X(jj), Y(jj));

                j+=2;

            }

        }

        vd_lineto(X(beg_pole), Y(beg_pole));

    }

#undef X

#undef Y

#endif

}

private void  t1_hinter__paint_raster_grid(t1_hinter * this)

{

#ifdef VD_TRACE

    int i;

    double j; /* 'long' can overflow */

    unsigned long c0 = RGB(192, 192, 192), c1 = RGB(64, 64, 64);

    t1_hinter_space_coord min_ox, max_ox, min_oy, max_oy;

    long div_x = this->g2o_fraction, div_xx = div_x << this->log2_pixels_x; 

    long div_y = this->g2o_fraction, div_yy = div_y << this->log2_pixels_y; 

    long ext_x = div_x * 5;

    long ext_y = div_y * 5;

    long sx = this->orig_ox % div_xx;

    long sy = this->orig_oy % div_yy;

    if (!vd_enabled)

	return;

    g2o(this, this->pole[0].gx, this->pole[0].gy, &min_ox, &min_oy);

    max_ox = min_ox, max_oy = min_oy;

    /* Compute BBox in outliner's space : */

    for (i = 1; i < this->pole_count - 1; i++) {

        t1_hinter_space_coord ox, oy;

        g2o(this, this->pole[i].gx, this->pole[i].gy, &ox, &oy);

        min_ox = min(min_ox, ox);

        min_oy = min(min_oy, oy);

        max_ox = max(max_ox, ox);

        max_oy = max(max_oy, oy);

    }

    min_ox -= ext_x;

    min_oy -= ext_y;

    max_ox += ext_x;

    max_oy += ext_y;

    /* Paint columns : */

    for (j = min_ox / div_x * div_x; j < (double)max_ox + div_x; j += div_x) {

        t1_glyph_space_coord gx0, gy0, gx1, gy1;

	bool pix = ((int)j / div_xx * div_xx == (int)j);

        o2g_float(this, (int)j - sx, min_oy - sy, &gx0, &gy0); /* o2g may overflow here due to ext. */

        o2g_float(this, (int)j - sx, max_oy - sy, &gx1, &gy1);

        vd_bar(gx0, gy0, gx1, gy1, 1, (!j ? 0 : pix ? c1 : c0));

    }

    /* Paint rows : */

    for (j = min_oy / div_y * div_y; j < max_oy + div_y; j += div_y) {

        t1_glyph_space_coord gx0, gy0, gx1, gy1;

	bool pix = ((int)j / div_yy * div_yy == (int)j);

        o2g_float(this, min_ox - sx, (int)j - sy, &gx0, &gy0);

        o2g_float(this, max_ox - sx, (int)j - sy, &gx1, &gy1);

        vd_bar(gx0, gy0, gx1, gy1, 1, (!j ? 0 : pix ? c1 : c0));

    }

#endif

}

/* --------------------- t1_hinter class members - import --------------------*/

void t1_hinter__init(t1_hinter * this, gx_path *output_path)

{   this->max_import_coord = (1 << max_coord_bits);

    this->stem_snap_count[0] = this->stem_snap_count[1] = 0;

    this->zone_count = 0;

    this->pole_count = 0;

    this->hint_count = 0;

    this->contour_count = 0;

    this->hint_range_count = 0;

    this->flex_count = 0;

    this->max_contour_count = count_of(this->contour0);

    this->max_zone_count = count_of(this->zone0);

    this->max_pole_count = count_of(this->pole0);

    this->max_hint_count = count_of(this->hint0);

    this->max_hint_range_count = count_of(this->hint_range0);

    this->max_stem_snap_count[0] = count_of(this->stem_snap[0]);

    this->max_stem_snap_count[1] = count_of(this->stem_snap[1]);

    this->pole = this->pole0;

    this->hint = this->hint0;

    this->zone = this->zone0;

    this->contour = this->contour0;

    this->hint_range = this->hint_range0;

    this->stem_snap[0] = this->stem_snap0[0];

    this->stem_snap[1] = this->stem_snap0[1];

    this->FontType = 1;

    this->ForceBold = false;

    this->base_font_scale = 0;

    this->resolution = 0;

    this->heigt_transform_coef = this->width_transform_coef = 0;

    this->heigt_transform_coef_rat = this->width_transform_coef_rat = 0;

    this->heigt_transform_coef_inv = this->width_transform_coef_inv = 0;

    this->cx = this->cy = 0;

    this->contour[0] = 0;

    this->seac_flag = 0;

    this->keep_stem_width = false;

    this->charpath_flag = false;

    this->grid_fit_x = this->grid_fit_y = true;

    this->output_path = output_path;

    this->memory = (output_path == 0 ? 0 : output_path->memory);

    this->disable_hinting = (this->memory == NULL);

    this->autohinting = false;

    this->stem_snap[0][0] = this->stem_snap[1][0] = 100; /* default */

}

private inline void t1_hinter__free_arrays(t1_hinter * this)

{   if (this->pole != this->pole0)

	gs_free_object(this->memory, this->pole, s_pole_array);

    if (this->hint != this->hint0)

	gs_free_object(this->memory, this->hint, s_hint_array);

    if (this->zone != this->zone0)

	gs_free_object(this->memory, this->zone, s_zone_array);

    if (this->contour != this->contour0)

	gs_free_object(this->memory, this->contour, s_contour_array);

    if (this->hint_range != this->hint_range0)

	gs_free_object(this->memory, this->hint_range, s_hint_range_array);

    if (this->stem_snap[0] != this->stem_snap0[0])

	gs_free_object(this->memory, this->stem_snap[0], s_stem_snap_array);

    if (this->stem_snap[1] != this->stem_snap0[1])

	gs_free_object(this->memory, this->stem_snap[1], s_stem_snap_array);

    this->pole = 0;

    this->hint = 0;

    this->zone = 0;

    this->contour = 0;

    this->hint_range = 0;

    this->stem_snap[0] = this->stem_snap[1] = 0;

}

private inline void t1_hinter__init_outline(t1_hinter * this)

{   this->contour_count = 0;

    this->pole_count = 0;

    this->contour[0] = 0;

    this->seac_flag = 0;

    this->hint_count = 0;

    this->primary_hint_count = -1;

    this->suppress_overshoots = false;

    this->path_opened = false;

}

private void t1_hinter__compute_rat_transform_coef(t1_hinter * this)

{

    /* Round towards zero for a better view of mirrored characters : */

    this->heigt_transform_coef_rat = (int19)(this->heigt_transform_coef * this->ctmf.denominator + 0.5);

    this->width_transform_coef_rat = (int19)(this->width_transform_coef * this->ctmf.denominator + 0.5);

    this->heigt_transform_coef_inv = (int19)(this->ctmi.denominator / this->heigt_transform_coef + 0.5);

    this->width_transform_coef_inv = (int19)(this->ctmi.denominator / this->width_transform_coef + 0.5);

}

private inline void t1_hinter__adjust_matrix_precision(t1_hinter * this, fixed xx, fixed yy)

{   fixed x = any_abs(xx), y = any_abs(yy);

    fixed c = (x > y ? x : y);

    while (c >= this->max_import_coord) {

	/* Reduce the precision of ctmf to allow products to fit into 32 bits : */

	this->max_import_coord <<= 1;

	fraction_matrix__drop_bits(&this->ctmf, 1);

	fraction_matrix__drop_bits(&this->ctmi, 1);

	this->g2o_fraction_bits -= 1;

	this->g2o_fraction >>= 1;

	t1_hinter__compute_rat_transform_coef(this);

    }

    if (this->ctmf.denominator == 0) {

	/* ctmf should be degenerate. */

	this->ctmf.denominator = 1;

    }

}

private inline void t1_hinter__set_origin(t1_hinter * this, fixed dx, fixed dy)

{   

    fixed align_x = rshift(fixed_1, (this->align_to_pixels ? (int)this->log2_pixels_x : this->log2_subpixels_x));

    fixed align_y = rshift(fixed_1, (this->align_to_pixels ? (int)this->log2_pixels_y : this->log2_subpixels_y));

    this->orig_dx = (dx + align_x / 2) & ~(align_x - 1);

    this->orig_dy = (dy + align_y / 2) & ~(align_y - 1);

    t1_hinter__adjust_matrix_precision(this, this->orig_dx, this->orig_dy);

    this->orig_ox = d2o(this, this->orig_dx);

    this->orig_oy = d2o(this, this->orig_dy);

#   if ADOBE_SHIFT_CHARPATH

        /*  Adobe CPSI rounds coordinates for 'charpath' :

            X to trunc(x+0.5)

            Y to trunc(y)+0.5

        */

        if (this->charpath_flag) {

            this->orig_dx += fixed_half;

            this->orig_dx &= ~(fixed_1 - 1);

            this->orig_dy &= ~(fixed_1 - 1);

            this->orig_dy += fixed_half;

        } else {

            this->orig_dy += fixed_1;

	    /* Adobe CPSI does this, not sure why. */

            /* fixme : check bbox of cached bitmap. */

        }

#   endif

}

int t1_hinter__set_mapping(t1_hinter * this, gs_matrix_fixed * ctm,

		    gs_matrix * FontMatrix, gs_matrix * baseFontMatrix,

		    int log2_pixels_x, int log2_pixels_y,

		    int log2_subpixels_x, int log2_subpixels_y,

		    fixed origin_x, fixed origin_y, bool align_to_pixels)

{   float axx = fabs(ctm->xx), axy = fabs(ctm->xy);

    float ayx = fabs(ctm->xx), ayy = fabs(ctm->xy);

    float scale = max(axx + axy, ayx + ayy);

    double_matrix CTM;

    int code;

    this->disable_hinting |= (scale < 1/1024. || scale > 4);

    this->log2_pixels_x = log2_pixels_x;

    this->log2_pixels_y = log2_pixels_y;

    this->log2_subpixels_x = log2_subpixels_x;

    this->log2_subpixels_y = log2_subpixels_y;

    double_matrix__set(&CTM, ctm);

    fraction_matrix__set(&this->ctmf, &CTM);

    this->g2o_fraction_bits = this->ctmf.bitshift - g2o_bitshift + _fixed_shift;

    if (this->g2o_fraction_bits > max_coord_bits) {

        fraction_matrix__drop_bits(&this->ctmf, this->g2o_fraction_bits - max_coord_bits);

        this->g2o_fraction_bits = max_coord_bits;

    }

    if (this->ctmf.denominator != 0) {

	code = fraction_matrix__invert_to(&this->ctmf, &this->ctmi); /* Note: ctmi is inversion of ctmf, not ctm. */

	if (code < 0)

	    return code;

	this->g2o_fraction = 1 << this->g2o_fraction_bits;

	/* Note : possibly we'll adjust the matrix precision dynamically 

	   with adjust_matrix_precision while importing the glyph. */

	if (this->g2o_fraction == 0)

    	    return_error(gs_error_limitcheck);

    }

    if (this->ctmf.denominator == 0 || this->ctmi.denominator == 0) {

	/* ctmf should be degenerate. */

    	this->disable_hinting = true;

	this->ctmf.denominator = 1;

    }

    {   /* height_transform_coef is scaling factor for the

           distance between horizontal lines while transformation.

           width_transform_coef defines similarly.

        */

        double_matrix m;

        double vp, sp, div_x, div_y;

        code = fraction_matrix__to_double(&this->ctmf, &m);

	if (code < 0)

	    return code;

        vp = any_abs(m.xx * m.yy - m.yx * m.yx); 

        sp = any_abs(m.xx * m.yx + m.xy * m.yy);

        div_x = hypot(m.xx, m.xy);

        div_y = hypot(m.yx, m.yy);

        if (vp != 0 && div_x != 0 && div_y != 0) {

            this->heigt_transform_coef = vp / div_x;

            this->width_transform_coef = vp / div_y;

	    t1_hinter__compute_rat_transform_coef(this);

            this->keep_stem_width = (sp <= vp / 3); /* small skew */

        }

    }

    {   /* Compute font size and resolution : */

        gs_point p0, p1, p2;

        double d0, d1, d2;

        gs_distance_transform(0, 1, baseFontMatrix, &p0);

        gs_distance_transform(0, 1, FontMatrix, &p1);

        gs_distance_transform(0, 1, (gs_matrix *)ctm, &p2);

        d0 = hypot(p0.x, p0.y);

        d1 = hypot(p1.x, p1.y);

        d2 = hypot(p2.x, p2.y);

        this->base_font_scale = d0;

        this->font_size =  floor(d1 / d0 * 10000 + 0.5) / 10000;

        this->resolution = floor(d2 / d1 * 10000000 + 0.5) / 10000000;

	/*

	 * fixme: base_font_scale, font_size and resolution are computed wrongly 

	 * for any of the following cases :

	 *

	 * 1. CIDFontType0C with FontMatrix=[0.001 0 0 0.001 0 0] gives 1/1000 size.

	 * A known example : CIDembedded.pdf . We could obtain the Type 9 FontMatrix 

	 * in type1_exec_init from penum->fstack.

	 *

	 * 2. See comment in pdf_font_orig_matrix.

	 *

	 * Currently we don't use these values with a regular build. 

	 * The ADOBE_OVERSHOOT_COMPATIBILIY build needs to fix them.

	 */

    }

    if (1 || /* Doesn't work - see comment above. Using this->disable_hinting instead. */

	    this->resolution * this->font_size >= 2) {	

	/* Enable the grid fitting separately for axes : */

	this->grid_fit_y = (any_abs(this->ctmf.xy) * 10 < any_abs(this->ctmf.xx) ||

			    any_abs(this->ctmf.xx) * 10 < any_abs(this->ctmf.xy)); 

	this->grid_fit_x = (any_abs(this->ctmf.yx) * 10 < any_abs(this->ctmf.yy) ||

			    any_abs(this->ctmf.yy) * 10 < any_abs(this->ctmf.yx));

    } else {

	/* Disable the grid fitting for very small fonts. */

	this->grid_fit_x = this->grid_fit_y = false;

    }

    this->transposed = (any_abs(this->ctmf.xy) * 10 > any_abs(this->ctmf.xx));

    this->align_to_pixels = align_to_pixels;

    t1_hinter__set_origin(this, origin_x, origin_y);

    return 0;

}

private void t1_hinter__make_zone(t1_hinter * this, t1_zone *zone, float * blues, enum t1_zone_type type, t1_glyph_space_coord blue_fuzz)

{   t1_glyph_space_coord d = 0;

    zone->type = type;

    zone->y           = float2fixed(blues[0] + d);

    zone->overshoot_y = float2fixed(blues[1] + d);

    zone->y_min = min(zone->y, zone->overshoot_y) - blue_fuzz;

    zone->y_max = max(zone->y, zone->overshoot_y) + blue_fuzz;

    if (type == botzone ? zone->overshoot_y > zone->y : zone->overshoot_y < zone->y) {

        int v = zone->overshoot_y; zone->overshoot_y = zone->y; zone->y = v;

    }

    t1_hinter__adjust_matrix_precision(this, zone->y_min, zone->y_max);

}

private bool t1_hinter__realloc_array(gs_memory_t *mem, void **a, void *a0, int *max_count, int elem_size, int enhancement, const char *cname)

{

    void *aa = gs_alloc_bytes(mem, (*max_count + enhancement * 2) * elem_size, cname);

    if (aa == NULL)

	return true;

    memcpy(aa, *a, *max_count * elem_size);

    if (*a != a0)

	gs_free_object(mem, *a, cname);

    *a = aa;

    *max_count += enhancement * 2;

    return false;

}

private int t1_hinter__set_alignment_zones(t1_hinter * this, float * blues, int count, enum t1_zone_type type, bool family)

{   int count2 = count / 2, i, j;

    if (!family) {

        /* Store zones : */

        if (count2 + this->zone_count >= this->max_zone_count)

	    if(t1_hinter__realloc_array(this->memory, (void **)&this->zone, this->zone0, &this->max_zone_count, 

	                                sizeof(this->zone0) / count_of(this->zone0), 

					max(T1_MAX_ALIGNMENT_ZONES, count), s_zone_array))

    		return_error(gs_error_VMerror);

        for (i = 0; i < count2; i++)

            t1_hinter__make_zone(this, &this->zone[this->zone_count + i], blues + i + i, type, this->blue_fuzz);

        this->zone_count += count2;

    } else {

        /* Replace with family zones if allowed : */

        t1_zone zone;

        for (i = 0; i < count2; i++) {

            t1_hinter__make_zone(this, &zone, blues + i, type, this->blue_fuzz);

            for (j = 0; j<this->zone_count; j++) {

                t1_zone *zone1 = &this->zone[j];

                if (any_abs(zone.y -           zone1->y          ) * this->heigt_transform_coef <= 1 &&

                    any_abs(zone.overshoot_y - zone1->overshoot_y) * this->heigt_transform_coef <= 1)

                    *zone1 = zone;

            }

        }    

    }

    return 0;

}

private int t1_hinter__set_stem_snap(t1_hinter * this, float * value, int count, unsigned short hv)

{   int count0 = this->stem_snap_count[hv], i;

    if (count + count0 >= this->max_stem_snap_count[hv])

	if(t1_hinter__realloc_array(this->memory, (void **)&this->stem_snap[hv], this->stem_snap0[hv], &this->max_stem_snap_count[hv], 

	                                sizeof(this->stem_snap0[0]) / count_of(this->stem_snap0[0]), 

					max(T1_MAX_STEM_SNAPS, count), s_stem_snap_array))

    	    return_error(gs_error_VMerror);

    for (i = 0; i < count; i++)

        this->stem_snap[hv][count0 + i] = float2fixed(value[i]);

    this->stem_snap_count[hv] += count;

    return 0;

}

private void enable_draw_import(void)

{   /* CAUTION: can't close DC on import error */

    vd_get_dc('h');

    vd_set_shift(VD_SHIFT_X, VD_SHIFT_Y);

    vd_set_scale(VD_SCALE);

    vd_set_origin(0,0);

    vd_erase(RGB(255, 255, 255));

    vd_setcolor(VD_IMPORT_COLOR);

    vd_setlinewidth(0);

}

int t1_hinter__set_font_data(t1_hinter * this, int FontType, gs_type1_data *pdata, bool no_grid_fitting)

{   int code;

    t1_hinter__init_outline(this);

    this->FontType = FontType;

    this->BlueScale = pdata->BlueScale;

    this->blue_shift = float2fixed(pdata->BlueShift);

    this->blue_fuzz  = float2fixed(pdata->BlueFuzz);

    this->suppress_overshoots = (this->BlueScale > this->heigt_transform_coef / (1 << this->log2_pixels_y) - 0.00020417);

    this->overshoot_threshold = (this->heigt_transform_coef != 0 ? (t1_glyph_space_coord)(fixed_half * (1 << this->log2_pixels_y) / this->heigt_transform_coef) : 0);

    this->ForceBold = pdata->ForceBold;

    this->disable_hinting |= no_grid_fitting;

    this->charpath_flag = no_grid_fitting;

    if (vd_enabled && (VD_DRAW_IMPORT || this->disable_hinting))

	enable_draw_import();

    if (this->disable_hinting)

	return 0;

    code = t1_hinter__set_alignment_zones(this, pdata->OtherBlues.values, pdata->OtherBlues.count, botzone, false);

    if (code >= 0)

	code = t1_hinter__set_alignment_zones(this, pdata->BlueValues.values, min(2, pdata->BlueValues.count), botzone, false);

    if (code >= 0)

	code = t1_hinter__set_alignment_zones(this, pdata->BlueValues.values + 2, pdata->BlueValues.count - 2, topzone, false);

    if (code >= 0)

	code = t1_hinter__set_alignment_zones(this, pdata->FamilyOtherBlues.values, pdata->FamilyOtherBlues.count, botzone, true);

    if (code >= 0)

	code = t1_hinter__set_alignment_zones(this, pdata->FamilyBlues.values, min(2, pdata->FamilyBlues.count), botzone, true);

    if (code >= 0)

	code = t1_hinter__set_alignment_zones(this, pdata->FamilyBlues.values + 2, pdata->FamilyBlues.count - 2, topzone, true);

    if (code >= 0)

	code = t1_hinter__set_stem_snap(this, pdata->StdHW.values, pdata->StdHW.count, 0);

    if (code >= 0)

	code = t1_hinter__set_stem_snap(this, pdata->StdVW.values, pdata->StdVW.count, 1);

    if (code >= 0)

	code = t1_hinter__set_stem_snap(this, pdata->StemSnapH.values, pdata->StemSnapH.count, 0);

    if (code >= 0)

	code = t1_hinter__set_stem_snap(this, pdata->StemSnapV.values, pdata->StemSnapV.count, 1);

    return code;

}

int t1_hinter__set_font42_data(t1_hinter * this, int FontType, gs_type42_data *pdata, bool no_grid_fitting)

{   

    t1_hinter__init_outline(this);

    this->FontType = FontType;

    this->BlueScale = 0.039625;	/* A Type 1 spec default. */

    this->blue_shift = 7;	/* A Type 1 spec default. */

    this->blue_fuzz  = 1;	/* A Type 1 spec default. */

    this->suppress_overshoots = (this->BlueScale > this->heigt_transform_coef / (1 << this->log2_pixels_y) - 0.00020417);

    this->overshoot_threshold = (this->heigt_transform_coef != 0 ? (t1_glyph_space_coord)(fixed_half * (1 << this->log2_pixels_y) / this->heigt_transform_coef) : 0);

    this->ForceBold = false;

    this->disable_hinting |= no_grid_fitting;

    this->charpath_flag = no_grid_fitting;

    this->autohinting = true;

    if (vd_enabled && (VD_DRAW_IMPORT || this->disable_hinting))

	enable_draw_import();

    if (this->disable_hinting)

	return 0;

    /* Currently we don't provice alignments zones or stem snap. */

    return 0;

}

private inline int t1_hinter__can_add_pole(t1_hinter * this, t1_pole **pole)

{   if (this->pole_count >= this->max_pole_count)