/* Copyright (C) 2001-2021 Artifex Software, Inc.

   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 that

   license.  Refer to licensing information at http://www.artifex.com/

   or contact Artifex Software, Inc.,  1305 Grant Avenue - Suite 200,

   Novato, CA 94945, U.S.A., +1(415)492-9861, for further information.

*/

#include "memory_.h"

#include "gsmemory.h"

#include "gserrors.h"

#include "gxdevice.h"

#include "gxfont.h"

#include "gxfont1.h"

#include "gxpath.h"

#include "gxfcache.h"

#include "gxchrout.h"

#include "gximask.h"

#include "gscoord.h"

#include "gspaint.h"

#include "gspath.h"

#include "gzstate.h"

#include "gxfcid.h"

#include "gxchar.h"             /* for st_gs_show_enum and MAX_CCACHE_TEMP_BITMAP_BITS */

#include "gdebug.h"

#include "gsimage.h"

#include "gsbittab.h"

#include "gzpath.h"

#include "gxdevsop.h"

#include "gxfapi.h"

extern_gs_get_fapi_server_inits();

/* FIXME */

static int

gs_fapi_renderer_retcode(gs_memory_t *mem, gs_fapi_server *I,

                         gs_fapi_retcode rc)

{

    if (rc == 0)

        return 0;

    if (gs_debug_c('1')) {

        emprintf2(mem,

                  "Error: Font Renderer Plugin ( %s ) return code = %d\n",

                  I->ig.d->subtype, rc);

    }

    return rc < 0 ? rc : gs_error_invalidfont;

}

typedef struct gs_fapi_outline_handler_s

{

    gs_fapi_server *fserver;

    struct gx_path_s *path;

    fixed x0;

    fixed y0;

    bool close_path;

    bool need_close;            /* This stuff fixes unclosed paths being rendered with UFST */

} gs_fapi_outline_handler;

static inline int64_t

import_shift(int64_t x, int64_t n)

{

    return (n > 0 ? (x << n) : (x >> -n));

}

static inline int

export_shift(int x, int n)

{

    return (n > 0 ? (x >> n) : (x << -n));

}

static inline int

fapi_round(double x)

{

    return (int)(x + 0.5);

}

static int

add_closepath(gs_fapi_path *I)

{

    gs_fapi_outline_handler *olh = (gs_fapi_outline_handler *) I->olh;

    if (olh->need_close == true) {

        olh->need_close = false;

        I->gs_error = gx_path_close_subpath_notes(olh->path, 0);

    }

    return (I->gs_error);

}

static int

add_move(gs_fapi_path *I, int64_t x, int64_t y)

{

    gs_fapi_outline_handler *olh = (gs_fapi_outline_handler *) I->olh;

    x = import_shift(x, I->shift);

    y = -import_shift(y, I->shift);

    if (olh->fserver->transform_outline) {

        gs_point pt;

        I->gs_error = gs_distance_transform((double)fixed2float((float)x), (double)fixed2float((float)y), &olh->fserver->outline_mat, &pt);

        if (I->gs_error < 0)

            return I->gs_error;

        x = float2fixed(pt.x);

        y = float2fixed(pt.y);

    }

    x += olh->x0;

    y += olh->y0;

    if (x > (int64_t) max_coord_fixed || x < (int64_t) min_coord_fixed

     || y > (int64_t) max_coord_fixed || y < (int64_t) min_coord_fixed) {

         I->gs_error = gs_error_undefinedresult;

    }

    else {

        if (olh->need_close && olh->close_path)

            if ((I->gs_error = add_closepath(I)) < 0)

                return (I->gs_error);

        olh->need_close = false;

/*        dprintf2("%f %f moveto\n", fixed2float(x), fixed2float(y)); */

        I->gs_error = gx_path_add_point(olh->path, (fixed) x, (fixed) y);

    }

    return (I->gs_error);

}

static int

add_line(gs_fapi_path *I, int64_t x, int64_t y)

{

    gs_fapi_outline_handler *olh = (gs_fapi_outline_handler *) I->olh;

    x = import_shift(x, I->shift);

    y = -import_shift(y, I->shift);

    if (olh->fserver->transform_outline) {

        gs_point pt;

        I->gs_error = gs_distance_transform((double)fixed2float((float)x), (double)fixed2float((float)y), &olh->fserver->outline_mat, &pt);

        if (I->gs_error < 0)

            return I->gs_error;

        x = float2fixed(pt.x);

        y = float2fixed(pt.y);

    }

    x += olh->x0;

    y += olh->y0;

    if (x > (int64_t) max_coord_fixed || x < (int64_t) min_coord_fixed

     || y > (int64_t) max_coord_fixed || y < (int64_t) min_coord_fixed) {

         I->gs_error = gs_error_undefinedresult;

    }

    else {

        olh->need_close = true;

/*        dprintf2("%f %f lineto\n", fixed2float(x), fixed2float(y)); */

        I->gs_error = gx_path_add_line_notes(olh->path, (fixed) x, (fixed) y, 0);

    }

    return (I->gs_error);

}

