/* Copyright (C) 2001-2026 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 the license contained in the file LICENSE in this distribution.

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

   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,

   CA 94129, USA, for further information.

*/

/* Encoding-based (Type 1/2/42) text processing for pdfwrite. */

#include "math_.h"

#include "memory_.h"

#include "gx.h"

#include "gserrors.h"

#include "gsutil.h"

#include "gxfcmap.h"

#include "gxfcopy.h"

#include "gxfont.h"

#include "gxfont0.h"

#include "gxfont0c.h"

#include "gxpath.h"   /* for getting current point */

#include "gxchar.h"     /* for gx_compute_text_oversampling & gx_lookup_cached_char */

#include "gxfcache.h"    /* for gx_lookup_fm_pair */

#include "gdevpsf.h"

#include "gdevpdfx.h"

#include "gdevpdfg.h"

#include "gdevpdfo.h"

#include "gdevpdtx.h"

#include "gdevpdtd.h"

#include "gdevpdtf.h"

#include "gdevpdts.h"

#include "gdevpdtt.h"

#include "gximage.h"

#include "gxcpath.h"

#include "gsfcmap.h"

#include "tessocr.h"

static int pdf_char_widths(gx_device_pdf *const pdev,

                            pdf_font_resource_t *pdfont, int ch,

                            gs_font_base *font,

                            pdf_glyph_widths_t *pwidths /* may be NULL */);

static int pdf_process_string(pdf_text_enum_t *penum, gs_string *pstr,

                               const gs_matrix *pfmat,

                               pdf_text_process_state_t *ppts,

                               const gs_glyph *gdata);

/*

 * Process a string with a simple gs_font.

 */

int

pdf_process_string_aux(pdf_text_enum_t *penum, gs_string *pstr,

                          const gs_glyph *gdata, const gs_matrix *pfmat,

                          pdf_text_process_state_t *ppts)

{

    gs_font_base *font = (gs_font_base *)penum->current_font;

    switch (font->FontType) {

    case ft_TrueType:

    case ft_encrypted:

    case ft_encrypted2:

    case ft_user_defined:

    case ft_PDF_user_defined:

    case ft_PCL_user_defined:

    case ft_GL2_stick_user_defined:

    case ft_GL2_531:

    case ft_MicroType:

        break;

    default:

        return_error(gs_error_rangecheck);

    }

    return pdf_process_string(penum, pstr, pfmat, ppts, gdata);

}

/* #define OCR_DUMP_BITMAP */

#undef OCR_DUMP_BITMAP

static int OCRText(gx_device_pdf *pdev, gs_glyph glyph, gs_char ch, gs_char *length, byte **unicode)

