/* Copyright (C) 2001-2022 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.,  1305 Grant Avenue - Suite 200, Novato,

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

*/

/* PDF-writing driver */

#include "fcntl_.h"

#include "memory_.h"

#include "time_.h"

#include "unistd_.h"

#include "gx.h"

#include "gp.h"     /* for gp_get_realtime */

#include "gserrors.h"

#include "gxdevice.h"

#include "gdevpdfx.h"

#include "gdevpdfg.h"   /* only for pdf_reset_graphics */

#include "gdevpdfo.h"

#include "smd5.h"

#include "sarc4.h"

#include "gscms.h"

#include "gdevpdtf.h"

#include "gdevpdtx.h"

#include "gdevpdtd.h"

#include "gdevpdti.h"

#include "gsfcmap.h"        /* For gs_cmap_ToUnicode_free */

#include "gxfcache.h"

#include "gdevpdts.h"       /* for sync_text_state */

#include "gdevpdfo.h"

/* Define the default language level and PDF compatibility level. */

/* Acrobat 8 (PDF 1.7) is the default. (1.7 for ICC V4.2.0 profile support) */

#define PSDF_VERSION_INITIAL psdf_version_ll3

#define PDF_COMPATIBILITY_LEVEL_INITIAL 1.7

/* Define the size of internal stream buffers. */

/* (This is not a limitation, it only affects performance.) */

#define sbuf_size 512

/* GC descriptors */

private_st_pdf_page();

gs_private_st_element(st_pdf_page_element, pdf_page_t, "pdf_page_t[]",

                      pdf_page_elt_enum_ptrs, pdf_page_elt_reloc_ptrs,

                      st_pdf_page);

private_st_pdf_linearisation_record();

gs_private_st_element(st_pdf_linearisation_record_element, pdf_linearisation_record_t, "pdf_linearstion_record_t[]",

                      pdf_linearisation_record_elt_enum_ptrs, pdf_linearisation_record_elt_reloc_ptrs,

                      st_pdf_linearisation_record);

private_st_device_pdfwrite();

private_st_pdf_substream_save();

private_st_pdf_substream_save_element();

/* GC procedures */

static

ENUM_PTRS_WITH(device_pdfwrite_enum_ptrs, gx_device_pdf *pdev)

{

    index -= gx_device_pdf_num_ptrs + gx_device_pdf_num_param_strings;

    if (index < NUM_RESOURCE_TYPES * NUM_RESOURCE_CHAINS)

        ENUM_RETURN(pdev->resources[index / NUM_RESOURCE_CHAINS].chains[index % NUM_RESOURCE_CHAINS]);

    index -= NUM_RESOURCE_TYPES * NUM_RESOURCE_CHAINS;

    if (index <= pdev->outline_depth && pdev->outline_levels)

        ENUM_RETURN(pdev->outline_levels[index].first.action);

    index -= pdev->outline_depth + 1;

    if (index <= pdev->outline_depth && pdev->outline_levels)

        ENUM_RETURN(pdev->outline_levels[index].last.action);

    index -= pdev->outline_depth + 1;

    if (index < pdev->PatternDepth) {

       ENUM_RETURN(pdev->initial_pattern_states[index]);

    }

    index -= pdev->PatternDepth;

    ENUM_PREFIX(st_device_psdf, 0);

}

 ENUM_PTR(0, gx_device_pdf, asides.strm);

 ENUM_PTR(1, gx_device_pdf, asides.strm_buf);

 ENUM_PTR(2, gx_device_pdf, asides.save_strm);

 ENUM_PTR(3, gx_device_pdf, streams.strm);

 ENUM_PTR(4, gx_device_pdf, streams.strm_buf);

 ENUM_PTR(5, gx_device_pdf, pictures.strm);

 ENUM_PTR(6, gx_device_pdf, pictures.strm_buf);

 ENUM_PTR(7, gx_device_pdf, pictures.save_strm);

 ENUM_PTR(8, gx_device_pdf, Catalog);

 ENUM_PTR(9, gx_device_pdf, Info);

 ENUM_PTR(10, gx_device_pdf, Pages);

 ENUM_PTR(11, gx_device_pdf, text);

 ENUM_PTR(12, gx_device_pdf, pages);

 ENUM_PTR(13, gx_device_pdf, cs_Patterns[0]);

 ENUM_PTR(14, gx_device_pdf, cs_Patterns[1]);

 ENUM_PTR(15, gx_device_pdf, cs_Patterns[3]);

 ENUM_PTR(16, gx_device_pdf, cs_Patterns[4]);

 ENUM_PTR(17, gx_device_pdf, last_resource);

 ENUM_PTR(18, gx_device_pdf, articles);

 ENUM_PTR(19, gx_device_pdf, Dests);

 ENUM_PTR(20, gx_device_pdf, global_named_objects);

 ENUM_PTR(21, gx_device_pdf, local_named_objects);

 ENUM_PTR(22, gx_device_pdf, NI_stack);

 ENUM_PTR(23, gx_device_pdf, Namespace_stack);

 ENUM_PTR(24, gx_device_pdf, font_cache);

 ENUM_PTR(25, gx_device_pdf, clip_path);

 ENUM_PTR(26, gx_device_pdf, PageLabels);

 ENUM_PTR(27, gx_device_pdf, PageLabels_current_label);

 ENUM_PTR(28, gx_device_pdf, sbstack);

 ENUM_PTR(29, gx_device_pdf, substream_Resources);

 ENUM_PTR(30, gx_device_pdf, font3);

 ENUM_PTR(31, gx_device_pdf, accumulating_substream_resource);

 ENUM_PTR(32, gx_device_pdf, pres_soft_mask_dict);

 ENUM_PTR(33, gx_device_pdf, PDFXTrimBoxToMediaBoxOffset.data);

 ENUM_PTR(34, gx_device_pdf, PDFXBleedBoxToTrimBoxOffset.data);

 ENUM_PTR(35, gx_device_pdf, Identity_ToUnicode_CMaps[0]);

 ENUM_PTR(36, gx_device_pdf, Identity_ToUnicode_CMaps[1]);

 ENUM_PTR(37, gx_device_pdf, vgstack);

 ENUM_PTR(38, gx_device_pdf, outline_levels);

 ENUM_PTR(39, gx_device_pdf, EmbeddedFiles);

 ENUM_PTR(40, gx_device_pdf, pdf_font_dir);

 ENUM_PTR(41, gx_device_pdf, ExtensionMetadata);

 ENUM_PTR(42, gx_device_pdf, PassThroughWriter);