static int

add_curve(gs_fapi_path *I, int64_t x0, int64_t y0, int64_t x1, int64_t y1,

          int64_t x2, int64_t y2)

{

    gs_fapi_outline_handler *olh = (gs_fapi_outline_handler *) I->olh;

    x0 = import_shift(x0, I->shift);

    y0 = -import_shift(y0, I->shift);

    x1 = import_shift(x1, I->shift);

    y1 = -import_shift(y1, I->shift);

    x2 = import_shift(x2, I->shift);

    y2 = -import_shift(y2, I->shift);

    if (olh->fserver->transform_outline) {

        gs_point pt;

        I->gs_error = gs_distance_transform((double)fixed2float((float)x0), (double)fixed2float((float)y0), &olh->fserver->outline_mat, &pt);

        if (I->gs_error < 0)

            return I->gs_error;

        x0 = float2fixed(pt.x);

        y0 = float2fixed(pt.y);

        I->gs_error = gs_distance_transform((double)fixed2float((float)x1), (double)fixed2float((float)y1), &olh->fserver->outline_mat, &pt);

        if (I->gs_error < 0)

            return I->gs_error;

        x1 = float2fixed(pt.x);

        y1 = float2fixed(pt.y);

        I->gs_error = gs_distance_transform((double)fixed2float((float)x2), (double)fixed2float((float)y2), &olh->fserver->outline_mat, &pt);

        if (I->gs_error < 0)

            return I->gs_error;

        x2 = float2fixed(pt.x);

        y2 = float2fixed(pt.y);

    }

    x0 += olh->x0;

    y0 += olh->y0;

    x1 += olh->x0;

    y1 += olh->y0;

    x2 += olh->x0;

    y2 += olh->y0;

    if (x0 > (int64_t) max_coord_fixed || x0 < (int64_t) min_coord_fixed

     || y0 > (int64_t) max_coord_fixed || y0 < (int64_t) min_coord_fixed

     || x1 > (int64_t) max_coord_fixed || x1 < (int64_t) min_coord_fixed

     || y1 > (int64_t) max_coord_fixed || y1 < (int64_t) min_coord_fixed

     || x2 > (int64_t) max_coord_fixed || x2 < (int64_t) min_coord_fixed

     || y2 > (int64_t) max_coord_fixed || y2 < (int64_t) min_coord_fixed)

    {

        I->gs_error = gs_error_undefinedresult;

    }

    else {

        olh->need_close = true;

/*        dprintf6("%f %f %f %f %f %f curveto\n", fixed2float(x0), fixed2float(y0), fixed2float(x1), fixed2float(y1), fixed2float(x2), fixed2float(y2));*/

        I->gs_error = gx_path_add_curve_notes(olh->path, (fixed) x0, (fixed) y0, (fixed) x1, (fixed) y1, (fixed) x2, (fixed) y2, 0);

    }

    return (I->gs_error);

}

static gs_fapi_path path_interface_stub =

    { NULL, 0, 0, add_move, add_line, add_curve, add_closepath };

int

gs_fapi_get_metrics_count(gs_fapi_font *ff)

{

    if (!ff->is_type1 && ff->is_cid) {

        gs_font_cid2 *pfcid = (gs_font_cid2 *) ff->client_font_data;

        return (pfcid->cidata.MetricsCount);

    }

    return 0;

}

/*

 * Lifted from psi/zchar.c

 * Return true if we only need the width from the rasterizer

 * and can short-circuit the full rendering of the character,

 * false if we need the actual character bits.  This is only safe if

 * we know the character is well-behaved, i.e., is not defined by an

 * arbitrary PostScript procedure.

 */

static inline bool

fapi_gs_char_show_width_only(const gs_text_enum_t *penum)

{

    if (!gs_text_is_width_only(penum))

        return false;

    switch (penum->orig_font->FontType) {

        case ft_encrypted:

        case ft_encrypted2:

        case ft_CID_encrypted:

        case ft_CID_TrueType:

        case ft_CID_bitmap:

        case ft_TrueType:

            return true;

        default:

            return false;

    }

}

/* If we're rendering an uncached glyph, we need to know

 * whether we're filling it with a pattern, and whether

 * transparency is involved - if so, we have to produce

 * a path outline, and not a bitmap.

 */

static inline bool

using_transparency_pattern(gs_gstate *pgs)

{

    gx_device *dev = gs_currentdevice_inline(pgs);

    return ((!gs_color_writes_pure(pgs)) && dev_proc(dev, dev_spec_op)(dev, gxdso_supports_pattern_transparency, NULL, 0));

}