{

#if OCR_VERSION > 0

    int code = 0;

    if(pdev->OCRStage == OCR_Rendered) {

        int llx, lly, urx, ury, char_count = 0, returned_count = 0, *returned;

        ocr_glyph_t *next_glyph = pdev->ocr_glyphs;

        int rows, stride, row, column;

        byte *bitmap = NULL, *src, *dest, *rowptr, srcmask, destmask;

        void *state;

        const char *language = pdev->ocr_language;

#ifdef OCR_DUMP_BITMAP

        gp_file *DbgFile;

#endif

        if(language == NULL || language[0] == 0)

            language = "eng";

        /* We should alredy have rendered a bitmap for all the glyphs in the

         * text operation, so this shuld be redundant, but best to be safe.

         */

        if(next_glyph == NULL)

            return_error(gs_error_unknownerror);

        /* Identify the bounding box of the returned glyphs by examing the bounds and position

         * of each glyph. At the same time count the number of expected returned characters.

         * We treat any empty bitmap (all 0x00 bytes) as a space because, obviously, the

         * OCR engine can't tell differentiate between a space character and no character at all.

         */

        llx = next_glyph->x;

        lly = next_glyph->y;

        urx = llx + next_glyph->width;

        ury = lly + next_glyph->height;

        if(next_glyph != NULL && !next_glyph->is_space)

            char_count++;

        next_glyph = (ocr_glyph_t *)next_glyph->next;

        while(next_glyph) {

            if(!next_glyph->is_space)

                char_count++;

            if(next_glyph->x < llx)

                llx = next_glyph->x;

            if(next_glyph->y < lly)

                lly = next_glyph->y;

            if(next_glyph->x + next_glyph->width > urx)

                urx = next_glyph->x + next_glyph->width;

            if(next_glyph->y + next_glyph->height > ury)

                ury = next_glyph->y + next_glyph->height;

            next_glyph = next_glyph->next;

        }

        /* Allocate and initialise the 'strip' bitmap which will receive all the

         * individual glyph bitmaps.

         */

        rows = ury - lly;

        stride = (((urx - llx) + 7) / 8) + 1;

        bitmap = gs_alloc_bytes(pdev->memory, (size_t)rows * stride, "working OCR memory");

        if(bitmap == NULL)

            return_error(gs_error_VMerror);

        memset(bitmap, 0x00, rows * stride);

        /* Allocate a buffer for the OCR engine to return the Unicode code points. This needs work,

         * we might want more information returned (bounding boxes and confidence levels) and we

         * need to think about the possibility that the OCR engine finds more character than we

         * expected (eg fi ligatures returned as 'f' and 'i'.

         */

        returned = (int *)gs_alloc_bytes(pdev->memory, (size_t)char_count * sizeof(int), "returned unicodes");

        if(returned == NULL) {

            gs_free_object(pdev->memory, bitmap, "working OCR memory");

            return_error(gs_error_VMerror);

        }

        memset(returned, 0x00, char_count * sizeof(int));

        /* Now copy each glyph bitmap to the correct position in the strip. This is complicated

         * by the fact that bitmaps are monochrome pcaked into bytes and so the destination

         * may not be aligned on a byte boundary.

         */

        next_glyph = (ocr_glyph_t *)pdev->ocr_glyphs;

        while(next_glyph) {

            rowptr = bitmap + ((next_glyph->y - lly) * stride) + (int)floor((next_glyph->x - llx) / 8);

            for(row = 0;row < next_glyph->height;row++) {

                dest = rowptr + row * stride;

                src = next_glyph->data + (row * next_glyph->raster);

                destmask = 0x80 >> (next_glyph->x - llx) % 8;

                srcmask = 0x80;

                for(column = 0; column < next_glyph->width;column++) {

                    if(*src & srcmask) {

                        *dest = *dest | destmask;

                    }

                    srcmask = srcmask >> 1;

                    if(srcmask == 0) {

                        srcmask = 0x80;

                        src++;

                    }

                    destmask = destmask >> 1;

                    if(destmask == 0) {

                        destmask = 0x80;

                        dest++;

                    }

                }

            }

            next_glyph = next_glyph->next;

        }

#ifdef OCR_DUMP_BITMAP

        DbgFile = gp_fopen(pdev->memory, "d:/temp/bits.txt", "wb+");

        for(row = 0;row < rows;row++) {

            for(column = 0;column < stride;column++) {

                dest = bitmap + (row * stride);

                gp_fprintf(DbgFile, "%02x", dest[column]);

            }

            gp_fprintf(DbgFile, "\n");

        }

        gp_fclose(DbgFile);

#endif

        /* Initialise the OCR engine */

        code = ocr_init_api(pdev->memory->non_gc_memory, language,

            pdev->ocr_engine, &state);

        if(code < 0) {

            gs_free_object(pdev->memory, bitmap, "working OCR memory");

            gs_free_object(pdev->memory, returned, "returned unicodes");

            return 0;

        }

        returned_count = char_count;

        /* Pass our strip to the OCR engine */

        code = ocr_bitmap_to_unicodes(state,

            bitmap, 0, stride * 8, rows, stride,

            (int)pdev->HWResolution[0],

            (int)pdev->HWResolution[1],

            returned, &returned_count);

        /* and close the engine back down again */

        ocr_fin_api(pdev->memory->non_gc_memory, state);

        gs_free_object(pdev->memory, bitmap, "working OCR memory");

        if(code < 0) {

            pdev->OCRStage = OCR_Failed;

            gs_free_object(pdev->memory, returned, "returned unicodes");

            return code;

        }

        /* Future enhancement we should fall back to trying the individual bitmap here */

        if(returned_count != char_count) {

            pdev->OCRStage = OCR_Failed;

            gs_free_object(pdev->memory, returned, "returned unicodes");

            return 0;

        }

        pdev->OCRUnicode = returned;

        /* Actually perform OCR on the stored bitmaps */

        pdev->OCRStage = OCR_UnicodeAvailable;

    }

    if(pdev->OCRStage == OCR_UnicodeAvailable) {

        /* We've OCR'ed the bitmaps already, find the unicode value */

        ocr_glyph_t *new_glyph = (ocr_glyph_t *)pdev->ocr_glyphs;

        int ocr_index = 0;

        uint mask = 0xFF;

        int ix;

        char *u;

        /* Find the bitmap which matches the character/glyph we are processing */

        while(new_glyph) {

            if(new_glyph->char_code == ch || new_glyph->glyph == glyph) {

                ocr_glyph_t *g1 = pdev->ocr_glyphs;

                /* Spaces are handled specially, so just jump out now */

                if(new_glyph->is_space)

                    break;

                /* Otherwise, find all the bitmaps which lie to the left of the

                 * one we found (we are assuming for now that the returned

                 * Unicode values are left to right)

                 */

                while(g1) {

                    if(!g1->is_space) {

                        if(g1->x < new_glyph->x)

                            ocr_index++;

                    }

                    g1 = g1->next;

                }

                break;

            }

            new_glyph = new_glyph->next;

        }

        /* If we found a matching bitmap, get the corresponding unicode code point from

         * the stored values returned by the OCR engine.

         */

        if(new_glyph) {

            if(pdev->OCRUnicode[ocr_index] > 0xFFFF) {

                *unicode = (byte *)gs_alloc_bytes(pdev->memory, 2 * sizeof(ushort), "temporary Unicode array");

                if(*unicode == NULL)

                    return_error(gs_error_VMerror);

                u = (char *)(*unicode);

                if(new_glyph->is_space) {

                    memset(u, 0x00, 3);

                    u[3] = 0x20;

                }

                else{

                    for(ix = 0;ix < 4;ix++) {

                        u[3 - ix] = (pdev->OCRUnicode[ocr_index] & mask) >> (8 * ix);

                        mask = mask << 8;

                    }

                }

                *length = 4;

            }else{

                *unicode = (byte *)gs_alloc_bytes(pdev->memory, sizeof(ushort), "temporary Unicode array");

                if(*unicode == NULL)

                    return_error(gs_error_VMerror);

                u = (char *)(*unicode);

                if(new_glyph->is_space) {

                    memset(u, 0x00, 2);

                    u[1] = 0x20;

                }else{

                    u[0] = (pdev->OCRUnicode[ocr_index] & 0xFF00) >> 8;

                    u[1] = (pdev->OCRUnicode[ocr_index] & 0xFF);

                }

                *length = 2;

            }

        }

    }

    #endif

    return 0;

}