#define e1(i,elt) ENUM_PARAM_STRING_PTR(i + gx_device_pdf_num_ptrs, gx_device_pdf, elt);

gx_device_pdf_do_param_strings(e1)

#undef e1

#define e1(i,elt) ENUM_STRING_PTR(i + gx_device_pdf_num_ptrs + gx_device_pdf_num_param_strings,\

                                 gx_device_pdf, elt);

gx_device_pdf_do_const_strings(e1)

#undef e1

ENUM_PTRS_END

static RELOC_PTRS_WITH(device_pdfwrite_reloc_ptrs, gx_device_pdf *pdev)

{

    RELOC_PREFIX(st_device_psdf);

 RELOC_PTR(gx_device_pdf, asides.strm);

 RELOC_PTR(gx_device_pdf, asides.strm_buf);

 RELOC_PTR(gx_device_pdf, asides.save_strm);

 RELOC_PTR(gx_device_pdf, streams.strm);

 RELOC_PTR(gx_device_pdf, streams.strm_buf);

 RELOC_PTR(gx_device_pdf, pictures.strm);

 RELOC_PTR(gx_device_pdf, pictures.strm_buf);

 RELOC_PTR(gx_device_pdf, pictures.save_strm);

 RELOC_PTR(gx_device_pdf, Catalog);

 RELOC_PTR(gx_device_pdf, Info);

 RELOC_PTR(gx_device_pdf, Pages);

 RELOC_PTR(gx_device_pdf, text);

 RELOC_PTR(gx_device_pdf, pages);

 RELOC_PTR(gx_device_pdf, cs_Patterns[0]);

 RELOC_PTR(gx_device_pdf, cs_Patterns[1]);

 RELOC_PTR(gx_device_pdf, cs_Patterns[3]);

 RELOC_PTR(gx_device_pdf, cs_Patterns[4]);

 RELOC_PTR(gx_device_pdf, last_resource);

 RELOC_PTR(gx_device_pdf, articles);

 RELOC_PTR(gx_device_pdf, Dests);

 RELOC_PTR(gx_device_pdf, global_named_objects);

 RELOC_PTR(gx_device_pdf, local_named_objects);

 RELOC_PTR(gx_device_pdf, NI_stack);

 RELOC_PTR(gx_device_pdf, Namespace_stack);

 RELOC_PTR(gx_device_pdf, font_cache);

 RELOC_PTR(gx_device_pdf, clip_path);

 RELOC_PTR(gx_device_pdf, PageLabels);

 RELOC_PTR(gx_device_pdf, PageLabels_current_label);

 RELOC_PTR(gx_device_pdf, sbstack);

 RELOC_PTR(gx_device_pdf, substream_Resources);

 RELOC_PTR(gx_device_pdf, font3);

 RELOC_PTR(gx_device_pdf, accumulating_substream_resource);

 RELOC_PTR(gx_device_pdf, pres_soft_mask_dict);

 RELOC_PTR(gx_device_pdf, PDFXTrimBoxToMediaBoxOffset.data);

 RELOC_PTR(gx_device_pdf, PDFXBleedBoxToTrimBoxOffset.data);

 RELOC_PTR(gx_device_pdf, Identity_ToUnicode_CMaps[0]);

 RELOC_PTR(gx_device_pdf, Identity_ToUnicode_CMaps[1]);

 RELOC_PTR(gx_device_pdf, vgstack);

 RELOC_PTR(gx_device_pdf, EmbeddedFiles);

 RELOC_PTR(gx_device_pdf, pdf_font_dir);

 RELOC_PTR(gx_device_pdf, ExtensionMetadata);

 RELOC_PTR(gx_device_pdf, PassThroughWriter);

#define r1(i,elt) RELOC_PARAM_STRING_PTR(gx_device_pdf,elt);

        gx_device_pdf_do_param_strings(r1)

#undef r1

#define r1(i,elt) RELOC_CONST_STRING_PTR(gx_device_pdf,elt);

        gx_device_pdf_do_const_strings(r1)

#undef r1

    {

        int i, j;

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

            for (j = 0; j < NUM_RESOURCE_CHAINS; ++j)

                RELOC_PTR(gx_device_pdf, resources[i].chains[j]);

        if (pdev->outline_levels) {

            for (i = 0; i <= pdev->outline_depth; ++i) {

                RELOC_PTR(gx_device_pdf, outline_levels[i].first.action);

                RELOC_PTR(gx_device_pdf, outline_levels[i].last.action);

            }

        }

        for (i = 0; i < pdev->PatternDepth; i++) {

            RELOC_PTR(gx_device_pdf, initial_pattern_states[i]);

        }

    }

 RELOC_PTR(gx_device_pdf, outline_levels);

}

RELOC_PTRS_END

/* Even though device_pdfwrite_finalize is the same as gx_device_finalize, */

/* we need to implement it separately because st_composite_final */

/* declares all 3 procedures as private. */

static void

device_pdfwrite_finalize(const gs_memory_t *cmem, void *vpdev)