static inline bool

recreate_multiple_master(gs_font_base *pbfont)

{

    bool r = false;

    gs_fapi_server *I = pbfont->FAPI;

    bool changed = false;

    if (I && I->face.font_id != gs_no_id &&

        (pbfont->FontType == ft_encrypted

        || pbfont->FontType == ft_encrypted2)) {

        gs_font_type1 *pfont1 = (gs_font_type1 *) pbfont;

        if (pfont1->data.WeightVector.count != 0

            && I->face.WeightVector.count != pfont1->data.WeightVector.count) {

            changed = true;

        }

        else if (pfont1->data.WeightVector.count != 0) {

            changed = (memcmp(I->face.WeightVector.values, pfont1->data.WeightVector.values,

                             pfont1->data.WeightVector.count * sizeof(pfont1->data.WeightVector.values[0])) != 0);

        }

        if (changed) {

            r = (I->set_mm_weight_vector(I, &I->ff, pfont1->data.WeightVector.values, pfont1->data.WeightVector.count) == gs_error_invalidaccess);

            I->face.WeightVector.count = pfont1->data.WeightVector.count;

            memcpy(I->face.WeightVector.values, pfont1->data.WeightVector.values,

                   pfont1->data.WeightVector.count * sizeof(pfont1->data.WeightVector.values[0]));

        }

    }

    return r;

}

static bool

produce_outline_char(gs_show_enum *penum_s,

                     gs_font_base *pbfont, int abits,

                     gs_log2_scale_point *log2_scale)

{

    gs_gstate *pgs = (gs_gstate *) penum_s->pgs;

    log2_scale->x = 0;

    log2_scale->y = 0;

    /* Checking both gx_compute_text_oversampling() result, and abits (below) may seem redundant,

     * and hopefully it will be soon, but for now, gx_compute_text_oversampling() could opt to

     * "oversample" sufficiently small glyphs (fwiw, I don't think gx_compute_text_oversampling is

     * working as intended in that respect), regardless of the device's anti-alias setting.

     * This was an old, partial solution for dropouts in small glyphs.

     */

    gx_compute_text_oversampling(penum_s, (gs_font *) pbfont, abits,

                                 log2_scale);

    return (pgs->in_charpath || pbfont->PaintType != 0 ||

            (pgs->in_cachedevice != CACHE_DEVICE_CACHING

             && using_transparency_pattern((gs_gstate *) penum_s->pgs))

            || (pgs->in_cachedevice != CACHE_DEVICE_CACHING

                && (log2_scale->x > 0 || log2_scale->y > 0))

            || (pgs->in_cachedevice != CACHE_DEVICE_CACHING && abits > 1));

}

static inline void

gs_fapi_release_typeface(gs_fapi_server *I, void **server_font_data)

{

    I->release_typeface(I, *server_font_data);

    I->face.font_id = gs_no_id;

    if (I->ff.server_font_data == *server_font_data)

        I->ff.server_font_data = 0;

    *server_font_data = 0;

}

static int

notify_remove_font(void *proc_data, void *event_data)

{                               /* gs_font_finalize passes event_data == NULL, so check it here. */

    if (event_data == NULL) {

        gs_font_base *pbfont = proc_data;

        gs_fapi_server *I = pbfont->FAPI;

        if (pbfont->FAPI_font_data != 0) {

            gs_fapi_release_typeface(I, &pbfont->FAPI_font_data);

        }

    }

    return 0;

}

int

gs_fapi_prepare_font(gs_font *pfont, gs_fapi_server *I, int subfont, const char *font_file_path,

                     gs_string *full_font_buf, const char *xlatmap, const char **decodingID)