/*

 * Add char code pair to ToUnicode CMap,

 * creating the CMap on neccessity.

 */

int

pdf_add_ToUnicode(gx_device_pdf *pdev, gs_font *font, pdf_font_resource_t *pdfont,

                  gs_glyph glyph, gs_char ch, const gs_const_string *gnstr)

{   int code = 0;

    gs_char length = 0;

    ushort *unicode = 0;

    if (glyph == GS_NO_GLYPH)

        return 0;

    if(pdev->UseOCR == UseOCRAlways) {

        code = OCRText(pdev, glyph, ch, &length, (byte **)&unicode);

        if(code < 0)

            return code;

    }

    else {

        length = font->procs.decode_glyph((gs_font *)font, glyph, ch, NULL, 0);

        if(length == 0 || length == GS_NO_CHAR) {

            if(gnstr != NULL && gnstr->size == 7) {

                if(!memcmp(gnstr->data, "uni", 3)) {

                    static const char *hexdigits = "0123456789ABCDEF";

                    const char *d0 = strchr(hexdigits, gnstr->data[3]);

                    const char *d1 = strchr(hexdigits, gnstr->data[4]);

                    const char *d2 = strchr(hexdigits, gnstr->data[5]);

                    const char *d3 = strchr(hexdigits, gnstr->data[6]);

                    unicode = (ushort *)gs_alloc_bytes(pdev->memory, sizeof(ushort), "temporary Unicode array");

                    if (unicode == NULL)

                        return_error(gs_error_VMerror);

                    if(d0 != NULL && d1 != NULL && d2 != NULL && d3 != NULL) {

                        char *u = (char *)unicode;

                        u[0] = ((d0 - hexdigits) << 4) + ((d1 - hexdigits));

                        u[1] = ((d2 - hexdigits) << 4) + ((d3 - hexdigits));

                        length = 2;

                    }

                }

            }

            else {

                if(pdev->UseOCR != UseOCRNever) {

                    code = OCRText(pdev, glyph, ch, &length, (byte **)&unicode);

                    if(code < 0)

                        return code;

                }

            }

        }

    }

    if (length != 0 && length != GS_NO_CHAR) {

        if (pdfont->cmap_ToUnicode == NULL) {

            /* ToUnicode CMaps are always encoded with two byte keys. See

             * Technical Note 5411, 'ToUnicode Mapping File Tutorial'

             * page 3.

             */

            /* Unfortunately, the above is not true. See the PDF Reference (version 1.7

             * p 472 'ToUnicode CMaps'. Even that documentation is incorrect as it

             * describes codespaceranges, in fact for Acrobat this is irrelevant,

             * but the bfranges must be one byte for simple fonts. By altering the

             * key size for CID fonts we can write both consistently correct.

             */

            uint num_codes = 256, key_size = 1;

            if (font->FontType == ft_CID_encrypted) {

                gs_font_cid0 *pfcid = (gs_font_cid0 *)font;

                num_codes = pfcid->cidata.common.CIDCount;

                key_size = 2;

            } else if (font->FontType == ft_CID_TrueType || font->FontType == ft_composite) {

                key_size = 2;

                /* Since PScript5.dll creates GlyphNames2Unicode with character codes

                   instead CIDs, and with the WinCharSetFFFF-H2 CMap

                   character codes appears from the range 0-0xFFFF (Bug 687954),

                   we must use the maximal character code value for the ToUnicode

                   code count. */

                num_codes = 65536;

            }

            code = gs_cmap_ToUnicode_alloc(pdev->pdf_memory, pdfont->rid, num_codes, key_size, length,

                                            &pdfont->cmap_ToUnicode);

            if (code < 0) {

                if (unicode)

                    gs_free_object(pdev->memory, unicode, "temporary Unicode array");

                return code;

            }

        } else {

            if (((gs_cmap_ToUnicode_t *)pdfont->cmap_ToUnicode)->value_size < length){

                code = gs_cmap_ToUnicode_realloc(pdev->pdf_memory, length, &pdfont->cmap_ToUnicode);

                if (code < 0)

                    return code;

            }

        }

        if (!unicode) {

            unicode = (ushort *)gs_alloc_bytes(pdev->memory, (size_t)length, "temporary Unicode array");

            if (unicode == NULL)

                return_error(gs_error_VMerror);

            length = font->procs.decode_glyph((gs_font *)font, glyph, ch, unicode, length);

        }

        /* We use this when determining whether we should use an existing ToUnicode

         * CMap entry, for s aimple font. The basic problem appears to be that the front end ToUnicode

         * processing is somewhat limited, due to its origins in the PostScript GlyphNames2Unicode

         * handling. We cannot support more than 4 bytes on input, the bug for 702201 has a ToUnicode

         * entry which maps the single /ffi glyph to 'f' 'f' and 'i' code points for a total of 6

         * (3 x UTF-16BE code points) bytes. If we just leave the Encoding alone then Acrobat will use the

         * /ffi glyph to get the 'correct' answer. This was originally done using a 'TwoByteToUnicode'

         * flag in the font and if the flag was not true, then we dropped the entire ToUnicode CMap.

         *

         * Additionally; bug #708284, the ToUnicode CMap is actually broken, it contains invalid UTF-16BE

         * entries which actually are 4 bytes long. Acrobat silently ignores the broekn entires (!) but the fact

         * that we dropped the entire CMap meant that none of the content pasted correctly.

         *

         * So... Until we get to the point of preserving input codes in excess of 4 bytes we do some hideous

         * hackery here and simply drop ToUnicode entries in simple fonts, with a standard encoding, when the

         * ToUnicode entry is not a single UTF-16BE code point. Acrobat will use the Encoding for the missing entries

         * or the character code in extremis, which is as good as this is going to get right now.

         *

         */

        if (pdfont->cmap_ToUnicode != NULL) {

            if (pdfont->FontType != ft_composite && pdfont->u.simple.Encoding != NULL) {

                if (length <= 2)

                    gs_cmap_ToUnicode_add_pair(pdfont->cmap_ToUnicode, ch, unicode, length);

            } else

                gs_cmap_ToUnicode_add_pair(pdfont->cmap_ToUnicode, ch, unicode, length);

        }

    }

    if (unicode)

        gs_free_object(pdev->memory, unicode, "temporary Unicode array");

    return 0;

}