{

    gx_device_finalize(cmem, vpdev);

}

/* Driver procedures */

static dev_proc_open_device(pdf_open);

static dev_proc_output_page(pdf_output_page);

static dev_proc_close_device(pdf_close);

/* Driver procedures defined in other files are declared in gdevpdfx.h. */

#ifndef X_DPI

#  define X_DPI 720

#endif

#ifndef Y_DPI

#  define Y_DPI 720

#endif

/* ---------------- Device prototype ---------------- */

static void

pdfwrite_initialize_device_procs(gx_device *dev)

{

    set_dev_proc(dev, open_device, pdf_open);

    set_dev_proc(dev, get_initial_matrix, gx_upright_get_initial_matrix);

    set_dev_proc(dev, output_page, pdf_output_page);

    set_dev_proc(dev, close_device, pdf_close);

    set_dev_proc(dev, map_rgb_color, gx_default_rgb_map_rgb_color);

    set_dev_proc(dev, map_color_rgb, gx_default_rgb_map_color_rgb);

    set_dev_proc(dev, fill_rectangle, gdev_pdf_fill_rectangle);

    set_dev_proc(dev, copy_mono, gdev_pdf_copy_mono);

    set_dev_proc(dev, copy_color, gdev_pdf_copy_color);

    set_dev_proc(dev, get_params, gdev_pdf_get_params);

    set_dev_proc(dev, put_params, gdev_pdf_put_params);

    set_dev_proc(dev, get_page_device, gx_page_device_get_page_device);

    set_dev_proc(dev, fill_path, gdev_pdf_fill_path);

    set_dev_proc(dev, stroke_path, gdev_pdf_stroke_path);

    set_dev_proc(dev, fill_mask, gdev_pdf_fill_mask);

    set_dev_proc(dev, strip_tile_rectangle, gdev_pdf_strip_tile_rectangle);

    set_dev_proc(dev, begin_typed_image, gdev_pdf_begin_typed_image);

    set_dev_proc(dev, get_bits_rectangle, psdf_get_bits_rectangle);

    set_dev_proc(dev, composite, gdev_pdf_composite);

    set_dev_proc(dev, text_begin, gdev_pdf_text_begin);

    set_dev_proc(dev, begin_transparency_group, gdev_pdf_begin_transparency_group);

    set_dev_proc(dev, end_transparency_group, gdev_pdf_end_transparency_group);

    set_dev_proc(dev, begin_transparency_mask ,gdev_pdf_begin_transparency_mask);

    set_dev_proc(dev, end_transparency_mask, gdev_pdf_end_transparency_mask);

    set_dev_proc(dev, fill_rectangle_hl_color, gdev_pdf_fill_rectangle_hl_color);

    set_dev_proc(dev, include_color_space, gdev_pdf_include_color_space);

    set_dev_proc(dev, fillpage, gdev_pdf_fillpage);

    set_dev_proc(dev, dev_spec_op, gdev_pdf_dev_spec_op);

    set_dev_proc(dev, fill_stroke_path, gdev_pdf_fill_stroke_path);

}

#define PDF_DEVICE_NAME "pdfwrite"

#define PDF_DEVICE_IDENT gs_pdfwrite_device

#define PDF_DEVICE_MaxInlineImageSize 4000

#define PDF_FOR_OPDFREAD 0

#define PDF_FOR_EPS2WRITE 0

#include "gdevpdfb.h"

#undef PDF_DEVICE_NAME

#undef PDF_DEVICE_IDENT

#undef PDF_DEVICE_MaxInlineImageSize

#undef PDF_FOR_OPDFREAD

#define PDF_DEVICE_NAME "ps2write"

#define PDF_DEVICE_IDENT gs_ps2write_device

#define PDF_DEVICE_MaxInlineImageSize max_long

#define PDF_FOR_OPDFREAD 1

#define PDF_FOR_EPS2WRITE 0

#include "gdevpdfb.h"

#undef PDF_DEVICE_NAME

#undef PDF_DEVICE_IDENT

#undef PDF_DEVICE_MaxInlineImageSize

#undef PDF_FOR_OPDFREAD

#undef PDF_FOR_EPS2WRITE

#define PDF_DEVICE_NAME "eps2write"

#define PDF_DEVICE_IDENT gs_eps2write_device

#define PDF_DEVICE_MaxInlineImageSize max_long

#define PDF_FOR_OPDFREAD 1

#define PDF_FOR_EPS2WRITE 1

#include "gdevpdfb.h"

#undef PDF_DEVICE_NAME

#undef PDF_DEVICE_IDENT

#undef PDF_DEVICE_MaxInlineImageSize

#undef PDF_FOR_OPDFREAD

#undef PDF_FOR_EPS2WRITE

/* ---------------- Device open/close ---------------- */

/* Close and remove temporary files. */

static int

pdf_close_temp_file(gx_device_pdf *pdev, pdf_temp_file_t *ptf, int code)

{

    int err = 0;

    gp_file *file = ptf->file;

    /*

     * ptf->strm == 0 or ptf->file == 0 is only possible if this procedure

     * is called to clean up during initialization failure, but ptf->strm

     * might not be open if it was finalized before the device was closed.

     */

    if (ptf->strm) {

        if (s_is_valid(ptf->strm)) {

            sflush(ptf->strm);

            /* Prevent freeing the stream from closing the file. */

            ptf->strm->file = 0;

        } else

            ptf->file = file = 0; /* file was closed by finalization */

        gs_free_object(pdev->pdf_memory, ptf->strm_buf,

                       "pdf_close_temp_file(strm_buf)");

        ptf->strm_buf = 0;

        gs_free_object(pdev->pdf_memory, ptf->strm,

                       "pdf_close_temp_file(strm)");

        ptf->strm = 0;

    }

    if (file) {

        err = gp_ferror(file) | gp_fclose(file);

        unlink(ptf->file_name);

        ptf->file = 0;

    }

    ptf->save_strm = 0;

    return

        (code < 0 ? code : err != 0 ? gs_note_error(gs_error_ioerror) : code);

}