{                               /* Returns 1 iff BBox is set. */

    /* Cleans up server's font data if failed. */

    /* A renderer may need to access the top level font's data of

     * a CIDFontType 0 (FontType 9) font while preparing its subfonts,

     * and/or perform a completion action with the top level font after

     * its descendants are prepared. Therefore with such fonts

     * we first call get_scaled_font(..., FAPI_TOPLEVEL_BEGIN), then

     * get_scaled_font(..., i) with eash descendant font index i,

     * and then get_scaled_font(..., FAPI_TOPLEVEL_COMPLETE).

     * For other fonts we don't call with 'i'.

     *

     * Actually server's data for top level CIDFontTYpe 0 non-disk fonts should not be important,

     * because with non-disk fonts FAPI_do_char never deals with the top-level font,

     * but does with its descendants individually.

     * Therefore a recommendation for the renderer is don't build any special

     * data for the top-level non-disk font of CIDFontType 0, but return immediately

     * with success code and NULL data pointer.

     *

     * get_scaled_font may be called for same font at second time,

     * so the renderen must check whether the data is already built.

     */

    gs_memory_t *mem = pfont->memory;

    gs_font_base *pbfont = (gs_font_base *)pfont;

    int code, bbox_set = 0;

    int BBox[4], scale;

    int units[2];

    double size;

    gs_fapi_font_scale font_scale =

        { {1, 0, 0, 1, 0, 0}, {0, 0}, {1, 1}, true };

    scale = 1 << I->frac_shift;

    size = 1 / hypot(pbfont->FontMatrix.xx, pbfont->FontMatrix.xy);

    /* I believe this is just to ensure minimal rounding problems with scalers that

       scale the FontBBox values with the font scale.

     */

    if (size < 1000)

        size = 1000;

    font_scale.matrix[0] = font_scale.matrix[3] = (int)(size * scale + 0.5);

    font_scale.HWResolution[0] = (fracint) (72 * scale);

    font_scale.HWResolution[1] = (fracint) (72 * scale);

    /* The interpreter specific parts of the gs_fapi_font should

     * be assinged by the caller - now do the generic parts.

     */

    I->ff.subfont = subfont;

    I->ff.font_file_path = font_file_path;

    I->ff.is_type1 = FAPI_ISTYPE1GLYPHDATA(pbfont);

    I->ff.is_vertical = (pbfont->WMode != 0);

    I->ff.memory = mem;

    I->ff.client_ctx_p = I->client_ctx_p;

    I->ff.client_font_data = pbfont;

    I->ff.client_font_data2 = pbfont;

    I->ff.server_font_data = pbfont->FAPI_font_data;    /* Possibly pass it from zFAPIpassfont. */

    if (full_font_buf) {

        I->ff.full_font_buf = (char *)full_font_buf->data;

        I->ff.full_font_buf_len = full_font_buf->size;

    }

    else {

        I->ff.full_font_buf = NULL;

        I->ff.full_font_buf_len = 0;

    }

    I->ff.is_cid = FAPI_ISCIDFONT(pbfont);

    I->ff.is_outline_font = pbfont->PaintType != 0;

    if (!I->ff.is_mtx_skipped)

        I->ff.is_mtx_skipped = (gs_fapi_get_metrics_count(&I->ff) != 0);

    if ((code = gs_fapi_renderer_retcode(mem, I, I->get_scaled_font(I, &I->ff,

                                                                    (const

                                                                     gs_fapi_font_scale

                                                                     *)

                                                                    &font_scale, xlatmap, gs_fapi_toplevel_begin)))

        < 0)

        return code;

    pbfont->FAPI_font_data = I->ff.server_font_data;    /* Save it back to GS font. */

    /* We only want to "refine" the FontBBox for fonts where we allow FAPI to be

       treated as a "black box", handing over the entire font to the FAPI server.

       That is, fonts where we give the server either the file, or a buffer with

       the entire font description in it.

     */

    if (I->ff.server_font_data != 0

        && (font_file_path != NULL || full_font_buf != NULL)) {

        if ((code =

             gs_fapi_renderer_retcode(mem, I,

                                      I->get_font_bbox(I, &I->ff,

                                                       BBox, units))) < 0) {

            gs_fapi_release_typeface(I, &pbfont->FAPI_font_data);

            return code;

        }

        /* Refine FontBBox : */

        pbfont->FontBBox.p.x = ((double)BBox[0] / units[0]);

        pbfont->FontBBox.p.y = ((double)BBox[1] / units[1]);

        pbfont->FontBBox.q.x = ((double)BBox[2] / units[0]);

        pbfont->FontBBox.q.y = ((double)BBox[3] / units[1]);

        bbox_set = 1;

    }

    if (xlatmap != NULL && pbfont->FAPI_font_data != NULL) {

        if ((code =

             gs_fapi_renderer_retcode(mem, I,

                                      I->get_decodingID(I, &I->ff,

                                                        decodingID))) < 0) {

            gs_fapi_release_typeface(I, &pbfont->FAPI_font_data);

            return code;

        }

    }

    /* Prepare descendant fonts : */

    if (font_file_path == NULL && I->ff.is_type1 && I->ff.is_cid) {     /* Renderers should expect same condition. */

        gs_font_cid0 *pfcid = (gs_font_cid0 *) pbfont;

        gs_font_type1 **FDArray = pfcid->cidata.FDArray;

        int i, n = pfcid->cidata.FDArray_size;

        I->ff.is_type1 = true;

        I->ff.is_vertical = false;      /* A subfont may be shared with another fonts. */

        I->ff.memory = mem;

        I->ff.client_ctx_p = I->client_ctx_p;

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

            gs_font_type1 *pbfont1 = FDArray[i];

            int BBox_temp[4];

            int units_temp[2];

            pbfont1->FontBBox = pbfont->FontBBox;       /* Inherit FontBBox from the type 9 font. */

            I->ff.client_font_data = pbfont1;

            pbfont1->FAPI = pbfont->FAPI;

            I->ff.client_font_data2 = pbfont1;

            I->ff.server_font_data = pbfont1->FAPI_font_data;

            I->ff.is_cid = true;

            I->ff.is_outline_font = pbfont1->PaintType != 0;

            if (!I->ff.is_mtx_skipped)

                I->ff.is_mtx_skipped = (gs_fapi_get_metrics_count(&I->ff) != 0);

            I->ff.subfont = 0;

            if ((code =

                 gs_fapi_renderer_retcode(mem, I,

                                          I->get_scaled_font(I, &I->ff,

                                                             (const

                                                              gs_fapi_font_scale

                                                              *)&font_scale,

                                                             NULL, i))) < 0) {

                break;

            }

            pbfont1->FAPI_font_data = I->ff.server_font_data;   /* Save it back to GS font. */

            /* Try to do something with the descendant font to ensure that it's working : */

            if ((code =

                 gs_fapi_renderer_retcode(mem, I,

                                          I->get_font_bbox(I, &I->ff,

                                                           BBox_temp, units_temp))) < 0) {

                break;

            }

            code = gs_notify_register(&pbfont1->notify_list, notify_remove_font, pbfont1);

            if (code < 0) {

                emprintf(mem,

                         "Ignoring gs_notify_register() failure for FAPI font.....");

            }

        }

        if (i == n) {

            code =

                gs_fapi_renderer_retcode(mem, I,

                                         I->get_scaled_font(I, &I->ff,

                                                            (const

                                                             gs_fapi_font_scale

                                                             *)&font_scale,

                                                            NULL,

                                                            gs_fapi_toplevel_complete));

            if (code >= 0)

                return bbox_set;        /* Full success. */

        }

        /* Fail, release server's font data : */

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

            gs_font_type1 *pbfont1 = FDArray[i];

            if (pbfont1->FAPI_font_data != NULL)

                gs_fapi_release_typeface(I, &pbfont1->FAPI_font_data);

        }

        if (pbfont->FAPI_font_data != NULL) {

            gs_fapi_release_typeface(I, &pbfont->FAPI_font_data);

        }

        return_error(gs_error_invalidfont);

    }

    /* This was an "else", but could elicit a warning from static analysis tools

     * about the potential for a non-void function without a return value.

     */

    code = gs_fapi_renderer_retcode(mem, I, I->get_scaled_font(I, &I->ff,

                                                               (const

                                                                gs_fapi_font_scale

                                                                *)&font_scale,

                                                               xlatmap,

                                                               gs_fapi_toplevel_complete));

    if (code < 0) {

        gs_fapi_release_typeface(I, &pbfont->FAPI_font_data);

        return code;

    }

    code =

        gs_notify_register(&pbfont->notify_list, notify_remove_font, pbfont);

    if (code < 0) {

        gs_fapi_release_typeface(I, &pbfont->FAPI_font_data);

        return code;

    }

    return bbox_set;

}