typedef struct {

    gx_device_pdf *pdev;

    pdf_resource_type_t rtype;

} pdf_resource_enum_data_t;

static int

process_resources2(void *client_data, const byte *key_data, uint key_size, const cos_value_t *v)

{

    pdf_resource_enum_data_t *data = (pdf_resource_enum_data_t *)client_data;

    pdf_resource_t *pres = pdf_find_resource_by_resource_id(data->pdev, data->rtype, v->contents.object->id);

    if (pres == NULL)

        return_error(gs_error_unregistered); /* Must not happen. */

    pres->where_used |= data->pdev->used_mask;

    return 0;

}

static int

process_resources1(void *client_data, const byte *key_data, uint key_size, const cos_value_t *v)

{

    pdf_resource_enum_data_t *data = (pdf_resource_enum_data_t *)client_data;

    static const char *rn[] = {PDF_RESOURCE_TYPE_NAMES};

    int i;

    for (i = 0; i < count_of(rn); i++) {

        if (rn[i] != NULL && !bytes_compare((const byte *)rn[i], strlen(rn[i]), key_data, key_size))

            break;

    }

    if (i >= count_of(rn))

        return 0;

    data->rtype = i;

    return cos_dict_forall((cos_dict_t *)v->contents.object, data, process_resources2);

}

/*

 * Register charproc fonts with the page or substream.

 */

int

pdf_used_charproc_resources(gx_device_pdf *pdev, pdf_font_resource_t *pdfont)

{

    if (pdfont->where_used & pdev->used_mask)

        return 0;

    pdfont->where_used |= pdev->used_mask;

    if (pdev->CompatibilityLevel >= 1.2)

        return 0;

    if (pdfont->FontType == ft_user_defined ||

        pdfont->FontType == ft_PDF_user_defined ||

        pdfont->FontType == ft_PCL_user_defined ||

        pdfont->FontType == ft_MicroType ||

        pdfont->FontType == ft_GL2_stick_user_defined ||

        pdfont->FontType == ft_GL2_531) {

        pdf_resource_enum_data_t data;

        data.pdev = pdev;

        return cos_dict_forall(pdfont->u.simple.s.type3.Resources, &data, process_resources1);

    }

    return 0;

}

/*

 * Given a text string and a simple gs_font, return a font resource suitable

 * for the text string, possibly re-encoding the string.  This

 * may involve creating a font resource and/or adding glyphs and/or Encoding

 * entries to it.

 *

 * Sets *ppdfont.

 */

static int

pdf_encode_string_element(gx_device_pdf *pdev, gs_font *font, pdf_font_resource_t *pdfont,

                  gs_char ch, const gs_glyph *gdata)