static int

pdf_close_files(gx_device_pdf * pdev, int code)

{

    code = pdf_close_temp_file(pdev, &pdev->pictures, code);

    code = pdf_close_temp_file(pdev, &pdev->streams, code);

    code = pdf_close_temp_file(pdev, &pdev->asides, code);

    return pdf_close_temp_file(pdev, &pdev->xref, code);

}

/* Reset the state of the current page. */

static void

pdf_reset_page(gx_device_pdf * pdev)

{

    pdev->page_dsc_info = gs_pdfwrite_device.page_dsc_info;

    pdev->contents_id = 0;

    pdf_reset_graphics(pdev);

    pdev->procsets = NoMarks;

    memset(pdev->cs_Patterns, 0, sizeof(pdev->cs_Patterns));  /* simplest to create for each page */

    pdf_reset_text_page(pdev->text);

    pdf_remember_clip_path(pdev, 0);

    pdev->clip_path_id = pdev->no_clip_path_id;

}

/* Open a temporary file, with or without a stream. */

static int

pdf_open_temp_file(gx_device_pdf *pdev, pdf_temp_file_t *ptf)

{

    char fmode[4];

    if (strlen(gp_fmode_binary_suffix) > 2)

        return_error(gs_error_invalidfileaccess);

    strcpy(fmode, "w+");

    strcat(fmode, gp_fmode_binary_suffix);

    ptf->file = gp_open_scratch_file(pdev->memory,

                                     gp_scratch_file_name_prefix,

                                     ptf->file_name,

                                     fmode);

    if (ptf->file == 0)

        return_error(gs_error_invalidfileaccess);

    return 0;

}

static int

pdf_open_temp_stream(gx_device_pdf *pdev, pdf_temp_file_t *ptf)

{

    int code = pdf_open_temp_file(pdev, ptf);

    if (code < 0)

        return code;

    ptf->strm = s_alloc(pdev->pdf_memory, "pdf_open_temp_stream(strm)");

    if (ptf->strm == 0)

        return_error(gs_error_VMerror);

    ptf->strm_buf = gs_alloc_bytes(pdev->pdf_memory, sbuf_size,

                                   "pdf_open_temp_stream(strm_buf)");

    if (ptf->strm_buf == 0) {

        gs_free_object(pdev->pdf_memory, ptf->strm,

                       "pdf_open_temp_stream(strm)");

        ptf->strm = 0;

        return_error(gs_error_VMerror);

    }

    swrite_file(ptf->strm, ptf->file, ptf->strm_buf, sbuf_size);

    return 0;

}

/* Initialize the IDs allocated at startup. */

void

pdf_initialize_ids(gx_device_pdf * pdev)

{

    gs_param_string nstr;

    pdev->next_id = pdev->FirstObjectNumber;

    /* Initialize the Catalog. */

    param_string_from_string(nstr, "{Catalog}");

    pdf_create_named_dict(pdev, &nstr, &pdev->Catalog, 0L);

    /* Initialize the Info dictionary. */

    param_string_from_string(nstr, "{DocInfo}");

    pdf_create_named_dict(pdev, &nstr, &pdev->Info, 0L);

    {

        char buf[PDF_MAX_PRODUCER];

        pdf_store_default_Producer(buf);

        if (pdev->CompatibilityLevel <= 1.7)

            cos_dict_put_c_key_string(pdev->Info, "/Producer", (byte *)buf,

                                  strlen(buf));

    }

    /*

     * Acrobat Distiller sets CreationDate and ModDate to the current

     * date and time, rather than (for example) %%CreationDate from the

     * PostScript file.  We think this is wrong, but we do the same.

     */

    if (!pdev->OmitInfoDate)

    {

        struct tm tms;

        time_t t;

        char buf[1+2+4+2+2+2+2+2+1+2+1+2+1+1+1]; /* (D:yyyymmddhhmmssZhh'mm')\0 */

        int timeoffset;

        char timesign;

#ifdef CLUSTER

        memset(&t, 0, sizeof(t));

        memset(&tms, 0, sizeof(tms));

        timesign = 'Z';

        timeoffset = 0;

#else

        time(&t);

        tms = *gmtime(&t);

        tms.tm_isdst = -1;

        timeoffset = (int)difftime(t, mktime(&tms)); /* tz+dst in seconds */

        timesign = (timeoffset == 0 ? 'Z' : timeoffset < 0 ? '-' : '+');

        timeoffset = any_abs(timeoffset) / 60;

        tms = *localtime(&t);

#endif

        gs_snprintf(buf, sizeof(buf), "(D:%04d%02d%02d%02d%02d%02d%c%02d\'%02d\')",

            tms.tm_year + 1900, tms.tm_mon + 1, tms.tm_mday,

            tms.tm_hour, tms.tm_min, tms.tm_sec,

            timesign, timeoffset / 60, timeoffset % 60);

        cos_dict_put_c_key_string(pdev->Info, "/CreationDate", (byte *)buf,

                                  strlen(buf));

        cos_dict_put_c_key_string(pdev->Info, "/ModDate", (byte *)buf,

                                  strlen(buf));

    }

    /* Allocate the root of the pages tree. */

    pdf_create_named_dict(pdev, NULL, &pdev->Pages, 0L);

}

static int

pdf_compute_fileID(gx_device_pdf * pdev)