static int

outline_char(gs_memory_t *mem, gs_fapi_server *I, int import_shift_v,

             gs_show_enum *penum_s, struct gx_path_s *path, bool close_path)

{

    gs_fapi_path path_interface = path_interface_stub;

    gs_fapi_outline_handler olh;

    int code = 0;

    gs_gstate *pgs = penum_s->pgs;

    struct gx_path_s path1;

    (void)gx_path_init_local(&path1, mem);

    olh.fserver = I;

    olh.path = &path1;

    olh.x0 = pgs->ctm.tx_fixed - float2fixed(penum_s->fapi_glyph_shift.x);

    olh.y0 = pgs->ctm.ty_fixed - float2fixed(penum_s->fapi_glyph_shift.y);

    olh.close_path = close_path;

    olh.need_close = false;

    path_interface.olh = &olh;

    path_interface.shift = import_shift_v;

    if ((code =

         gs_fapi_renderer_retcode(mem, I,

                                  I->get_char_outline(I,

                                                      &path_interface))) < 0

        || path_interface.gs_error != 0) {

        if (path_interface.gs_error != 0) {

            code = path_interface.gs_error;

            goto done;

        }

        else {

            goto done;

        }

    }

    if (olh.need_close && olh.close_path)

        if ((code = add_closepath(&path_interface)) < 0)

            goto done;

    code = gx_path_copy(&path1, path);

done:

    code = code >= 0 || code == gs_error_undefinedresult ? 0 : code;

    gx_path_free(&path1, "outline_char");

    return code;

}

static void

compute_em_scale(const gs_font_base *pbfont, gs_fapi_metrics *metrics,

                 double FontMatrix_div, double *em_scale_x,

                 double *em_scale_y)