{

    gs_font_base *cfont, *ccfont;

    int code;

    gs_glyph copied_glyph;

    gs_const_string gnstr;

    pdf_encoding_element_t *pet;

    gs_glyph glyph;

    /*

     * In contradiction with pre-7.20 versions of pdfwrite,

     * we never re-encode texts due to possible encoding conflict while font merging.

     */

    cfont = pdf_font_resource_font(pdfont, false);

    ccfont = pdf_font_resource_font(pdfont, true);

    pet = &pdfont->u.simple.Encoding[ch];

    glyph = (gdata == NULL ? font->procs.encode_char(font, ch, GLYPH_SPACE_NAME)

                           : *gdata);

    if (glyph == GS_NO_GLYPH || glyph == pet->glyph) {

        if((pdfont->cmap_ToUnicode == NULL || !gs_cmap_ToUnicode_check_pair(pdfont->cmap_ToUnicode, ch)) && pdev->UseOCR != UseOCRNever)

            (void)pdf_add_ToUnicode(pdev, font, pdfont, glyph, ch, NULL);

        return 0;

    }

    if (pet->glyph != GS_NO_GLYPH) { /* encoding conflict */

        return_error(gs_error_rangecheck);

        /* Must not happen because pdf_obtain_font_resource

         * checks for encoding compatibility.

         */

    }

    code = font->procs.glyph_name(font, glyph, &gnstr);

    if (code < 0)

        return code; /* can't get name of glyph */

    if (pdev->PDFA > 1 && (font->FontType == ft_encrypted || font->FontType == ft_encrypted2) && bytes_compare(gnstr.data, gnstr.size, (const byte *)".notdef", 7) == 0) {

        switch (pdev->PDFACompatibilityPolicy) {

            case 0:

                emprintf(pdev->memory,

                     "\nAttempt to use the /.notdef glyph directly, not permitted in PDF/A-2+, reverting to normal PDF output\n");

                pdev->AbortPDFAX = true;

                pdev->PDFA = 0;

                break;

            case 1:

                emprintf(pdev->memory,

                     "\nAttempt to use the /.notdef glyph directly, not permitted in PDF/A-2+, glyph will not be present in output file\n\n");

                /* Returning an error causees text processing to try and

                 * handle the glyph by rendering to a bitmap instead of

                 * as a glyph in a font. This will eliminate the problem

                 * and the fiel should appear the same as the original.

                 */

                return_error(gs_error_unknownerror);

                break;

            case 2:

                emprintf(pdev->memory,

                     "\nAttempt to use the /.notdef glyph directly, not permitted in PDF/A-2+, aborting conversion\n");

                /* Careful here, only certain errors will bubble up

                 * through the text processing.

                 */

                return_error(gs_error_invalidfont);

                break;

            default:

                emprintf(pdev->memory,

                     "\nAttempt to use the /.notdef glyph directly, not permitted in PDF/A-2+, unrecognised PDFACompatibilityLevel,\nreverting to normal PDF output\n");

                pdev->AbortPDFAX = true;

                pdev->PDFA = 0;

                break;

        }

    }

    if (font->FontType != ft_user_defined &&

        font->FontType != ft_PDF_user_defined &&

        font->FontType != ft_PCL_user_defined &&

        font->FontType != ft_MicroType &&

        font->FontType != ft_GL2_stick_user_defined &&

        font->FontType != ft_GL2_531) {

        /* The standard 14 fonts don't have a FontDescriptor. */

        code = (pdfont->base_font != 0 ?

                pdf_base_font_copy_glyph(pdfont->base_font, glyph, (gs_font_base *)font) :

                pdf_font_used_glyph(pdfont->FontDescriptor, glyph, (gs_font_base *)font));

        if (code < 0 && code != gs_error_undefined)

            return code;

        if (code == gs_error_undefined) {

            if (pdev->PDFA != 0 || pdev->PDFX != 0) {

                switch (pdev->PDFACompatibilityPolicy) {

                    case 0:

                        emprintf(pdev->memory,

                             "Requested glyph not present in source font,\n not permitted in PDF/A or PDF/X, reverting to normal PDF output\n");

                        pdev->AbortPDFAX = true;

                        pdev->PDFA = 0;

                        break;

                    case 1:

                        emprintf(pdev->memory,

                             "Requested glyph not present in source font,\n not permitted in PDF/A or PDF/X, glyph will not be present in output file\n\n");

                        /* Returning an error causees text processing to try and

                         * handle the glyph by rendering to a bitmap instead of

                         * as a glyph in a font. This will eliminate the problem

                         * and the fiel should appear the same as the original.

                         */

                        return_error(gs_error_unknownerror);

                        break;

                    case 2:

                        emprintf(pdev->memory,

                             "Requested glyph not present in source font,\n not permitted in PDF/A or PDF/X, aborting conversion\n");

                        /* Careful here, only certain errors will bubble up

                         * through the text processing.

                         */

                        return_error(gs_error_invalidfont);

                        break;

                    default:

                        emprintf(pdev->memory,

                             "Requested glyph not present in source font,\n not permitted in PDF/A or PDF/X, unrecognised PDFACompatibilityLevel,\nreverting to normal PDF output\n");

                        pdev->AbortPDFAX = true;

                        pdev->PDFA = 0;

                        break;

                }

            }

            /* PS font has no such glyph. */

            if (bytes_compare(gnstr.data, gnstr.size, (const byte *)".notdef", 7)) {

                pet->glyph = glyph;

                pdf_copy_string_to_encoding(pdev, &gnstr, pet);

                pet->is_difference = true;

            }

        } else if (pdfont->base_font == NULL && ccfont != NULL &&

                (gs_copy_glyph_options(font, glyph, (gs_font *)ccfont, COPY_GLYPH_NO_NEW) != 1 ||

                    gs_copied_font_add_encoding((gs_font *)ccfont, ch, glyph) < 0)) {

               /*

                * The "complete" copy of the font appears incomplete

                * due to incrementally added glyphs. Drop the "complete"

                * copy now and continue with subset font only.

                *

                * Note that we need to add the glyph to the encoding of the

                * "complete" font, because "PPI-ProPag 2.6.1.4 (archivePg)"

                * creates multiple font copies with reduced encodings

                * (we believe it is poorly designed),

                * and we can merge the copies back to a single font (see Bug 686875).

                * We also check whether the encoding is compatible.

                * It must be compatible here due to the pdf_obtain_font_resource

                * and ccfont logics, but we want to ensure for safety reason.

                */

            ccfont = NULL;

            pdf_font_descriptor_drop_complete_font(pdfont->FontDescriptor);

        }

        /*

            * We arbitrarily allow the first encoded character in a given

            * position to determine the encoding associated with the copied

            * font.

            */

        copied_glyph = cfont->procs.encode_char((gs_font *)cfont, ch,

                                                GLYPH_SPACE_NAME);

        if (glyph != copied_glyph &&

            gs_copied_font_add_encoding((gs_font *)cfont, ch, glyph) < 0

            )

            pet->is_difference = true;

        pdfont->used[ch >> 3] |= 0x80 >> (ch & 7);

    }

    /*

     * We always generate ToUnicode for simple fonts, because

     * we can't detemine in advance, which glyphs the font actually uses.

     * The decision about writing it out is deferred until pdf_write_font_resource.

     */

    code = pdf_add_ToUnicode(pdev, font, pdfont, glyph, ch, &gnstr);

    if(code < 0)

        return code;

    pet->glyph = glyph;

    return pdf_copy_string_to_encoding(pdev, &gnstr, pet);

}