{

    /* We compute a file identifier when beginning a document

       to allow its usage with PDF encryption. Due to that,

       in contradiction to the Adobe recommendation, our

       ID doesn't depend on the document size.

    */

    gs_memory_t *mem = pdev->pdf_memory;

    stream *strm = pdev->strm;

    uint ignore;

    int code;

    stream *s = s_MD5E_make_stream(mem, pdev->fileID, sizeof(pdev->fileID));

    long secs_ns[2];

    uint KeyLength = pdev->KeyLength;

    if (s == NULL)

        return_error(gs_error_VMerror);

    pdev->KeyLength = 0; /* Disable encryption. Not so important though. */

#ifdef CLUSTER

    secs_ns[0] = 0;

    secs_ns[1] = 0;

#else

    gp_get_realtime(secs_ns);

#endif

    sputs(s, (byte *)secs_ns, sizeof(secs_ns), &ignore);

#ifdef CLUSTER

    /* Don't have the ID's vary by filename output in the cluster testing.

     * This prevents us comparing gs to gpdl results, and makes it harder

     * to manually reproduce results. */

    sputs(s, (const byte *)"ClusterTest.pdf", strlen("ClusterTest.pdf"), &ignore);

#else

    sputs(s, (const byte *)pdev->fname, strlen(pdev->fname), &ignore);

#endif

    pdev->strm = s;

    code = cos_dict_elements_write(pdev->Info, pdev);

    pdev->strm = strm;

    pdev->KeyLength = KeyLength;

    if (code < 0)

        return code;

    /* Generally we would call s_close_filters() here in order to free the data buffer

     * associated with the MD5 filter, but the data buffer we passed in to s_MD5E_make_stream()

     * is part of the device structure, so we must *NOT* free that buffer. Therefore we must

     * instead call sclose(). This confusion over ownership of the stream buffers causes

     * a lot of problems......

     */

    sclose(s);

    gs_free_object(mem, s, "pdf_compute_fileID");

    return 0;

}

static const byte pad[32] = { 0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41,

                               0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08,

                               0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80,

                               0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A};

static inline void

copy_padded(byte buf[32], gs_param_string *str)

{

    memcpy(buf, str->data, min(str->size, 32));

    if (32 > str->size)

        memcpy(buf + str->size, pad, 32 - str->size);

}

static void

Adobe_magic_loop_50(byte digest[16], int key_length)

{

    gs_md5_state_t md5;

    int i;

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

        gs_md5_init(&md5);

        gs_md5_append(&md5, digest, key_length);

        gs_md5_finish(&md5, digest);

    }

}

static void

Adobe_magic_loop_19(byte *data, int data_size, const byte *key, int key_size)

{

    stream_arcfour_state sarc4;

    byte key_buf[16];

    int i, j;

    for (i = 1; i <= 19; i++) {

        for (j = 0; j < key_size; j++)

            key_buf[j] = key[j] ^ (byte)i;

        s_arcfour_set_key(&sarc4, key_buf, key_size);

        s_arcfour_process_buffer(&sarc4, data, data_size);

    }

}

static int

pdf_compute_encryption_data(gx_device_pdf * pdev)