{                               /* optimize : move this stuff to FAPI_refine_font */

    gs_matrix mat;

    gs_matrix *m = &mat;

    int rounding_x, rounding_y; /* Striking out the 'float' representation error in FontMatrix. */

    double sx, sy;

    gs_fapi_server *I = pbfont->FAPI;

#if 1

    I->get_fontmatrix(I, m);

#else

    /* Temporary: replace with a FAPI call to check *if* the library needs a replacement matrix */

    memset(m, 0x00, sizeof(gs_matrix));

    m->xx = m->yy = 1.0;

#endif

    if (m->xx == 0 && m->xy == 0 && m->yx == 0 && m->yy == 0)

        m = &pbfont->base->FontMatrix;

    sx = hypot(m->xx, m->xy) * metrics->em_x / FontMatrix_div;

    sy = hypot(m->yx, m->yy) * metrics->em_y / FontMatrix_div;

    rounding_x = (int)(0x00800000 / sx);

    rounding_y = (int)(0x00800000 / sy);

    *em_scale_x = (int)(sx * rounding_x + 0.5) / (double)rounding_x;

    *em_scale_y = (int)(sy * rounding_y + 0.5) / (double)rounding_y;

}

static int

fapi_copy_mono(gx_device *dev1, gs_fapi_raster *rast, int dx, int dy)

{

    int line_step = bitmap_raster(rast->width), code;

    if (rast->line_step >= line_step) {

        return dev_proc(dev1, copy_mono) (dev1, rast->p, 0, rast->line_step,

                                          0, dx, dy, rast->width,

                                          rast->height, 0, 1);

    }

    else {                      /* bitmap data needs to be aligned, make the aligned copy : */

        byte *p = gs_alloc_byte_array(dev1->memory, rast->height, line_step,

                                      "fapi_copy_mono");

        byte *q = p, *r = rast->p, *pe;

        if (p == NULL)

            return_error(gs_error_VMerror);

        pe = p + rast->height * line_step;

        for (; q < pe; q += line_step, r += rast->line_step) {

            memcpy(q, r, rast->line_step);

            memset(q + rast->line_step, 0, line_step - rast->line_step);

        }

        code =

            dev_proc(dev1, copy_mono) (dev1, p, 0, line_step, 0, dx, dy,

                                       rast->width, rast->height, 0, 1);

        gs_free_object(dev1->memory, p, "fapi_copy_mono");

        return code;

    }

}

/*

 * For PCL/PXL pseudo-bolding, we have to "smear" a bitmap horizontally and

 * vertically by ORing together a rectangle of bits below and to the left of

 * each output bit.  We do this separately for horizontal and vertical

 * smearing.  Eventually, we will replace the current procedure, which takes

 * time proportional to W * H * (N + log2(N)), with one that is only

 * proportional to N (but takes W * N additional buffer space).

 */

/* Allocate the line buffer for bolding.  We need 2 + bold scan lines. */

static byte *

alloc_bold_lines(gs_memory_t *mem, uint width, int bold, client_name_t cname)

{       return gs_alloc_byte_array(mem, 2 + bold, bitmap_raster(width + bold),

                                   cname);

}

/* Merge one (aligned) scan line into another, for vertical smearing. */

static void

bits_merge(byte *dest, const byte *src, uint nbytes)

{       long *dp = (long *)dest;

        const long *sp = (const long *)src;

        uint n = (nbytes + sizeof(long) - 1) >> ARCH_LOG2_SIZEOF_LONG;

        for ( ; n >= 4; sp += 4, dp += 4, n -= 4 )

          dp[0] |= sp[0], dp[1] |= sp[1], dp[2] |= sp[2], dp[3] |= sp[3];

        for ( ; n; ++sp, ++dp, --n )

          *dp |= *sp;

}

/* Smear a scan line horizontally.  Note that the output is wider than */

/* the input by the amount of bolding (smear_width). */

static void

bits_smear_horizontally(byte *dest, const byte *src, uint width,

  uint smear_width)