/*

 * Estimate text bbox.

 */

static int

process_text_estimate_bbox(pdf_text_enum_t *pte, gs_font_base *font,

                          const gs_const_string *pstr,

                          const gs_matrix *pfmat,

                          gs_rect *text_bbox, gs_point *pdpt)

{

    int i;

    int space_char =

        (pte->text.operation & TEXT_ADD_TO_SPACE_WIDTH ?

         pte->text.space.s_char : -1);

    int WMode = font->WMode;

    int code = 0;

    gs_point total = {0, 0};

    gs_point p0, p1, p2, p3;

    gs_fixed_point origin;

    gs_matrix m;

    int xy_index = pte->xy_index, info_flags = 0;

    gx_path *path = gs_text_enum_path(pte);

    code = gx_path_current_point(path, &origin);

    if (code < 0)

        return code;

    m = ctm_only(pte->pgs);

    m.tx = fixed2float(origin.x);

    m.ty = fixed2float(origin.y);

    gs_matrix_multiply(pfmat, &m, &m);

    /* If the FontBBox is all 0, then its clearly wrong, so determine the text width

     * accurately by processing the glyph program.

     */

    if (font->FontBBox.p.x == font->FontBBox.q.x ||

        font->FontBBox.p.y == font->FontBBox.q.y) {

            info_flags = GLYPH_INFO_BBOX | GLYPH_INFO_WIDTH0 << WMode;

    } else {

        double width, height;

        /* This is a heuristic for Bug #700124. We try to determine whether a given glyph

         * is used in a string by using the current point, glyph width and advance width

         * to see if the glyph is fully clipped out, if it is we don't include it in the

         * output, or in subset fonts.

         *

         * Previously we used the FontBBox to determine a quick glyph width, but

         * in bug #699454 and bug #699571 we saw that OneVision EPSExport could construct

         * fonts with a wildly incorrect BBox ([0 0 2 1]) and then draw the text without

         * an advance width, leading us to conclude the glyph was clipped out and eliding it.

         *

         * To solve this we added code to process the glyph program and extract an accurate

         * width of the glyph. However, this proved slow. So here we attempt to decide if

         * the FontBBox is sensible by applying the FontMatrix to it, and looking to see

         * if that results in a reasonable number of co-ordinates in font space. If it

         * does then we use the FontBBox for speed, otherwise we carefully process the

         * glyphs in the font and extract their accurate widths.

         */

        gs_point_transform(font->FontBBox.p.x, font->FontBBox.p.y, &font->FontMatrix, &p0);

        gs_point_transform(font->FontBBox.p.x, font->FontBBox.q.y, &font->FontMatrix, &p1);

        gs_point_transform(font->FontBBox.q.x, font->FontBBox.p.y, &font->FontMatrix, &p2);

        gs_point_transform(font->FontBBox.q.x, font->FontBBox.q.y, &font->FontMatrix, &p3);

        width = max(fabs(p2.x), fabs(p3.x)) - p0.x;

        height = max(fabs(p1.y), fabs(p3.y)) - p0.y;

        /* Yes, this is a magic number. There's no reasoning here, its just a guess, we may

         * need to adjust this in future. Or possibly do away with it altogether if it proves

         * unreliable.

         */

        if (fabs(width) < 0.1 || fabs(height) < 0.1) {

            info_flags = GLYPH_INFO_BBOX | GLYPH_INFO_WIDTH0 << WMode;

        } else {

            gs_point_transform(font->FontBBox.p.x, font->FontBBox.p.y, &m, &p0);

            gs_point_transform(font->FontBBox.p.x, font->FontBBox.q.y, &m, &p1);

            gs_point_transform(font->FontBBox.q.x, font->FontBBox.p.y, &m, &p2);

            gs_point_transform(font->FontBBox.q.x, font->FontBBox.q.y, &m, &p3);

            info_flags = GLYPH_INFO_WIDTH0 << WMode;

        }

    }

    for (i = 0; i < pstr->size; ++i) {

        byte c = pstr->data[i];

        gs_rect bbox;

        gs_point wanted, tpt;

        gs_glyph glyph = font->procs.encode_char((gs_font *)font, c,

                                        GLYPH_SPACE_NAME);

        gs_glyph_info_t info;

        int code;

        if (glyph == GS_NO_GLYPH)

            return_error (gs_error_invalidfont);

        memset(&info, 0x00, sizeof(gs_glyph_info_t));

        code = font->procs.glyph_info((gs_font *)font, glyph, NULL,

                                            info_flags,

                                            &info);

        /* If we got an undefined error, and its a type 1/CFF font, try to

         * find the /.notdef glyph and use its width instead (as this is the

         * glyph which will be rendered). We don't do this for other font types

         * as it seems Acrobat/Distiller may not do so either.

         */

        /* The GL/2 stick font does not supply the enumerate_glyphs method,

         * *and* leaves it uninitialised. But it should not be possible to

         * get an undefiend error with this font anyway.

         */

        if (code < 0) {

            if ((font->FontType == ft_encrypted ||

            font->FontType == ft_encrypted2)) {

                int index;

                for (index = 0;

                    (font->procs.enumerate_glyph((gs_font *)font, &index,

                    (GLYPH_SPACE_NAME), &glyph)) >= 0 &&

                    index != 0;) {

                    if (gs_font_glyph_is_notdef(font, glyph)) {

                        code = font->procs.glyph_info((gs_font *)font, glyph, NULL,

                                            info_flags,

                                            &info);

                    if (code < 0)

                        return code;

                    }

                    break;

                }

            }

            if (code < 0)

                return code;

        }

        if (pte->text.operation & TEXT_REPLACE_WIDTHS) {

            code = gs_text_replaced_width(&pte->text, xy_index++, &tpt);

            if (code < 0)

                return code;

            gs_distance_transform(tpt.x, tpt.y, &ctm_only(pte->pgs), &wanted);

        } else {

            gs_distance_transform(info.width[WMode].x,

                                  info.width[WMode].y,

                                  &m, &wanted);

            if (pte->text.operation & TEXT_ADD_TO_ALL_WIDTHS) {

                gs_distance_transform(pte->text.delta_all.x,

                                      pte->text.delta_all.y,

                                      &ctm_only(pte->pgs), &tpt);

                wanted.x += tpt.x;

                wanted.y += tpt.y;

            }

            if (pstr->data[i] == space_char && pte->text.operation & TEXT_ADD_TO_SPACE_WIDTH) {

                gs_distance_transform(pte->text.delta_space.x,

                                      pte->text.delta_space.y,

                                      &ctm_only(pte->pgs), &tpt);

                wanted.x += tpt.x;

                wanted.y += tpt.y;

            }

        }

        if (info_flags & GLYPH_INFO_BBOX) {

            gs_point_transform(info.bbox.p.x, info.bbox.p.x, &m, &p0);

            gs_point_transform(info.bbox.p.x, info.bbox.q.y, &m, &p1);

            gs_point_transform(info.bbox.q.x, info.bbox.p.y, &m, &p2);

            gs_point_transform(info.bbox.q.x, info.bbox.q.y, &m, &p3);

        }

        bbox.p.x = min(min(p0.x, p1.x), min(p2.x, p3.x));

        bbox.p.y = min(min(p0.y, p1.y), min(p2.y, p3.y));

        bbox.q.x = max(max(p0.x, p1.x), max(p2.x, p3.x));

        bbox.q.y = max(max(p0.y, p1.y), max(p2.y, p3.y));

        bbox.q.x = bbox.p.x + max(bbox.q.x - bbox.p.x, wanted.x);

        bbox.q.y = bbox.p.y + max(bbox.q.y - bbox.p.y, wanted.y);

        bbox.p.x += total.x;

        bbox.p.y += total.y;

        bbox.q.x += total.x;

        bbox.q.y += total.y;

        total.x += wanted.x;

        total.y += wanted.y;

        if (i == 0)

            *text_bbox = bbox;

        else

            rect_merge(*text_bbox, bbox);

    }

    *pdpt = total;

    return 0;

}