{

    gs_md5_state_t md5;

    byte digest[16], buf[32], t;

    stream_arcfour_state sarc4;

    if (pdev->PDFX && pdev->KeyLength != 0) {

        emprintf(pdev->memory,

                 "Encryption is not allowed in a PDF/X doucment.\n");

        return_error(gs_error_rangecheck);

    }

    if (pdev->KeyLength == 0)

        pdev->KeyLength = 40;

    if (pdev->EncryptionV == 0 && pdev->KeyLength == 40)

        pdev->EncryptionV = 1;

    if (pdev->EncryptionV == 0 && pdev->KeyLength > 40)

        pdev->EncryptionV = 2;

    if (pdev->EncryptionV > 1 && pdev->CompatibilityLevel < 1.4) {

        emprintf(pdev->memory, "PDF 1.3 only supports 40 bits keys.\n");

        return_error(gs_error_rangecheck);

    }

    if (pdev->EncryptionR == 0)

        pdev->EncryptionR = 2;

    if (pdev->EncryptionR < 2 || pdev->EncryptionR > 3) {

        emprintf(pdev->memory,

                 "Encryption revisions 2 and 3 are only supported.\n");

        return_error(gs_error_rangecheck);

    }

    if (pdev->EncryptionR > 2 && pdev->CompatibilityLevel < 1.4) {

        emprintf(pdev->memory,

                 "PDF 1.3 only supports the encryption revision 2.\n");

        return_error(gs_error_rangecheck);

    }

    if (pdev->KeyLength > 128) {

        emprintf(pdev->memory,

                 "The maximal length of PDF encryption key is 128 bits.\n");

        return_error(gs_error_rangecheck);

    }

    if (pdev->KeyLength % 8) {

        emprintf(pdev->memory,

                 "PDF encryption key length must be a multiple of 8.\n");

        return_error(gs_error_rangecheck);

    }

    if (pdev->EncryptionR == 2 &&

        ((pdev->Permissions & (0xFFFFFFC3)) != 0xFFFFFFC0)) {

        emprintf(pdev->memory,

                 "Some of Permissions are not allowed with R=2.\n");

        return_error(gs_error_rangecheck);

    }

    if (pdev->EncryptionV == 2 && pdev->EncryptionR == 2 && pdev->KeyLength > 40) {

        emprintf(pdev->memory, "Encryption version 2 revision 2 with "

                 "KeyLength > 40 appears incompatible to some viewers. With "

                 "long keys use revision 3.\n");

        return_error(gs_error_rangecheck);

    }

    /* Compute O : */

    gs_md5_init(&md5);

    copy_padded(buf, &pdev->OwnerPassword);

    gs_md5_append(&md5, buf, sizeof(buf));

    gs_md5_finish(&md5, digest);

    if (pdev->EncryptionR == 3)

        Adobe_magic_loop_50(digest, pdev->KeyLength / 8);

    copy_padded(buf, &pdev->UserPassword);

    s_arcfour_set_key(&sarc4, digest, pdev->KeyLength / 8);

    s_arcfour_process_buffer(&sarc4, buf, sizeof(buf));

    if (pdev->EncryptionR == 3)

        Adobe_magic_loop_19(buf, sizeof(buf), digest, pdev->KeyLength / 8);

    memcpy(pdev->EncryptionO, buf, sizeof(pdev->EncryptionO));

    /* Compute Key : */

    gs_md5_init(&md5);

    copy_padded(buf, &pdev->UserPassword);

    gs_md5_append(&md5, buf, sizeof(buf));

    gs_md5_append(&md5, pdev->EncryptionO, sizeof(pdev->EncryptionO));

    t = (byte)(pdev->Permissions >>  0);  gs_md5_append(&md5, &t, 1);

    t = (byte)(pdev->Permissions >>  8);  gs_md5_append(&md5, &t, 1);

    t = (byte)(pdev->Permissions >> 16);  gs_md5_append(&md5, &t, 1);

    t = (byte)(pdev->Permissions >> 24);  gs_md5_append(&md5, &t, 1);

    gs_md5_append(&md5, pdev->fileID, sizeof(pdev->fileID));

    if (pdev->EncryptionR == 3)

        if (!pdev->EncryptMetadata) {

            const byte v[4] = {0xFF, 0xFF, 0xFF, 0xFF};

            gs_md5_append(&md5, v, 4);

        }

    gs_md5_finish(&md5, digest);

    if (pdev->EncryptionR == 3)

        Adobe_magic_loop_50(digest, pdev->KeyLength / 8);

    memcpy(pdev->EncryptionKey, digest, pdev->KeyLength / 8);

    /* Compute U : */

    if (pdev->EncryptionR == 3) {

        gs_md5_init(&md5);

        gs_md5_append(&md5, pad, sizeof(pad));

        gs_md5_append(&md5, pdev->fileID, sizeof(pdev->fileID));

        gs_md5_finish(&md5, digest);

        s_arcfour_set_key(&sarc4, pdev->EncryptionKey, pdev->KeyLength / 8);

        s_arcfour_process_buffer(&sarc4, digest, sizeof(digest));

        Adobe_magic_loop_19(digest, sizeof(digest), pdev->EncryptionKey, pdev->KeyLength / 8);

        memcpy(pdev->EncryptionU, digest, sizeof(digest));

        memcpy(pdev->EncryptionU + sizeof(digest), pad,

                sizeof(pdev->EncryptionU) - sizeof(digest));

    } else {

        memcpy(pdev->EncryptionU, pad, sizeof(pdev->EncryptionU));

        s_arcfour_set_key(&sarc4, pdev->EncryptionKey, pdev->KeyLength / 8);

        s_arcfour_process_buffer(&sarc4, pdev->EncryptionU, sizeof(pdev->EncryptionU));

    }

    return 0;

}

#ifdef __DECC

/* The ansi alias rules are violated in this next routine.  Tell the compiler

   to ignore this.

 */

#pragma optimize save

#pragma optimize ansi_alias=off

#endif

/*

 * Update the color mapping procedures after setting ProcessColorModel.

 *

 * The 'index' value indicates the ProcessColorModel.

 *  0 = DeviceGray

 *  1 = DeviceRGB

 *  2 = DeviceCMYK

 *  3 = DeviceN (treat like CMYK except for color model name)

 */

void

pdf_set_process_color_model(gx_device_pdf * pdev, int index)

{

    const static gx_device_color_info pcm_color_info[] = {

        dci_values(1, 8, 255, 0, 256, 0),   /* Gray */

        dci_values(3, 24, 255, 255, 256, 256),    /* RGB */

        dci_values(4, 32, 255, 255, 256, 256),    /* CMYK */

        dci_values(4, 32, 255, 255, 256, 256) /* Treat DeviceN like CMYK */

    };

    /* Don't blow away the ICC information */

    pdev->pcm_color_info_index = index;

    pdev->color_info = pcm_color_info[index];

    /* Set the separable and linear shift, masks, bits. */

    set_linear_color_bits_mask_shift((gx_device *)pdev);

    pdev->color_info.separable_and_linear = GX_CINFO_SEP_LIN;

    /*

     * The conversion from PS to PDF should be transparent as possible.

     * Particularly it should not change representation of colors.

     * Perhaps due to historical reasons the source color information

     * sometimes isn't accessible from device methods, and

     * therefore they perform a mapping of colors to

     * an output color model. Here we handle some color models,

     * which were selected almost due to antique reasons.

     */

    switch (index) {

        case 0:   /* DeviceGray */

            set_dev_proc(pdev, map_rgb_color, gx_default_gray_map_rgb_color);

            set_dev_proc(pdev, map_color_rgb, gx_default_gray_map_color_rgb);

            set_dev_proc(pdev, map_cmyk_color, NULL);

            set_dev_proc(pdev, get_color_mapping_procs,

                        gx_default_DevGray_get_color_mapping_procs);

            set_dev_proc(pdev, get_color_comp_index,

                        gx_default_DevGray_get_color_comp_index);

            set_dev_proc(pdev, encode_color, gx_default_gray_encode);

            set_dev_proc(pdev, decode_color, gx_default_decode_color);

            break;

        case 1:   /* DeviceRGB */

            set_dev_proc(pdev, map_rgb_color, gx_default_rgb_map_rgb_color);

            set_dev_proc(pdev, map_color_rgb, gx_default_rgb_map_color_rgb);

            set_dev_proc(pdev, map_cmyk_color, NULL);

            set_dev_proc(pdev, get_color_mapping_procs,

                        gx_default_DevRGB_get_color_mapping_procs);

            set_dev_proc(pdev, get_color_comp_index,

                        gx_default_DevRGB_get_color_comp_index);

            set_dev_proc(pdev, encode_color, gx_default_rgb_map_rgb_color);

            set_dev_proc(pdev, decode_color, gx_default_rgb_map_color_rgb);

            break;

        case 3:   /* DeviceN - treat like DeviceCMYK except for cm_name */

            pdev->color_info.cm_name = "DeviceN";

        case 2:   /* DeviceCMYK */

            set_dev_proc(pdev, map_rgb_color, NULL);

            set_dev_proc(pdev, map_color_rgb, cmyk_8bit_map_color_rgb);

           /* possible problems with aliassing on next statement */

            set_dev_proc(pdev, map_cmyk_color, cmyk_8bit_map_cmyk_color);

            set_dev_proc(pdev, get_color_mapping_procs,

                        gx_default_DevCMYK_get_color_mapping_procs);

            set_dev_proc(pdev, get_color_comp_index,

                        gx_default_DevCMYK_get_color_comp_index);

            set_dev_proc(pdev, encode_color, cmyk_8bit_map_cmyk_color);

            set_dev_proc(pdev, decode_color, cmyk_8bit_map_color_cmyk);

            break;

        default:  /* can't happen - see the call from gdev_pdf_put_params. */

            DO_NOTHING;

    }

}