{       uint bits_on = 0;

        const byte *sp = src;

        uint sbyte = *sp;

        byte *dp = dest;

        uint dbyte = sbyte;

        uint sdmask = 0x80;

        const byte *zp = src;

        uint zmask = 0x80;

        uint i = 0;

        /* Process the first smear_width bits. */

        { uint stop = min(smear_width, width);

          for ( ; i < stop; ++i ) {

            if ( sbyte & sdmask )

              bits_on++;

            else if ( bits_on )

              dbyte |= sdmask;

            if ( (sdmask >>= 1) == 0 )

              sdmask = 0x80, *dp++ = dbyte, dbyte = sbyte = *++sp;

          }

        }

        /* Process all but the last smear_width bits. */

        { for ( ; i < width; ++i ) {

            if ( sbyte & sdmask )

              bits_on++;

            else if ( bits_on )

              dbyte |= sdmask;

            if ( *zp & zmask )

              --bits_on;

            if ( (sdmask >>= 1) == 0 ) {

              sdmask = 0x80;

              *dp++ = dbyte;

on:           switch ( (dbyte = sbyte = *++sp) ) {

                case 0xff:

                  if ( width - i <= 8 )

                    break;

                  *dp++ = 0xff;

                  bits_on += 8 -

                    byte_count_bits[(*zp & (zmask - 1)) + (zp[1] & -(int)zmask)];

                  ++zp;

                  i += 8;

                  goto on;

                case 0:

                  if ( bits_on || width - i <= 8 )

                    break;

                  *dp++ = 0;

                  /* We know there can't be any bits to be zeroed, */

                  /* because bits_on can't go negative. */

                  ++zp;

                  i += 8;

                  goto on;

                default:

                  ;

              }

            }

            if ( (zmask >>= 1) == 0 )

              zmask = 0x80, ++zp;

          }

        }

        /* Process the last smear_width bits. */

        /****** WRONG IF width < smear_width ******/

        { uint stop = width + smear_width;

          for ( ; i < stop; ++i ) {

            if ( bits_on )

              dbyte |= sdmask;

            if ( (sdmask >>= 1) == 0 )

              sdmask = 0x80, *dp++ = dbyte, dbyte = 0;

            if ( *zp & zmask )

              --bits_on;

            if ( (zmask >>= 1) == 0 )

              zmask = 0x80, ++zp;

          }

        }

        if ( sdmask != 0x80 )

          *dp = dbyte;

}

static const int frac_pixel_shift = 4;

/* NOTE: fapi_image_uncached_glyph() doesn't check various paramters: it assumes fapi_finish_render_aux()

 * has done so: if it gets called from another function, the function must either do all the parameter

 * validation, or fapi_image_uncached_glyph() must be changed to include the validation.

 */

static int

fapi_image_uncached_glyph(gs_font *pfont, gs_gstate *pgs, gs_show_enum *penum,

                          gs_fapi_raster *rast, const int import_shift_v)