void

adjust_first_last_char(pdf_font_resource_t *pdfont, byte *str, int size)

{

    int i;

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

        int chr = str[i];

        if (chr < pdfont->u.simple.FirstChar)

            pdfont->u.simple.FirstChar = chr;

        if (chr > pdfont->u.simple.LastChar)

            pdfont->u.simple.LastChar = chr;

    }

}

int

pdf_shift_text_currentpoint(pdf_text_enum_t *penum, gs_point *wpt)

{

    return gs_moveto_aux(penum->pgs, gx_current_path(penum->pgs),

                              fixed2float(penum->origin.x) + wpt->x,

                              fixed2float(penum->origin.y) + wpt->y);

}

/*

 * Internal procedure to process a string in a non-composite font.

 * Doesn't use or set pte->{data,size,index}; may use/set pte->xy_index;

 * may set penum->returned.total_width.  Sets ppts->values.

 *

 * Note that the caller is responsible for re-encoding the string, if

 * necessary; for adding Encoding entries in pdfont; and for copying any

 * necessary glyphs.  penum->current_font provides the gs_font for getting

 * glyph metrics, but this font's Encoding is not used.

 */

static int process_text_return_width(const pdf_text_enum_t *pte,

                                      gs_font_base *font,

                                      pdf_text_process_state_t *ppts,

                                      const gs_const_string *pstr, const gs_glyph *gdata,

                                      gs_point *pdpt, int *accepted, gs_rect *bbox);

static int