#ifdef __DECC

#pragma optimize restore

#endif

/*

 * Reset the text state parameters to initial values.

 */

void

pdf_reset_text(gx_device_pdf * pdev)

{

    /* we need to flush the text buffer, in case we have (eg) Tr set,

     * but have reset it to 0 for the current (buffered) text. If we restore to a

     * graphics state which also has Tr 0 then we won't ever write out the change.

     * I suspect this can theoretically happen with other graphics state values too

     * See PCL file enter.test.

     */

    sync_text_state(pdev);

    pdf_reset_text_state(pdev->text);

}

/* Open the device. */

static int

pdf_open(gx_device * dev)

{

    gx_device_pdf *pdev = (gx_device_pdf *) dev;

    gs_memory_t *mem = pdev->pdf_memory = gs_memory_stable(pdev->memory);

    int code;

    pdev->InOutputPage = false;

    if ((code = pdf_open_temp_file(pdev, &pdev->xref)) < 0 ||

        (code = pdf_open_temp_stream(pdev, &pdev->asides)) < 0 ||

        (code = pdf_open_temp_stream(pdev, &pdev->streams)) < 0 ||

        (code = pdf_open_temp_stream(pdev, &pdev->pictures)) < 0

        )

        goto fail;

    code = gdev_vector_open_file((gx_device_vector *) pdev, sbuf_size);

    if (code < 0)

        goto fail;

    while (pdev->child) {

        /* we've been subclassed by gdev_vector_open_file. Ordinarily we would want to call

         * open_file last, in order to make sure that we don't care if we are subclessed

         * but we want to set up the stream, so we can't do that....

         */

        pdev = (gx_device_pdf *)pdev->child;

    }

    if (pdev->ComputeDocumentDigest) {

        stream *s = s_MD5C_make_stream(pdev->pdf_memory, pdev->strm);

        if (s == NULL)

            return_error(gs_error_VMerror);

        pdev->strm = s;

    }

    gdev_vector_init((gx_device_vector *) pdev);

#ifdef CLUSTER

    memset(&pdev->uuid_time, 0, sizeof(pdev->uuid_time));

#else

    gp_get_realtime(pdev->uuid_time);

#endif

    pdev->vec_procs = &pdf_vector_procs;

    pdev->fill_options = pdev->stroke_options = gx_path_type_optimize;

    /* Set in_page so the vector routines won't try to call */

    /* any vector implementation procedures. */

    pdev->in_page = true;

    /*

     * pdf_initialize_ids allocates some (global) named objects, so we must

     * initialize the named objects dictionary now.

     */

    pdev->local_named_objects =

        pdev->global_named_objects =

        cos_dict_alloc(pdev, "pdf_open(global_named_objects)");

    /* Initialize internal structures that don't have IDs. */

    pdev->NI_stack = cos_array_alloc(pdev, "pdf_open(NI stack)");

    pdev->vgstack = (pdf_viewer_state *)gs_alloc_bytes(pdev->pdf_memory, 11 * sizeof(pdf_viewer_state), "pdf_open(graphics state stack)");

    if (pdev->vgstack == 0) {

        code = gs_error_VMerror;

        goto fail;

    }

    memset(pdev->vgstack, 0x00, 11 * sizeof(pdf_viewer_state));

    pdev->vgstack_size = 11;

    pdev->Namespace_stack = cos_array_alloc(pdev, "pdf_open(Namespace stack)");

    pdf_initialize_ids(pdev);

    code = pdf_compute_fileID(pdev);

    if (code < 0)

        goto fail;

    if (pdev->OwnerPassword.size > 0) {

        code = pdf_compute_encryption_data(pdev);

        if (code < 0)

            goto fail;

    } else if(pdev->UserPassword.size > 0) {

        emprintf(pdev->memory,

                 "User password is specified. Need an Owner password or both.\n");

        return_error(gs_error_rangecheck);

    } else if (pdev->KeyLength) {

        emprintf(pdev->memory,

                 "Can't accept encryption options without a password.\n");

        return_error(gs_error_rangecheck);

    }

    /* Now create a new dictionary for the local named objects. */

    pdev->local_named_objects =

        cos_dict_alloc(pdev, "pdf_open(local_named_objects)");

    pdev->outlines_id = 0;

    pdev->next_page = 0;

    pdev->text = pdf_text_data_alloc(mem);

    pdev->sbstack_size = pdev->vgstack_size; /* Overestimated a few. */

    pdev->sbstack = gs_alloc_struct_array(mem, pdev->sbstack_size, pdf_substream_save,

                                 &st_pdf_substream_save_element, "pdf_open");

    pdev->pages =

        gs_alloc_struct_array(mem, initial_num_pages, pdf_page_t,

                              &st_pdf_page_element, "pdf_open(pages)");

    if (pdev->text == 0 || pdev->pages == 0 || pdev->sbstack == 0) {

        code = gs_error_VMerror;

        goto fail;

    }

    memset(pdev->sbstack, 0, pdev->sbstack_size * sizeof(pdf_substream_save));

    memset(pdev->pages, 0, initial_num_pages * sizeof(pdf_page_t));

    pdev->num_pages = initial_num_pages;

    {

        int i, j;

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

            for (j = 0; j < NUM_RESOURCE_CHAINS; ++j)

                pdev->resources[i].chains[j] = 0;

    }

    pdev->outline_levels = (pdf_outline_level_t *)gs_alloc_bytes(mem, INITIAL_MAX_OUTLINE_DEPTH * sizeof(pdf_outline_level_t), "outline_levels array");

    memset(pdev->outline_levels, 0x00, INITIAL_MAX_OUTLINE_DEPTH * sizeof(pdf_outline_level_t));

    pdev->max_outline_depth = INITIAL_MAX_OUTLINE_DEPTH;

    pdev->outline_levels[0].first.id = 0;

    pdev->outline_levels[0].left = max_int;

    pdev->outline_levels[0].first.action = 0;

    pdev->outline_levels[0].last.action = 0;

    pdev->outline_depth = 0;

    pdev->closed_outline_depth = 0;

    pdev->outlines_open = 0;

    pdev->articles = 0;

    pdev->Dests = 0;

    pdev->EmbeddedFiles = 0;

    /* {global,local}_named_objects was initialized above */

    pdev->PageLabels = 0;

    pdev->PageLabels_current_page = 0;

    pdev->PageLabels_current_label = 0;

    pdev->pte = NULL;

    pdf_reset_page(pdev);

    pdev->BBox.p.x = pdev->width;

    pdev->BBox.p.y = pdev->height;

    pdev->BBox.q.x = 0;

    pdev->BBox.q.y = 0;

    if(pdev->UseCIEColor) {

        emprintf(pdev->memory, "\n\nUse of -dUseCIEColor detected!\nSince the release of version 9.11 of Ghostscript we recommend you do not set\n-dUseCIEColor with the pdfwrite/ps2write device family.\n\n");

    }

    /* Build a font cache for pdfwrite, see 'pdf_free_pdf_font_cache' for why we need this. */

    pdev->pdf_font_dir = gs_font_dir_alloc2(pdev->memory->stable_memory, pdev->memory->non_gc_memory);

    if (pdev->pdf_font_dir == 0) {

        code = gs_error_VMerror;

        goto fail;

    }

    /* If we have a gs_lib_ctx, then we need to copy these function pointers from it (we are in PostScript).

     * We can't fill them in otherwise, as the functions are declared static in gsfont.c.

     * If we don't have one then we are in PCL/PXL/XPS, and cannot copy these function pointers. Fortunately

     * we don't need them for fonts in these languages.

     */

    if (pdev->memory->gs_lib_ctx->font_dir) {

        pdev->pdf_font_dir->ccache.mark_glyph = pdev->memory->gs_lib_ctx->font_dir->ccache.mark_glyph;

        pdev->pdf_font_dir->global_glyph_code = pdev->memory->gs_lib_ctx->font_dir->global_glyph_code;

    }

    /* gs_opendevice() sets the device 'is_open' flag which is now of course the parent. We

     * still need to set the child's flag, we'll do it here to avoid setting it if we get any

     * failures, as those will also leave the parent not open.

     */

    if (pdev->parent)

        pdev->is_open = true;

    return 0;

  fail:

    gdev_vector_close_file((gx_device_vector *) pdev);

    return pdf_close_files(pdev, code);

}