{

    gx_device *dev = penum->dev;

    gs_gstate *penum_pgs = (gs_gstate *) penum->pgs;

    int code;

    const gx_clip_path *pcpath = pgs->clip_path;

    const gx_drawing_color *pdcolor = gs_currentdevicecolor_inline(penum->pgs);

    int rast_orig_x = rast->orig_x;

    int rast_orig_y = -rast->orig_y;

    gs_font_base *pbfont = (gs_font_base *)pfont;

    gs_fapi_server *I = pbfont->FAPI;

    extern_st(st_gs_show_enum);

    byte *r = rast->p;

    byte *src, *dst;

    int h, padbytes, cpbytes, dstr = bitmap_raster(rast->width);

    int sstr = rast->line_step;

    double dx = penum_pgs->ctm.tx + (double)rast_orig_x / (1 << frac_pixel_shift) + 0.5;

    double dy = penum_pgs->ctm.ty + (double)rast_orig_y / (1 << frac_pixel_shift) + 0.5;

    /* we can only safely use the gx_image_fill_masked() "shortcut" if we're drawing

     * a "simple" colour, rather than a pattern.

     */

    if (gs_color_writes_pure(penum_pgs) && I->ff.embolden == 0.0) {

        if (dstr != sstr) {

            /* If the stride of the bitmap we've got doesn't match what the rest

             * of the Ghostscript world expects, make one that does.

             * Ghostscript aligns bitmap raster memory in a platform specific

             * manner, so see gxbitmap.h for details.

             *

             * Ideally the padding bytes wouldn't matter, but currently the

             * clist code ends up compressing it using bitmap compression. To

             * ensure consistency across runs (and to get the best possible

             * compression ratios) we therefore set such bytes to zero. It would

             * be nicer if this was fixed in future.

             */

            r = gs_alloc_bytes(penum->memory, (size_t)dstr * rast->height,

                               "fapi_finish_render_aux");

            if (!r) {

                return_error(gs_error_VMerror);

            }

            cpbytes = sstr < dstr ? sstr : dstr;

            padbytes = dstr - cpbytes;

            h = rast->height;

            src = rast->p;

            dst = r;

            if (padbytes > 0) {

                while (h-- > 0) {

                    memcpy(dst, src, cpbytes);

                    memset(dst + cpbytes, 0, padbytes);

                    src += sstr;

                    dst += dstr;

                }

            }

            else {

                while (h-- > 0) {

                    memcpy(dst, src, cpbytes);

                    src += sstr;

                    dst += dstr;

                }

            }

        }

        if (gs_object_type(penum->memory, penum) == &st_gs_show_enum) {

            dx += penum->fapi_glyph_shift.x;

            dy += penum->fapi_glyph_shift.y;

        }

        /* Processing an image object operation, but this may be for a text object */

        ensure_tag_is_set(pgs, pgs->device, GS_TEXT_TAG); /* NB: may unset_dev_color */

        code = gx_set_dev_color(pgs);

        if (code != 0)

            return code;

        code = gs_gstate_color_load(pgs);

        if (code < 0)

            return code;

        code = gx_image_fill_masked(dev, r, 0, dstr, gx_no_bitmap_id,

                                    (int)dx, (int)dy,

                                    rast->width, rast->height,

                                    pdcolor, 1, rop3_default, pcpath);

        if (rast->p != r) {

            gs_free_object(penum->memory, r, "fapi_finish_render_aux");

        }

    }

    else {

        gs_memory_t *mem = penum->memory->non_gc_memory;

        gs_image_enum *pie;

        gs_image_t image;

        int iy, nbytes;

        uint used;

        int code1;

        int w, h;

        int x = (int)dx;

        int y = (int)dy;

        uint bold = 0;

        byte *bold_lines = NULL;

        byte *line = NULL;

        int ascent = 0;

        pie = gs_image_enum_alloc(mem, "image_char(image_enum)");

        if (!pie) {

            return_error(gs_error_VMerror);

        }

        w = rast->width;

        h = rast->height;

        if (I->ff.embolden != 0.0) {

            bold = (uint)(2 * h * I->ff.embolden + 0.5);

            ascent += bold;

            bold_lines = alloc_bold_lines(pgs->memory, w, bold, "fapi_image_uncached_glyph(bold_line)");

            if (bold_lines == NULL) {

                code = gs_note_error(gs_error_VMerror);

                return(code);

            }

            line = gs_alloc_byte_array(pgs->memory, 1, bitmap_raster(w + bold) + 1, "fapi_copy_mono");

            if (line == 0) {

                gs_free_object(pgs->memory, bold_lines, "fapi_image_uncached_glyph(bold_lines)");

                code = gs_note_error(gs_error_VMerror);

                return(code);

            }

        }

        /* Make a matrix that will place the image */

        /* at (x,y) with no transformation. */

        gs_image_t_init_mask(&image, true);

        gs_make_translation((double) - x, (double) (- y + ascent), &image.ImageMatrix);

        gs_matrix_multiply(&ctm_only(penum_pgs), &image.ImageMatrix, &image.ImageMatrix);

        image.Width = w + bold;

        image.Height = h + bold;

        image.adjust = false;

        code = gs_image_init(pie, &image, false, true, penum_pgs);

        nbytes = (rast->width + 7) >> 3;

        switch (code) {

            case 1:            /* empty image */

                code = 0;

            default:

                break;

            case 0:

                if (bold == 0) {

                    for (iy = 0; iy < h && code >= 0; iy++, r += sstr) {

                        code = gs_image_next(pie, r, nbytes, &used);

                    }

                }

                else {

                    uint dest_raster = bitmap_raster(image.Width);

                    uint dest_bytes = (image.Width + 7) >> 3;

                    int n1 = bold + 1;

#define merged_line(i) (bold_lines + ((i) % n1 + 1) * dest_raster)

                    for ( y = 0; y < image.Height; y++ ) {

                        int y0 = (y < bold ? 0 : y - bold);

                        int y1 = min(y + 1, rast->height);

                        int kmask;

                        bool first = true;

                        if ( y < rast->height ) {

                            memcpy(line, r + y * rast->line_step, rast->line_step);

                            memset(line + rast->line_step, 0x00, (dest_raster + 1) -  rast->line_step);

                            bits_smear_horizontally(merged_line(y), line, rast->width, bold);

                            /* Now re-establish the invariant -- see below. */

                            kmask = 1;

                            for ( ; (y & kmask) == kmask && y - kmask >= y0;

                                  kmask = (kmask << 1) + 1) {

                                bits_merge(merged_line(y - kmask), merged_line(y - (kmask >> 1)), dest_bytes);

                            }

                        }

                       /*

                        * As of this point in the loop, we maintain the following

                        * invariant to cache partial merges of groups of lines: for

                        * each Y, y0 <= Y < y1, let K be the maximum k such that Y

                        * mod 2^k = 0 and Y + 2^k < y1; then merged_line(Y) holds

                        * the union of horizontally smeared source lines Y through

                        * Y + 2^k - 1.  The idea behind this is similar to the idea

                        * of quicksort.

                        */

                        /* Now construct the output line. */

                        first = true;

                        for ( iy = y1 - 1; iy >= y0; --iy ) {

                          kmask = 1;

                          while ( (iy & kmask) == kmask && iy - kmask >= y0 )

                            iy -= kmask, kmask <<= 1;