pdf_process_string(pdf_text_enum_t *penum, gs_string *pstr,

                   const gs_matrix *pfmat,

                   pdf_text_process_state_t *ppts, const gs_glyph *gdata)

{

    gx_device_pdf *const pdev = (gx_device_pdf *)penum->dev;

    gs_font_base *font = (gs_font_base *)penum->current_font;

    pdf_font_resource_t *pdfont;

    gs_text_params_t *text = &penum->text;

    int code = 0, mask;

    gs_point width_pt;

    int accepted;

    gs_rect text_bbox = {{0, 0}, {0, 0}}, glyphs_bbox = {{10000,10000}, {0,0}};

    unsigned int operation = text->operation;

    gx_path *path = gs_text_enum_path(penum);

    code = pdf_obtain_font_resource(penum, pstr, &pdfont);

    if (code < 0)

        return code;

    if (pfmat == 0)

        pfmat = &font->FontMatrix;

    if (text->operation & TEXT_RETURN_WIDTH) {

        code = gx_path_current_point(path, &penum->origin);

        if (code < 0)

            return code;

    }

    if (text->size == 0)

        return 0;

    if (penum->pgs->text_rendering_mode != 3 && !(text->operation & TEXT_DO_NONE)) {

        /*

         * Acrobat Reader can't handle text with huge coordinates,

         * so don't emit the text if it is outside the clip bbox

         * (Note : it ever fails with type 3 fonts).

         */

        code = process_text_estimate_bbox(penum, font, (gs_const_string *)pstr, pfmat,

                                          &text_bbox, &width_pt);

        if (code == 0) {

            gs_fixed_rect clip_bbox;

            gs_rect rect;

            if (penum->pcpath) {

                gx_cpath_outer_box(penum->pcpath, &clip_bbox);

                rect.p.x = fixed2float(clip_bbox.p.x);

                rect.p.y = fixed2float(clip_bbox.p.y);

                rect.q.x = fixed2float(clip_bbox.q.x);

                rect.q.y = fixed2float(clip_bbox.q.y);

                rect_intersect(rect, text_bbox);

                if ((rect.p.x > rect.q.x || rect.p.y > rect.q.y) && penum->pgs->text_rendering_mode < 3) {

                    penum->index += pstr->size;

                    text->operation &= ~TEXT_DO_DRAW;

                    penum->text_clipped = true;

                }

            }

        } else {

            gs_matrix m;

            gs_fixed_point origin;

            gs_point p0, p1, p2, p3;

            code = gx_path_current_point(path, &origin);

            if (code < 0)

                goto done;

            m = ctm_only(penum->pgs);

            m.tx = fixed2float(origin.x);

            m.ty = fixed2float(origin.y);

            gs_matrix_multiply(pfmat, &m, &m);

            if (font->FontBBox.p.x != font->FontBBox.q.x) {

                text_bbox.p.x = font->FontBBox.p.x;

                text_bbox.q.x = font->FontBBox.q.x;

            } else {

                text_bbox.p.x = 0;

                text_bbox.q.x = 1000;

            }

            if (font->FontBBox.p.y != font->FontBBox.q.y) {

                text_bbox.p.y = font->FontBBox.p.y;

                text_bbox.q.y = font->FontBBox.q.y;

            } else {

                text_bbox.p.y = 0;

                text_bbox.q.y = 1000;

            }

            gs_point_transform(text_bbox.p.x, text_bbox.p.y, &m, &p0);

            gs_point_transform(text_bbox.p.x, text_bbox.q.y, &m, &p1);

            gs_point_transform(text_bbox.q.x, text_bbox.p.y, &m, &p2);

            gs_point_transform(text_bbox.q.x, text_bbox.q.y, &m, &p3);

            text_bbox.p.x = min(min(p0.x, p1.x), min(p1.x, p2.x));

            text_bbox.p.y = min(min(p0.y, p1.y), min(p1.y, p2.y));

            text_bbox.q.x = max(max(p0.x, p1.x), max(p1.x, p2.x));

            text_bbox.q.y = max(max(p0.y, p1.y), max(p1.y, p2.y));

        }

    } else {

        /* We have no penum->pcpath. */

    }

    /*

     * Note that pdf_update_text_state sets all the members of ppts->values

     * to their current values.

     */

    code = pdf_update_text_state(ppts, penum, pdfont, pfmat);

    if (code > 0) {

        /* Try not to emulate ADD_TO_WIDTH if we don't have to. */

        if (code & TEXT_ADD_TO_SPACE_WIDTH) {

            if (!memchr(pstr->data, penum->text.space.s_char, pstr->size))

                code &= ~TEXT_ADD_TO_SPACE_WIDTH;

        }

    }

    if (code < 0)

        goto done;

    mask = code;

    if (text->operation & TEXT_REPLACE_WIDTHS)

        mask |= TEXT_REPLACE_WIDTHS;

    /*

     * The only operations left to handle are TEXT_DO_DRAW and

     * TEXT_RETURN_WIDTH.

     */

    if (mask == 0) {

        /*

         * If any character has real_width != Width, we have to process

         * the string character-by-character.  process_text_return_width

         * will tell us what we need to know.

         */

        if (!(text->operation & (TEXT_DO_DRAW | TEXT_RETURN_WIDTH))) {

            code = 0;

            goto done;

        }

        code = process_text_return_width(penum, font, ppts,

                                         (gs_const_string *)pstr, gdata,