/* Detect I/O errors. */

static int

pdf_ferror(gx_device_pdf *pdev)

{

    gp_fflush(pdev->file);

    gp_fflush(pdev->xref.file);

    if (pdev->strm->file != NULL)

        sflush(pdev->strm);

    if (pdev->asides.strm->file != NULL)

        sflush(pdev->asides.strm);

    if (pdev->streams.strm->file != NULL)

        sflush(pdev->streams.strm);

    if (pdev->pictures.strm->file != NULL)

        sflush(pdev->pictures.strm);

    return gp_ferror(pdev->file) || gp_ferror(pdev->xref.file) ||

        gp_ferror(pdev->asides.file) || gp_ferror(pdev->streams.file) ||

        gp_ferror(pdev->pictures.file);

}

/* Compute the dominant text orientation of a page. */

static int

pdf_dominant_rotation(const pdf_text_rotation_t *ptr)

{

    int i, imax = -1;

    long max_count = 0;

    static const int angles[] = { pdf_text_rotation_angle_values };

    for (i = 0; i < countof(ptr->counts); ++i) {

        long count = ptr->counts[i];

        if (count > max_count)

            imax = i, max_count = count;

    }

    return (imax < 0 ? imax : angles[imax]);

}

/* Print a Rotate command, if requested and possible. */

static void

pdf_print_orientation(gx_device_pdf * pdev, pdf_page_t *page)

{

    stream *s = pdev->strm;

    int dsc_orientation = -1;

    const pdf_page_dsc_info_t *ppdi;

    if (pdev->params.AutoRotatePages == arp_None)

        return; /* Not requested. */

    ppdi = (page != NULL ? &page->dsc_info : &pdev->doc_dsc_info);

    /* Determine DSC orientation : */