10 files changed, 1801 insertions, 53 deletions

diff --git a/gs/base/gdevpdfb.h b/gs/base/gdevpdfb.h
index 48b85ab28..13babb957 100644
--- a/gs/base/gdevpdfb.h
+++ b/gs/base/gdevpdfb.h
@@ -272,8 +272,11 @@ const gx_device_pdf PDF_DEVICE_IDENT =
  true,                          /* IsDistiller (true even for ps2write!) */
  !PDF_FOR_OPDFREAD,             /* PreserveSMask */
  !PDF_FOR_OPDFREAD,             /* PreserveTrMode */
- false,                         /* NoT3CCITT */
- false,                         /* Linearise */
- 0,                            /* FirstPage */
- 0                             /* LastPage */
+ false,                 /* NoT3CCITT */
+ true,                 /* UseOldColor */
+ false,                 /* Linearise */
+ 0,                     /* FirstPage (from the command line) */
+ 0,                     /* LastPage (from the command line) */
+ 0,                     /* pointer to resourceusage */
+ 0                      /* Size of resourceusage */
 };
diff --git a/gs/base/gdevpdfg.c b/gs/base/gdevpdfg.c
index f71f94554..d5f84cb1e 100644
--- a/gs/base/gdevpdfg.c
+++ b/gs/base/gdevpdfg.c
@@ -36,6 +36,7 @@
 #include "gdevpdfg.h"
 #include "gdevpdfo.h"
 #include "gsicc_manage.h"
+#include "gsicc_cache.h"
 
 /* ---------------- Miscellaneous ---------------- */
 
@@ -292,6 +293,502 @@ is_pattern2_allowed_in_strategy(gx_device_pdf * pdev, const gx_drawing_color *pd
     return is_cspace_allowed_in_strategy(pdev, csi);
 }
 
+
+static int write_color_as_process(gx_device_pdf * pdev, const gs_imager_state * pis, const gs_color_space *pcs,
+                        const gx_drawing_color *pdc, bool *used_process_color,
+                        const psdf_set_color_commands_t *ppscc, gs_client_color *pcc)
+{
+    int code, i;
+    gsicc_link_t *icc_link;
+    gsicc_rendering_param_t rendering_params;
+    frac conc[GS_CLIENT_COLOR_MAX_COMPONENTS];
+    unsigned short Converted[GS_CLIENT_COLOR_MAX_COMPONENTS];
+    unsigned short Source[GS_CLIENT_COLOR_MAX_COMPONENTS];
+    gs_color_space_index csi, csi2;
+
+    csi = csi2 = gs_color_space_get_index(pcs);
+
+    if (csi == gs_color_space_index_Indexed) {
+        gs_color_space *pcs2 = pcs->base_space;
+        csi2 = gs_color_space_get_index(pcs2);
+    }
+    if (csi2 == gs_color_space_index_DeviceN ||
+        csi2 == gs_color_space_index_Separation) {
+
+        const char *command = NULL;
+
+        memset (&conc, 0x00, sizeof(frac) * GS_CLIENT_COLOR_MAX_COMPONENTS);
+        pcs->type->concretize_color(pcc, pcs, conc, pis, (gx_device *)pdev);
+        csi = gs_color_space_get_index(pcs->base_space);
+        if (csi != gs_color_space_index_ICC) {
+            *used_process_color = true;
+            switch (pdev->color_info.num_components) {
+                case 1:
+                    command = ppscc->setgray;
+                    break;
+                case 3:
+                    command = ppscc->setrgbcolor;
+                    break;
+                case 4:
+                    command = ppscc->setcmykcolor;
+                    break;
+            }
+            pprintg1(pdev->strm, "%g", psdf_round((conc[0] / (double)65535), 255, 8));
+            for (i = 1; i < pdev->color_info.num_components; i++) {
+                pprintg1(pdev->strm, " %g", psdf_round((conc[i] / (double)65535), 255, 8));
+            }
+            pprints1(pdev->strm, " %s\n", command);
+            return 0;
+        } else {
+            pcs = pcs->base_space;
+            for (i=0;i<pdev->color_info.num_components;i++)
+                Source[i] = (unsigned short)(conc[i]);
+        }
+    }
+    if (csi == gs_color_space_index_Indexed) {
+        memset (&conc, 0x00, sizeof(frac) * GS_CLIENT_COLOR_MAX_COMPONENTS);
+        pcs->type->concretize_color(pcc, pcs, conc, pis, (gx_device *)pdev);
+        pcs = pcs->base_space;
+        for (i=0;i<pcs->cmm_icc_profile_data->num_comps;i++)
+            Source[i] = (unsigned short)(conc[i]);
+    } else {
+        if (csi2 >= gs_color_space_index_CIEDEFG &&
+            csi2 <= gs_color_space_index_CIEA) {
+                int j = 0;
+
+                switch (csi2) {
+                    case gs_color_space_index_CIEDEFG:
+                        j += 1;
+                    case gs_color_space_index_CIEDEF:
+                    case gs_color_space_index_CIEABC:
+                        j += 2;
+                    case gs_color_space_index_CIEA:
+                        j += 1;
+                        break;
+                    default:    /* can't happen, simply silences compiler warnings */
+                        break;
+                }
+                for (i=0;i<j;i++)
+                    Source[i] = (unsigned short)(pcc->paint.values[i] * 65535);
+        } else {
+            if (csi2 != gs_color_space_index_DeviceN &&
+                csi2 != gs_color_space_index_Separation) {
+                for (i=0;i<pcs->cmm_icc_profile_data->num_comps;i++)
+                    Source[i] = (unsigned short)(pcc->paint.values[i] * 65535);
+            }
+        }
+    }
+    rendering_params.black_point_comp = pis->blackptcomp;
+    rendering_params.graphics_type_tag = pdev->graphics_type_tag;
+    rendering_params.override_icc = false;
+    rendering_params.preserve_black = gsBKPRESNOTSPECIFIED;
+    rendering_params.rendering_intent = pis->renderingintent;
+    rendering_params.cmm = gsCMM_DEFAULT;
+    icc_link = gsicc_get_link(pis, (gx_device *)pdev, pcs,
+                                      NULL, &rendering_params,
+                                      pis->memory);
+    (icc_link->procs.map_color)((gx_device *)pdev, icc_link, Source, Converted, 2);
+    gsicc_release_link(icc_link);
+    for (i = 0;i < pdev->color_info.num_components;i++)
+        pcc->paint.values[i] = Source[i] / 65535.0f;
+    code = psdf_set_color((gx_device_vector *)pdev, pdc, ppscc);
+    if (code < 0)
+        return code;
+    *used_process_color = true;
+    return 0;
+}
+
+static int write_color_unchanged(gx_device_pdf * pdev, const gs_imager_state * pis,
+                          gs_client_color *pcc, gx_hl_saved_color *current,
+                          gx_hl_saved_color * psc, const psdf_set_color_commands_t *ppscc,
+                          bool *used_process_color, const gs_color_space *pcs,
+                          const gx_drawing_color *pdc)
+{
+    gs_color_space_index csi, csi2;
+    int code;
+    const char *command = NULL;
+
+    csi = csi2 = gs_color_space_get_index(pcs);
+    if (csi == gs_color_space_index_ICC) {
+        csi2 = gsicc_get_default_type(pcs->cmm_icc_profile_data);
+    }
+
+    switch (csi2) {
+        case gs_color_space_index_DeviceGray:
+            command = ppscc->setgray;
+            code = pdf_write_ccolor(pdev, pis, pcc);
+            if (code < 0)
+                return code;
+            pprints1(pdev->strm, " %s\n", command);
+            break;
+        case gs_color_space_index_DeviceRGB:
+            command = ppscc->setrgbcolor;
+            code = pdf_write_ccolor(pdev, pis, pcc);
+            if (code < 0)
+                return code;
+            pprints1(pdev->strm, " %s\n", command);
+            break;
+        case gs_color_space_index_DeviceCMYK:
+            command = ppscc->setcmykcolor;
+            code = pdf_write_ccolor(pdev, pis, pcc);
+            if (code < 0)
+                return code;
+            pprints1(pdev->strm, " %s\n", command);
+            break;
+        default:
+            if (!gx_hld_saved_color_same_cspace(current, psc)) {
+                cos_value_t cs_value;
+
+                code = pdf_color_space_named(pdev, &cs_value, NULL, pcs,
+                                &pdf_color_space_names, true, NULL, 0);
+                /* fixme : creates redundant PDF objects. */
+                if (code == gs_error_rangecheck) {
+                    /* The color space can't write to PDF. This should never happen */
+                    return write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                }
+                if (code < 0)
+                    return code;
+                code = cos_value_write(&cs_value, pdev);
+                if (code < 0)
+                    return code;
+                pprints1(pdev->strm, " %s\n", ppscc->setcolorspace);
+                *used_process_color = false;
+                code = pdf_write_ccolor(pdev, pis, pcc);
+                if (code < 0)
+                    return code;
+                pprints1(pdev->strm, " %s\n", ppscc->setcolorn);
+            } else if (*used_process_color)
+                return write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+            else {
+                code = pdf_write_ccolor(pdev, pis, pcc);
+                if (code < 0)
+                    return code;
+                pprints1(pdev->strm, " %s\n", ppscc->setcolorn);
+            }
+            break;
+    }
+    *used_process_color = false;
+
+    return 0;
+}
+
+static int write_color_as_process_ICC(gx_device_pdf * pdev, const gs_imager_state * pis, const gs_color_space *pcs,
+                        const gx_drawing_color *pdc, gx_hl_saved_color * psc, bool *used_process_color,
+                        const psdf_set_color_commands_t *ppscc, gs_client_color *pcc,
+                        gx_hl_saved_color *current)
+{
+    int i, code;
+    cos_value_t cs_value;
+
+    if (!gx_hld_saved_color_same_cspace(current, psc)) {
+        code = pdf_color_space_named(pdev, &cs_value, NULL, pcs,
+                        &pdf_color_space_names, true, NULL, 0);
+        /* fixme : creates redundant PDF objects. */
+        if (code == gs_error_rangecheck) {
+            /* The color space can't write to PDF. This should never happen */
+            return write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+        }
+        if (code < 0)
+            return code;
+        code = cos_value_write(&cs_value, pdev);
+        if (code < 0)
+            return code;
+        pprints1(pdev->strm, " %s\n", ppscc->setcolorspace);
+        *used_process_color = false;
+        pprintg1(pdev->strm, "%g", psdf_round(pcc->paint.values[0], 255, 8));
+        for (i = 1; i < pcs->type->num_components(pcs); i++) {
+            pprintg1(pdev->strm, " %g", psdf_round(pcc->paint.values[i], 255, 8));
+        }
+        if (code < 0)
+            return code;
+        pprints1(pdev->strm, " %s\n", ppscc->setcolorn);
+    } else if (*used_process_color)
+        return write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+    return 0;
+}
+
+static int new_pdf_reset_color(gx_device_pdf * pdev, const gs_imager_state * pis,
+                const gx_drawing_color *pdc, gx_hl_saved_color * psc,
+                bool *used_process_color,
+                const psdf_set_color_commands_t *ppscc)
+{
+    int code=0, code1=0;
+    gx_hl_saved_color temp;
+    gs_client_color *pcc; /* fixme: not needed due to gx_hld_get_color_component. */
+    cos_value_t cs_value;
+    gs_color_space_index csi;
+    gs_color_space_index csi2;
+    const gs_color_space *pcs, *pcs2;
+
+    if (pdev->skip_colors)
+        return 0;
+
+    /* Get a copy of the current colour so we can examine it. */
+    gx_hld_save_color(pis, pdc, &temp);
+
+    /* Since pdfwrite never applies halftones and patterns, but monitors
+     * halftone/pattern IDs separately, we don't need to compare
+     * halftone/pattern bodies here.
+     */
+    if (gx_hld_saved_color_equal(&temp, psc))
+        /* New colour (and space) same as old colour, no need to do anything */
+        return 0;
+
+    /* Do we have a Pattern colour space ? */
+    switch (gx_hld_get_color_space_and_ccolor(pis, pdc, &pcs, (const gs_client_color **)&pcc)) {
+        case pattern_color_space:
+            {
+                pdf_resource_t *pres;
+
+                if (pdc->type == gx_dc_type_pattern) {
+                    /* Can't handle tiling patterns in levels 1.0 and 1.1, and
+                     * unlike shading patterns we have no fallback.
+                     */
+                    if (pdev->CompatibilityLevel < 1.2) {
+                        return gs_error_undefined;
+                    }
+                    code = pdf_put_colored_pattern(pdev, pdc, pcs,
+                                ppscc, pis->have_pattern_streams, &pres);
+                }
+                else if (pdc->type == &gx_dc_pure_masked) {
+                    code = pdf_put_uncolored_pattern(pdev, pdc, pcs,
+                                ppscc, pis->have_pattern_streams, &pres);
+                    if (code < 0 || pres == 0) {
+                        /* replaced a pattern with a flat fill, but we still
+                         * need to change the 'saved' colour or we will
+                         * get out of step with the PDF content.
+                         */
+                        *psc = temp;
+                        return code;
+                    }
+                    if (pis->have_pattern_streams)
+                        code = pdf_write_ccolor(pdev, pis, pcc);
+                } else if (pdc->type == &gx_dc_pattern2) {
+                    if (pdev->CompatibilityLevel <= 1.2)
+                        return_error(gs_error_rangecheck);
+                    if (!is_pattern2_allowed_in_strategy(pdev, pdc))
+                        return_error(gs_error_rangecheck);
+                    code1 = pdf_put_pattern2(pdev, pdc, ppscc, &pres);
+                    if (code1 < 0)
+                        return code1;
+                } else
+                    return_error(gs_error_rangecheck);
+                if (code < 0)
+                    return code;
+                code = pdf_add_resource(pdev, pdev->substream_Resources, "/Pattern", pres);
+                if (code1 != gs_error_rangecheck) {
+                    cos_value_write(cos_resource_value(&cs_value, pres->object), pdev);
+                    pprints1(pdev->strm, " %s\n", ppscc->setcolorn);
+                }
+                else
+                    pres->where_used = 0;
+                if (code < 0)
+                    return code;
+                *used_process_color = false;
+            }
+            break;
+        case non_pattern_color_space:
+            csi = csi2 = gs_color_space_get_index(pcs);
+            if (csi == gs_color_space_index_ICC) {
+                csi2 = gsicc_get_default_type(pcs->cmm_icc_profile_data);
+            }
+            /* Figure out what to do if we are outputting to really ancient versions of PDF */
+            /* NB ps2write sets CompatibilityLevel to 1.2 so we cater for it here */
+            if (pdev->CompatibilityLevel <= 1.2) {
+
+                /* If we have an /Indexed space, we need to look at the base space */
+                if (csi2 == gs_color_space_index_Indexed) {
+                    pcs2 = pcs->base_space;
+                    csi2 = gs_color_space_get_index(pcs2);
+                }
+
+                switch (csi2) {
+                    case gs_color_space_index_DeviceGray:
+                        if (pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged ||
+                            pdev->params.ColorConversionStrategy == ccs_Gray)
+                            code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                        else
+                            code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                        break;
+                    case gs_color_space_index_DeviceRGB:
+                        if (pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged ||
+                            pdev->params.ColorConversionStrategy == ccs_RGB)
+                            code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                        else
+                            code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                        break;
+                    case gs_color_space_index_DeviceCMYK:
+                        if (pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged ||
+                            pdev->params.ColorConversionStrategy == ccs_CMYK)
+                            code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                        else
+                            code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                        break;
+                    case gs_color_space_index_CIEA:
+                    case gs_color_space_index_CIEABC:
+                    case gs_color_space_index_CIEDEF:
+                    case gs_color_space_index_CIEDEFG:
+                    case gs_color_space_index_Separation:
+                        if (pdev->ForOPDFRead) {
+                            switch (pdev->params.ColorConversionStrategy) {
+                                case ccs_ByObjectType:
+                                    /* Object type not implemented yet */
+                                case ccs_UseDeviceDependentColor:
+                                    /* DeviceDependentColor deprecated */
+                                case ccs_UseDeviceIndependentColorForImages:
+                                    /* If only correcting images, then leave unchanged */
+                                case ccs_LeaveColorUnchanged:
+                                    code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                                    break;
+                                default:
+                                    code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                                    break;
+                            }
+                        }
+                        else
+                            code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                        break;
+                    case gs_color_space_index_DeviceN:
+                    case gs_color_space_index_DevicePixel:
+                    case gs_color_space_index_Indexed:
+                    case gs_color_space_index_ICC:
+                        code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                        break;
+                    default:
+                        return (gs_note_error(gs_error_rangecheck));
+                        break;
+                }
+            } else {
+                switch(pdev->params.ColorConversionStrategy) {
+                    case ccs_ByObjectType:
+                        /* Object type not implemented yet */
+                    case ccs_UseDeviceDependentColor:
+                        /* DeviceDependentCOlor deprecated */
+                    case ccs_UseDeviceIndependentColorForImages:
+                        /* If only correcting images, then leave unchanged */
+                    case ccs_LeaveColorUnchanged:
+                        code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                        break;
+                    case ccs_sRGB:
+                    case ccs_UseDeviceIndependentColor:
+                            code = write_color_as_process_ICC(pdev, pis, pcs, pdc, psc, used_process_color, ppscc, pcc, &temp);
+                        break;
+                    case ccs_CMYK:
+                        switch(csi2) {
+                            case gs_color_space_index_DeviceGray:
+                            case gs_color_space_index_DeviceCMYK:
+                                code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                                break;
+                            case gs_color_space_index_Separation:
+                            case gs_color_space_index_DeviceN:
+                                code = write_color_as_process_ICC(pdev, pis, pcs, pdc, psc, used_process_color, ppscc, pcc, &temp);
+                                break;
+                            case gs_color_space_index_Indexed:
+                                pcs2 = pcs->base_space;
+                                csi = gs_color_space_get_index(pcs2);
+                                if (csi == gs_color_space_index_ICC)
+                                    csi = gsicc_get_default_type(pcs2->cmm_icc_profile_data);
+                                switch(csi) {
+                                    case gs_color_space_index_DeviceGray:
+                                    case gs_color_space_index_DeviceCMYK:
+                                        code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                                        break;
+                                    case gs_color_space_index_Separation:
+                                    case gs_color_space_index_DeviceN:
+                                        code = write_color_as_process_ICC(pdev, pis, pcs, pdc, psc, used_process_color, ppscc, pcc, &temp);
+                                        break;
+                                    default:
+                                        code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                                        break;
+                                }
+                                break;
+                            default:
+                                code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                                break;
+                        }
+                        break;
+                    case ccs_Gray:
+                        switch(csi2) {
+                            case gs_color_space_index_DeviceGray:
+                                code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                                break;
+                            case gs_color_space_index_Separation:
+                            case gs_color_space_index_DeviceN:
+                                code = write_color_as_process_ICC(pdev, pis, pcs, pdc, psc, used_process_color, ppscc, pcc, &temp);
+                                break;
+                            case gs_color_space_index_Indexed:
+                                pcs2 = pcs->base_space;
+                                csi = gs_color_space_get_index(pcs2);
+                                if (csi == gs_color_space_index_ICC)
+                                    csi = gsicc_get_default_type(pcs2->cmm_icc_profile_data);
+                                switch(csi) {
+                                    case gs_color_space_index_DeviceGray:
+                                        code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                                        break;
+                                    case gs_color_space_index_Separation:
+                                    case gs_color_space_index_DeviceN:
+                                        code = write_color_as_process_ICC(pdev, pis, pcs, pdc, psc, used_process_color, ppscc, pcc, &temp);
+                                        break;
+                                    default:
+                                        code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                                        break;
+                                }
+                                break;
+                            default:
+                                code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                                break;
+                        }
+                        break;
+                    case ccs_RGB:
+                        switch(csi2) {
+                            case gs_color_space_index_DeviceGray:
+                            case gs_color_space_index_DeviceRGB:
+                                code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                                break;
+                            case gs_color_space_index_Separation:
+                            case gs_color_space_index_DeviceN:
+                                code = write_color_as_process_ICC(pdev, pis, pcs, pdc, psc, used_process_color, ppscc, pcc, &temp);
+                                break;
+                            case gs_color_space_index_Indexed:
+                                pcs2 = pcs->base_space;
+                                csi = gs_color_space_get_index(pcs2);
+                                if (csi == gs_color_space_index_ICC)
+                                    csi = gsicc_get_default_type(pcs2->cmm_icc_profile_data);
+                                switch(csi) {
+                                    case gs_color_space_index_DeviceGray:
+                                    case gs_color_space_index_DeviceRGB:
+                                        code = write_color_unchanged(pdev, pis, pcc, &temp, psc, ppscc, used_process_color, pcs, pdc);
+                                        break;
+                                    case gs_color_space_index_Separation:
+                                    case gs_color_space_index_DeviceN:
+                                        code = write_color_as_process_ICC(pdev, pis, pcs, pdc, psc, used_process_color, ppscc, pcc, &temp);
+                                        break;
+                                    default:
+                                        code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                                        break;
+                                }
+                                break;
+                            default:
+                                code = write_color_as_process(pdev, pis, pcs, pdc, used_process_color, ppscc, pcc);
+                                break;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+            break;
+        default: /* must not happen. */
+        case use_process_color:
+            code = psdf_set_color((gx_device_vector *)pdev, pdc, ppscc);
+            if (code < 0)
+                return code;
+            *used_process_color = true;
+            break;
+    }
+    *psc = temp;
+    return code;
+}
 /* Set the fill or stroke color. */
 int
 pdf_reset_color(gx_device_pdf * pdev, const gs_imager_state * pis,
@@ -309,6 +806,9 @@ pdf_reset_color(gx_device_pdf * pdev, const gs_imager_state * pis,
     gs_color_space_index csi;
     gs_color_space_index csi2;
 
+    if (!pdev->UseOldColor)
+        return new_pdf_reset_color(pdev, pis, pdc, psc, used_process_color, ppscc);
+
     if (pdev->skip_colors)
         return 0;
     gx_hld_save_color(pis, pdc, &temp);
diff --git a/gs/base/gdevpdfi.c b/gs/base/gdevpdfi.c
index b20109e0f..0d467c636 100644
--- a/gs/base/gdevpdfi.c
+++ b/gs/base/gdevpdfi.c
@@ -900,11 +900,11 @@ pdf_begin_typed_image_impl(gx_device_pdf *pdev, const gs_imager_state * pis,
  nyi:
     return gx_default_begin_typed_image
         ((gx_device *)pdev, pis, pmat, pic, prect, pdcolor, pcpath, mem,
-         pinfo);
+        pinfo);
 }
 
 static int
-pdf_begin_typed_image(gx_device_pdf *pdev, const gs_imager_state * pis,
+old_pdf_begin_typed_image(gx_device_pdf *pdev, const gs_imager_state * pis,
                       const gs_matrix *pmat, const gs_image_common_t *pic,
                       const gs_int_rect * prect,
                       const gx_drawing_color * pdcolor,
@@ -924,6 +924,984 @@ pdf_begin_typed_image(gx_device_pdf *pdev, const gs_imager_state * pis,
   return code;
 }
 
+static int setup_type1_image(gx_device_pdf *pdev, const gs_image_common_t *pic,
+                             const gx_drawing_color * pdcolor, image_union_t *image,
+                             pdf_typed_image_context_t context)
+{
+    const gs_image_t *pim1 = (const gs_image_t *)pic;
+
+    if (pim1->Alpha != gs_image_alpha_none)
+        return -1;
+    if (pim1->ImageMask) {
+        /* If parameters are invalid, use the fallback implementation. */
+        if (!(gx_dc_is_pattern1_color(pdcolor)))
+            if (pim1->BitsPerComponent != 1 ||
+                !((pim1->Decode[0] == 0.0 && pim1->Decode[1] == 1.0) ||
+                  (pim1->Decode[0] == 1.0 && pim1->Decode[1] == 0.0))
+                )
+                return -1;
+    }
+    image[0].type1 = *pim1;
+    /* If we can write in-line then make it so */
+    return (context == PDF_IMAGE_DEFAULT &&
+        can_write_image_in_line(pdev, pim1));
+}
+
+static int setup_type3_image(gx_device_pdf *pdev, const gs_imager_state * pis,
+                      const gs_matrix *pmat, const gs_image_common_t *pic,
+                      const gs_int_rect * prect,
+                      const gx_drawing_color * pdcolor,
+                      const gx_clip_path * pcpath, gs_memory_t * mem,
+                      gx_image_enum_common_t ** pinfo,
+                      image_union_t *image)
+{
+    const gs_image3_t *pim3 = (const gs_image3_t *)pic;
+    gs_image3_t pim3a;
+    const gs_image_common_t *pic1 = pic;
+    gs_matrix m, mi;
+    const gs_matrix *pmat1 = pmat;
+    int code;
+
+    if (pdev->CompatibilityLevel < 1.3 && !pdev->PatternImagemask) {
+        if (pdf_must_put_clip_path(pdev, pcpath))
+            code = pdf_unclip(pdev);
+        else
+            code = pdf_open_page(pdev, PDF_IN_STREAM);
+        if (code < 0)
+            return code;
+        code = pdf_put_clip_path(pdev, pcpath);
+        if (code < 0)
+            return code;
+        gs_make_identity(&m);
+        pmat1 = &m;
+        m.tx = floor(pis->ctm.tx + 0.5); /* Round the origin against the image size distorsions */
+        m.ty = floor(pis->ctm.ty + 0.5);
+        pim3a = *pim3;
+        gs_matrix_invert(&pim3a.ImageMatrix, &mi);
+        gs_make_identity(&pim3a.ImageMatrix);
+        if (pim3a.Width < pim3a.MaskDict.Width && pim3a.Width > 0) {
+            int sx = (pim3a.MaskDict.Width + pim3a.Width - 1) / pim3a.Width;
+
+            gs_matrix_scale(&mi, 1.0 / sx, 1, &mi);
+            gs_matrix_scale(&pim3a.ImageMatrix, 1.0 / sx, 1, &pim3a.ImageMatrix);
+        }
+        if (pim3a.Height < pim3a.MaskDict.Height && pim3a.Height > 0) {
+            int sy = (pim3a.MaskDict.Height + pim3a.Height - 1) / pim3a.Height;
+
+            gs_matrix_scale(&mi, 1, 1.0 / sy, &mi);
+            gs_matrix_scale(&pim3a.ImageMatrix, 1, 1.0 / sy, &pim3a.ImageMatrix);
+        }
+        gs_matrix_multiply(&mi, &pim3a.MaskDict.ImageMatrix, &pim3a.MaskDict.ImageMatrix);
+        pic1 = (gs_image_common_t *)&pim3a;
+        /* Setting pdev->converting_image_matrix to communicate with pdf_image3_make_mcde. */
+        gs_matrix_multiply(&mi, &ctm_only(pis), &pdev->converting_image_matrix);
+    }
+    /*
+     * We handle ImageType 3 images in a completely different way:
+     * the default implementation sets up the enumerator.
+     */
+    return gx_begin_image3_generic((gx_device *)pdev, pis, pmat1, pic1,
+                                   prect, pdcolor, pcpath, mem,
+                                   pdf_image3_make_mid,
+                                   pdf_image3_make_mcde, pinfo);
+}
+
+static int convert_type4_image(gx_device_pdf *pdev, const gs_imager_state * pis,
+                      const gs_matrix *pmat, const gs_image_common_t *pic,
+                      const gs_int_rect * prect,
+                      const gx_drawing_color * pdcolor,
+                      const gx_clip_path * pcpath, gs_memory_t * mem,
+                      gx_image_enum_common_t ** pinfo,
+                      pdf_typed_image_context_t context, image_union_t *image,
+                      cos_dict_t *pnamed)
+{
+    /* Try to convert the image to a plain masked image. */
+    gx_drawing_color icolor;
+    int code;
+
+    pdev->image_mask_is_SMask = false;
+    if (pdf_convert_image4_to_image1(pdev, pis, pdcolor,
+                                     (const gs_image4_t *)pic,
+                                     &image[0].type1, &icolor) >= 0) {
+        gs_state *pgs = (gs_state *)gx_hld_get_gstate_ptr(pis);
+
+        if (pgs == NULL)
+            return_error(gs_error_unregistered); /* Must not happen. */
+
+        /* Undo the pop of the NI stack if necessary. */
+        if (pnamed)
+            cos_array_add_object(pdev->NI_stack, COS_OBJECT(pnamed));
+        /* HACK: temporary patch the color space, to allow
+           pdf_prepare_imagemask to write the right color for the imagemask. */
+        code = gs_gsave(pgs);
+        if (code < 0)
+            return code;
+        /* {csrc}: const cast warning */
+        code = gs_setcolorspace(pgs, ((const gs_image4_t *)pic)->ColorSpace);
+        if (code < 0)
+            return code;
+        code = pdf_begin_typed_image(pdev, pis, pmat,
+                                     (gs_image_common_t *)&image[0].type1,
+                                     prect, &icolor, pcpath, mem,
+                                     pinfo, context);
+        if (code < 0)
+            return code;
+        return gs_grestore(pgs);
+    }
+    return 1;
+}
+
+static int convert_type4_to_masked_image(gx_device_pdf *pdev, const gs_imager_state * pis,
+                      const gs_image_common_t *pic,
+                      const gs_int_rect * prect,
+                      const gx_drawing_color * pdcolor,
+                      const gx_clip_path * pcpath, gs_memory_t * mem,
+                      gx_image_enum_common_t ** pinfo)
+{
+        gs_matrix m, m1, mi;
+        gs_image4_t pi4 = *(const gs_image4_t *)pic;
+        int code;
+        pdf_lcvd_t *cvd = NULL;
+
+        if (pdf_must_put_clip_path(pdev, pcpath))
+            code = pdf_unclip(pdev);
+        else
+            code = pdf_open_page(pdev, PDF_IN_STREAM);
+        if (code < 0)
+            return code;
+        code = pdf_put_clip_path(pdev, pcpath);
+        if (code < 0)
+            return code;
+        gs_make_identity(&m1);
+        gs_matrix_invert(&pic->ImageMatrix, &mi);
+        gs_matrix_multiply(&mi, &ctm_only(pis), &m);
+        code = pdf_setup_masked_image_converter(pdev, mem, &m, &cvd,
+                             true, 0, 0, pi4.Width, pi4.Height, false);
+        if (code < 0)
+            return code;
+        cvd->mdev.is_open = true; /* fixme: same as above. */
+        cvd->mask->is_open = true; /* fixme: same as above. */
+        cvd->mask_is_empty = false;
+        code = (*dev_proc(cvd->mask, fill_rectangle))((gx_device *)cvd->mask,
+                    0, 0, cvd->mask->width, cvd->mask->height, (gx_color_index)0);
+        if (code < 0)
+            return code;
+        gx_device_retain((gx_device *)cvd, true);
+        gx_device_retain((gx_device *)cvd->mask, true);
+        gs_make_identity(&pi4.ImageMatrix);
+        code = gx_default_begin_typed_image((gx_device *)cvd,
+            pis, &m1, (gs_image_common_t *)&pi4, prect, pdcolor, NULL, mem, pinfo);
+        if (code < 0)
+            return code;
+        (*pinfo)->procs = &pdf_image_cvd_enum_procs;
+        return 0;
+}
+
+static int setup_image_process_colorspace(gx_device_pdf *pdev, image_union_t *image, gs_color_space **pcs_orig,
+                                          const char *sname, cos_value_t *cs_value)
+{
+    int code;
+    gs_color_space *pcs_device = NULL;
+
+    cos_c_string_value(cs_value, sname);
+    *pcs_orig = image->pixel.ColorSpace;
+    code = make_device_color_space(pdev, pdev->pcm_color_info_index, &pcs_device);
+    if (code < 0)
+        return code;
+    image->pixel.ColorSpace = pcs_device;
+    return 0;
+}
+
+/* 0 = write unchanged
+   1 = convert to process
+   2 = write as ICC
+ */
+static int setup_image_colorspace(gx_device_pdf *pdev, image_union_t *image, const gs_color_space *pcs, gs_color_space **pcs_orig,
+                                  const pdf_color_space_names_t *names, cos_value_t *cs_value)
+{
+    int code=0;
+    gs_color_space_index csi;
+    gs_color_space_index csi2;
+    const gs_color_space *pcs2 = pcs;
+
+    csi = csi2 = gs_color_space_get_index(pcs);
+    if (csi == gs_color_space_index_ICC) {
+        csi2 = gsicc_get_default_type(pcs->cmm_icc_profile_data);
+    }
+    /* Figure out what to do if we are outputting to really ancient versions of PDF */
+    /* NB ps2write sets CompatibilityLevel to 1.2 so we cater for it here */
+    if (pdev->CompatibilityLevel <= 1.2) {
+
+        /* If we have an /Indexed space, we need to look at the base space */
+        if (csi2 == gs_color_space_index_Indexed) {
+            pcs2 = pcs->base_space;
+            csi2 = gs_color_space_get_index(pcs2);
+        }
+
+        switch (csi2) {
+            case gs_color_space_index_DeviceGray:
+                if (pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged ||
+                    pdev->params.ColorConversionStrategy == ccs_Gray) {
+                    return 0;
+                }
+                else {
+                    code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceGray, cs_value);
+                    if (code < 0)
+                        return code;
+                    return 1;
+                }
+                break;
+            case gs_color_space_index_DeviceRGB:
+                if (pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged ||
+                    pdev->params.ColorConversionStrategy == ccs_RGB)
+                    return 0;
+                else {
+                    code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceRGB, cs_value);
+                    if (code < 0)
+                        return code;
+                    return 1;
+                }
+                break;
+            case gs_color_space_index_DeviceCMYK:
+                if ((pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged ||
+                    pdev->params.ColorConversionStrategy == ccs_CMYK) && !pdev->params.ConvertCMYKImagesToRGB)
+                    return 0;
+                else {
+                    code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceCMYK, cs_value);
+                    if (code < 0)
+                        return code;
+                    return 1;
+                }
+                break;
+            case gs_color_space_index_CIEA:
+            case gs_color_space_index_CIEABC:
+            case gs_color_space_index_CIEDEF:
+            case gs_color_space_index_CIEDEFG:
+            case gs_color_space_index_Separation:
+                if (pdev->ForOPDFRead) {
+                    switch (pdev->params.ColorConversionStrategy) {
+                        case ccs_ByObjectType:
+                            /* Object type not implemented yet */
+                        case ccs_UseDeviceDependentColor:
+                            /* DeviceDependentColor deprecated */
+                        case ccs_UseDeviceIndependentColorForImages:
+                            /* If only correcting images, then leave unchanged */
+                        case ccs_LeaveColorUnchanged:
+                            if (csi2 == gs_color_space_index_Separation)
+                                return 0;
+                            /* Fall through and convert CIE to the device space */
+                        default:
+                            switch (pdev->pcm_color_info_index) {
+                                case gs_color_space_index_DeviceGray:
+                                    code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceGray, cs_value);
+                                    break;
+                                case gs_color_space_index_DeviceRGB:
+                                    code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceRGB, cs_value);
+                                    break;
+                                case gs_color_space_index_DeviceCMYK:
+                                    code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceCMYK, cs_value);
+                                    break;
+                                default:
+                                    emprintf(pdev->memory, "Unsupported ProcessColorModel.");
+                                    return_error(gs_error_undefined);
+                            }
+                            if (code < 0)
+                                return code;
+                            return 1;
+                            break;
+                    }
+                }
+                else
+                    return 1;
+                break;
+
+            case gs_color_space_index_ICC:
+                /* Note that if csi is ICC, check to see if this was one of
+                   the default substitutes that we introduced for DeviceGray,
+                   DeviceRGB or DeviceCMYK.  If it is, then just write
+                   the default color.  Depending upon the flavor of PDF,
+                   or other options, we may want to actually have all
+                   the colors defined by ICC profiles and not do the following
+                   substituion of the Device space. */
+                csi2 = gsicc_get_default_type(pcs2->cmm_icc_profile_data);
+
+                switch (csi2) {
+                    case gs_color_space_index_DeviceGray:
+                        if (pdev->params.ColorConversionStrategy == ccs_Gray ||
+                            pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged)
+                            return 0;
+                        break;
+                    case gs_color_space_index_DeviceRGB:
+                        if (pdev->params.ColorConversionStrategy == ccs_RGB ||
+                            pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged)
+                            return 0;
+                        break;
+                    case gs_color_space_index_DeviceCMYK:
+                        if (pdev->params.ColorConversionStrategy == ccs_CMYK ||
+                            pdev->params.ColorConversionStrategy == ccs_LeaveColorUnchanged)
+                            return 0;
+                        break;
+                    default:
+                        break;
+                }
+                /* Fall through for non-handled cases */
+            case gs_color_space_index_DeviceN:
+            case gs_color_space_index_DevicePixel:
+            case gs_color_space_index_Indexed:
+                switch (pdev->pcm_color_info_index) {
+                    case gs_color_space_index_DeviceGray:
+                        code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceGray, cs_value);
+                        break;
+                    case gs_color_space_index_DeviceRGB:
+                        code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceRGB, cs_value);
+                        break;
+                    case gs_color_space_index_DeviceCMYK:
+                        code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceCMYK, cs_value);
+                        break;
+                    default:
+                        emprintf(pdev->memory, "Unsupported ProcessColorModel.");
+                        return_error(gs_error_undefined);
+                }
+                if (code < 0)
+                    return code;
+                return 1;
+                break;
+            default:
+                return (gs_note_error(gs_error_rangecheck));
+                break;
+        }
+    } else {
+        switch(pdev->params.ColorConversionStrategy) {
+            case ccs_ByObjectType:
+                /* Object type not implemented yet */
+            case ccs_UseDeviceDependentColor:
+                /* DeviceDependentCOlor deprecated */
+            case ccs_UseDeviceIndependentColorForImages:
+                /* If only correcting images, then leave unchanged */
+            case ccs_LeaveColorUnchanged:
+                return 0;
+                break;
+            case ccs_sRGB:
+            case ccs_UseDeviceIndependentColor:
+                return 2;
+                break;
+            case ccs_CMYK:
+                switch(csi2) {
+                    case gs_color_space_index_DeviceGray:
+                    case gs_color_space_index_DeviceCMYK:
+                        return 0;
+                        break;
+                    case gs_color_space_index_Separation:
+                    case gs_color_space_index_DeviceN:
+                        return 0;
+                        break;
+                    case gs_color_space_index_Indexed:
+                        pcs2 = pcs->base_space;
+                        csi = gs_color_space_get_index(pcs2);
+                        if (csi == gs_color_space_index_ICC)
+                            csi = gsicc_get_default_type(pcs2->cmm_icc_profile_data);
+                        switch(csi) {
+                            case gs_color_space_index_DeviceGray:
+                            case gs_color_space_index_DeviceCMYK:
+                                return 0;
+                                break;
+                            case gs_color_space_index_Separation:
+                            case gs_color_space_index_DeviceN:
+                                return 2;
+                                break;
+                            default:
+                                switch (pdev->pcm_color_info_index) {
+                                    case gs_color_space_index_DeviceGray:
+                                        code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceGray, cs_value);
+                                        break;
+                                    case gs_color_space_index_DeviceRGB:
+                                        code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceRGB, cs_value);
+                                        break;
+                                    case gs_color_space_index_DeviceCMYK:
+                                        code = setup_image_process_colorspace(pdev, image, pcs_orig, names->DeviceCMYK, cs_value);
+                                        break;
+                                    default:
+                                        emprintf(pdev->memory, "Unsupported ProcessColorModel.");
+                                        return_error(gs_error_undefined);
+                                }
+                                if (code < 0)
+                                    return code;
+                                return 1;
+                                break;
+                        }
+                        break;
+                    default:
+                        return 0;
+                        break;
+                }
+                break;
+            case ccs_Gray:
+                switch(csi2) {
+                    case gs_color_space_index_DeviceGray:
+                        return 0;
+                        break;
+                    case gs_color_space_index_Separation:
+                    case gs_color_space_index_DeviceN:
+                        return 2;
+                        break;
+                    case gs_color_space_index_Indexed:
+                        pcs2 = pcs->base_space;
+                        csi = gs_color_space_get_index(pcs2);
+                        if (csi == gs_color_space_index_ICC)
+                            csi = gsicc_get_default_type(pcs2->cmm_icc_profile_data);
+                        switch(csi) {
+                            case gs_color_space_index_DeviceGray:
+                                return 0;
+                                break;
+                            case gs_color_space_index_Separation:
+                            case gs_color_space_index_DeviceN:
+                                return 2;
+                                break;
+                            default:
+                                return 0;
+                                break;
+                        }
+                        break;
+                    default:
+                        return 0;
+                        break;
+                }
+                break;
+            case ccs_RGB:
+                switch(csi2) {
+                    case gs_color_space_index_DeviceGray:
+                    case gs_color_space_index_DeviceRGB:
+                        return 0;
+                        break;
+                    case gs_color_space_index_Separation:
+                    case gs_color_space_index_DeviceN:
+                        return 2;
+                        break;
+                    case gs_color_space_index_Indexed:
+                        pcs2 = pcs->base_space;
+                        csi = gs_color_space_get_index(pcs2);
+                        if (csi == gs_color_space_index_ICC)
+                            csi = gsicc_get_default_type(pcs2->cmm_icc_profile_data);
+                        switch(csi) {
+                            case gs_color_space_index_DeviceGray:
+                            case gs_color_space_index_DeviceRGB:
+                                return 0;
+                                break;
+                            case gs_color_space_index_Separation:
+                            case gs_color_space_index_DeviceN:
+                                return 2;
+                                break;
+                            default:
+                                return 0;
+                                break;
+                        }
+                        break;
+                    default:
+                        return 0;
+                        break;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return 0;
+}
+
+static int
+new_pdf_begin_typed_image(gx_device_pdf *pdev, const gs_imager_state * pis,
+                      const gs_matrix *pmat, const gs_image_common_t *pic,
+                      const gs_int_rect * prect,
+                      const gx_drawing_color * pdcolor,
+                      const gx_clip_path * pcpath, gs_memory_t * mem,
+                      gx_image_enum_common_t ** pinfo,
+                      pdf_typed_image_context_t context)
+{
+    int code, i;
+    unsigned int use_fallback  = 0, in_line = 0, is_mask = 0,
+        force_lossless = 0, convert_to_process_colors = 0, reduce_bits = 0;
+    int width, height;
+    cos_dict_t *pnamed = 0;
+    image_union_t *image;
+    const gs_pixel_image_t *pim;
+    gs_int_rect rect;
+    gs_image_format_t format;
+    const gs_color_space *pcs;
+    int num_components;
+    pdf_image_enum *pie;
+    const pdf_color_space_names_t *names;
+    gs_color_space *pcs_orig = NULL;
+    gs_color_space *pcs_device = NULL;
+    cos_value_t cs_value;
+    const gs_range_t *pranges = 0;
+
+    image = (image_union_t *)gs_malloc(mem->non_gc_memory, 4,
+                       sizeof(image_union_t), "pdf_begin_typed_image(image)");
+    if (image == 0)
+        return_error(gs_error_VMerror);
+
+    /*
+     * Pop the image name from the NI stack.  We must do this, to keep the
+     * stack in sync, even if it turns out we can't handle the image.
+     */
+    {
+        cos_value_t ni_value;
+
+        if (cos_array_unadd(pdev->NI_stack, &ni_value) >= 0)
+            pnamed = (cos_dict_t *)ni_value.contents.object;
+    }
+
+    /* An initialization for pdf_end_and_do_image :
+       We need to delay adding the "Mask" entry into a type 3 image dictionary
+       until the mask is completed due to equal image merging. */
+    pdev->image_mask_id = gs_no_id;
+
+    /* Check for the image types we can handle. */
+    switch (pic->type->index) {
+    case 1:
+        is_mask = ((const gs_image_t *)pic)->ImageMask;
+        code = setup_type1_image(pdev, pic, pdcolor, image, context);
+        if (code < 0) {
+            use_fallback = 1;
+        }
+        else
+            in_line = code;
+        break;
+
+    case 3:
+        pdev->image_mask_is_SMask = false;
+        if (pdev->CompatibilityLevel < 1.2 ||
+            (prect && !(prect->p.x == 0 && prect->p.y == 0 &&
+                   prect->q.x == ((const gs_image3_t *)pic)->Width &&
+                   prect->q.y == ((const gs_image3_t *)pic)->Height))) {
+            gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+            return (gx_default_begin_typed_image((gx_device *)pdev, pis, pmat, pic, prect, pdcolor,
+                pcpath, mem, pinfo));
+        }
+        gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                          "pdf_begin_typed_image(image)");
+        return (setup_type3_image(pdev, pis, pmat, pic, prect, pdcolor, pcpath, mem, pinfo, image));
+        break;
+
+    case IMAGE3X_IMAGETYPE:
+        gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+        if (pdev->CompatibilityLevel < 1.4 ||
+            (prect && !(prect->p.x == 0 && prect->p.y == 0 &&
+                       prect->q.x == ((const gs_image3x_t *)pic)->Width &&
+                       prect->q.y == ((const gs_image3x_t *)pic)->Height))) {
+            return (gx_default_begin_typed_image((gx_device *)pdev, pis, pmat, pic, prect, pdcolor,
+                pcpath, mem, pinfo));
+        }
+        pdev->image_mask_is_SMask = true;
+        return gx_begin_image3x_generic((gx_device *)pdev, pis, pmat, pic,
+                                        prect, pdcolor, pcpath, mem,
+                                        pdf_image3x_make_mid,
+                                        pdf_image3x_make_mcde, pinfo);
+        break;
+
+    case 4:
+        code = convert_type4_image(pdev, pis, pmat, pic, prect, pdcolor,
+                      pcpath, mem, pinfo, context, image, pnamed);
+        if (code < 0) {
+            use_fallback = 1;
+        }
+        if (code == 0) {
+            gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                                  "pdf_begin_typed_image(image)");
+            return code;
+        }
+        /* No luck.  Masked images require PDF 1.3 or higher. */
+        if (pdev->CompatibilityLevel < 1.2) {
+            use_fallback = 1;
+        }
+        if (pdev->CompatibilityLevel < 1.3 && !pdev->PatternImagemask) {
+            gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                                  "pdf_begin_typed_image(image)");
+            return (convert_type4_to_masked_image(pdev, pis, pic, prect, pdcolor,
+                      pcpath, mem,pinfo));
+        }
+        image[0].type4 = *(const gs_image4_t *)pic;
+        break;
+
+    default:
+        use_fallback = 1;
+        break;
+    }
+
+    pim = (const gs_pixel_image_t *)pic;
+    format = pim->format;
+    switch (format) {
+    case gs_image_format_chunky:
+    case gs_image_format_component_planar:
+        break;
+    default:
+        use_fallback = 1;
+    }
+    /* AR5 on Windows doesn't support 0-size images. Skipping. */
+    if (pim->Width == 0 || pim->Height == 0)
+        use_fallback = 1;
+    /* PDF doesn't support images with more than 8 bits per component. */
+    switch (pim->BitsPerComponent) {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+            break;
+        case 12:
+        case 16:
+            use_fallback = 1;
+//            reduce_bits = pim->BitsPerComponent;
+            break;
+        default:
+            gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+            return_error(gs_error_rangecheck);
+    }
+    if (prect)
+        rect = *prect;
+    else {
+        rect.p.x = rect.p.y = 0;
+        rect.q.x = pim->Width, rect.q.y = pim->Height;
+    }
+    if (rect.p.x != 0 || rect.p.y != 0 ||
+        rect.q.x != pim->Width || rect.q.y != pim->Height ||
+        (is_mask && pim->CombineWithColor))
+        use_fallback = 1;
+
+    if (use_fallback) {
+        gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+        return gx_default_begin_typed_image
+            ((gx_device *)pdev, pis, pmat, pic, prect, pdcolor, pcpath, mem,
+            pinfo);
+    }
+
+    pcs = pim->ColorSpace;
+    num_components = (is_mask ? 1 : gs_color_space_num_components(pcs));
+
+    if (pdf_must_put_clip_path(pdev, pcpath))
+        code = pdf_unclip(pdev);
+    else
+        code = pdf_open_page(pdev, PDF_IN_STREAM);
+    if (code < 0) {
+        gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+        return gx_default_begin_typed_image
+            ((gx_device *)pdev, pis, pmat, pic, prect, pdcolor, pcpath, mem,
+            pinfo);
+    }
+
+    if (context == PDF_IMAGE_TYPE3_MASK) {
+        /*
+         * The soft mask for an ImageType 3x image uses a DevicePixel
+         * color space, which pdf_color_space() can't handle.  Patch it
+         * to DeviceGray here.
+         */
+        /* {csrc} make sure this gets freed */
+        pcs = gs_cspace_new_DeviceGray(pdev->memory);
+    } else if (is_mask)
+        code = pdf_prepare_imagemask(pdev, pis, pdcolor);
+    else
+        code = pdf_prepare_image(pdev, pis);
+    if (code < 0) {
+        gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+        return gx_default_begin_typed_image
+            ((gx_device *)pdev, pis, pmat, pic, prect, pdcolor, pcpath, mem,
+            pinfo);
+    }
+
+    pie = gs_alloc_struct(mem, pdf_image_enum, &st_pdf_image_enum,
+                        "pdf_begin_image");
+    if (pie == 0) {
+        gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+        return_error(gs_error_VMerror);
+    }
+    memset(pie, 0, sizeof(*pie)); /* cleanup entirely for GC to work in all cases. */
+    *pinfo = (gx_image_enum_common_t *) pie;
+    gx_image_enum_common_init(*pinfo, (const gs_data_image_t *) pim,
+                    ((pdev->CompatibilityLevel >= 1.3) ?
+                            (context == PDF_IMAGE_TYPE3_MASK ?
+                            &pdf_image_object_enum_procs :
+                            &pdf_image_enum_procs) :
+                            context == PDF_IMAGE_TYPE3_MASK ?
+                            &pdf_image_object_enum_procs :
+                            context == PDF_IMAGE_TYPE3_DATA ?
+                            &pdf_image_object_enum_procs2 :
+                            &pdf_image_enum_procs),
+                        (gx_device *)pdev, num_components, format);
+    pie->memory = mem;
+    width = rect.q.x - rect.p.x;
+    pie->width = width;
+    height = rect.q.y - rect.p.y;
+    pie->bits_per_pixel =
+        (reduce_bits ? reduce_bits : pim->BitsPerComponent) * num_components / pie->num_planes;
+    pie->rows_left = height;
+    if (pnamed != 0) /* Don't in-line the image if it is named. */
+        in_line = false;
+    else {
+        double nbytes = (double)(((ulong) pie->width * pie->bits_per_pixel + 7) >> 3) *
+            pie->num_planes * pie->rows_left;
+
+        in_line &= (nbytes < pdev->MaxInlineImageSize);
+    }
+
+    if (pmat == 0)
+        pmat = &ctm_only(pis);
+    {
+        gs_matrix mat;
+        gs_matrix bmat;
+        int code;
+
+        pdf_make_bitmap_matrix(&bmat, -rect.p.x, -rect.p.y,
+                               pim->Width, pim->Height, height);
+        if ((code = gs_matrix_invert(&pim->ImageMatrix, &mat)) < 0 ||
+            (code = gs_matrix_multiply(&bmat, &mat, &mat)) < 0 ||
+            (code = gs_matrix_multiply(&mat, pmat, &pie->mat)) < 0
+            ) {
+            gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+            gs_free_object(mem, pie, "pdf_begin_image");
+            return code;
+        }
+        /* AR3,AR4 show no image when CTM is singular; AR5 reports an error */
+        if (pie->mat.xx * pie->mat.yy == pie->mat.xy * pie->mat.yx)
+            goto fail_and_fallback;
+    }
+
+    code = pdf_put_clip_path(pdev, pcpath);
+    if (code < 0) {
+        gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                          "pdf_begin_typed_image(image)");
+        gs_free_object(mem, pie, "pdf_begin_image");
+        return code;
+    }
+    pdf_image_writer_init(&pie->writer);
+    /* Note : Possible values for alt_writer_count are 1,2,3,4.
+       1 means no alternative streams.
+       2 means the main image stream and a mask stream while converting
+               an Image Type 4.
+       3 means the main image stream, alternative image compression stream,
+               and the compression chooser.
+       4 meams 3 and a mask stream while convertingh an Image Type 4.
+     */
+    pie->writer.alt_writer_count = (in_line ||
+                                    (pim->Width <= 64 && pim->Height <= 64)
+                                    ? 1 : 2);
+    if ((image[0].pixel.ColorSpace != NULL &&
+        image[0].pixel.ColorSpace->type->index == gs_color_space_index_Indexed
+        && pdev->params.ColorImage.DownsampleType != ds_Subsample) ||
+        pdev->transfer_not_identity)
+        force_lossless = true;
+
+    names = (in_line ? &pdf_color_space_names_short : &pdf_color_space_names);
+
+    /* We don't want to change the colour space of a mask, or an SMask (both of which are Gray) */
+    if (!is_mask) {
+        if (image[0].pixel.ColorSpace != NULL && !(context == PDF_IMAGE_TYPE3_MASK))
+            convert_to_process_colors = setup_image_colorspace(pdev, &image[0], pcs, &pcs_orig, names, &cs_value);
+        if (convert_to_process_colors == 1) {
+            code = make_device_color_space(pdev, pdev->pcm_color_info_index, &pcs_device);
+            if (code < 0)
+                goto fail_and_fallback;
+            image[0].pixel.ColorSpace = pcs_device;
+            code = pdf_color_space_named(pdev, &cs_value, &pranges, pcs_device, names,
+                                     in_line, NULL, 0);
+            if (code < 0)
+                goto fail_and_fallback;
+        } else {
+            if (pcs->cmm_icc_profile_data != NULL &&
+                pcs->cmm_icc_profile_data->islab) {
+                    gscms_set_icc_range((cmm_profile_t **)&(pcs->cmm_icc_profile_data));
+            }
+            code = pdf_color_space_named(pdev, &cs_value, &pranges, pcs, names,
+                                     in_line, NULL, 0);
+            if (code < 0)
+                goto fail_and_fallback;
+        }
+    }
+
+    image[1] = image[0];
+
+    pdev->ParamCompatibilityLevel = pdev->CompatibilityLevel;
+
+    code = pdf_begin_write_image(pdev, &pie->writer, gs_no_id, width,
+                    height, pnamed, in_line);
+    if (code < 0)
+        goto fail_and_fallback;
+
+    /* Code below here deals with setting up the multiple data stream writing.
+     * We can have up to 4 stream writers, which we keep in an array. We must
+     * always have at least one which writes the uncompressed stream. If we
+     * are writing compressed streams, we have one for the compressed stream
+     * and one for the compression chooser.
+     * For type 4 images being converted (for old versions of PDF or for ps2write)
+     * we need an additional stream to write a mask, which masks the real
+     * image.
+     * For colour conversion we will place an additional filter in front of all
+     * the streams which does the conversion.
+     */
+    if (in_line) {
+        code = new_setup_lossless_filters((gx_device_psdf *) pdev,
+                                             &pie->writer.binary[0],
+                                             &image[0].pixel, in_line, convert_to_process_colors);
+    } else {
+        if (force_lossless) {
+            /*
+             * Some regrettable PostScript code (such as LanguageLevel 1 output
+             * from Microsoft's PSCRIPT.DLL driver) misuses the transfer
+             * function to accomplish the equivalent of indexed color.
+             * Downsampling (well, only averaging) or JPEG compression are not
+             * compatible with this.  Play it safe by using only lossless
+             * filters if the transfer function(s) is/are other than the
+             * identity and by setting the downsample type to Subsample..
+             */
+            int saved_downsample = pdev->params.ColorImage.DownsampleType;
+
+            pdev->params.ColorImage.DownsampleType = ds_Subsample;
+            code = new_setup_image_filters((gx_device_psdf *) pdev,
+                                          &pie->writer.binary[0], &image[0].pixel,
+                                          pmat, pis, true, in_line, convert_to_process_colors);
+            pdev->params.ColorImage.DownsampleType = saved_downsample;
+        } else {
+            code = new_setup_image_filters((gx_device_psdf *) pdev,
+                                          &pie->writer.binary[0], &image[0].pixel,
+                                          pmat, pis, true, in_line, convert_to_process_colors);
+        }
+    }
+
+    if (code < 0)
+        goto fail_and_fallback;
+
+    if (convert_to_process_colors) {
+        image[0].pixel.ColorSpace = pcs_orig;
+        code = psdf_setup_image_colors_filter(&pie->writer.binary[0],
+                    (gx_device_psdf *)pdev, &image[0].pixel, pis);
+        if (code < 0)
+            goto fail_and_fallback;
+        image[0].pixel.ColorSpace = pcs_device;
+    }
+
+    if (reduce_bits) {
+        code = new_resize_input(&pie->writer.binary[0], pim->Width, gs_color_space_num_components(pim->ColorSpace), reduce_bits, 8);
+        if (code < 0)
+            goto fail_and_fallback;
+    }
+
+    if (pie->writer.alt_writer_count > 1) {
+        code = pdf_make_alt_stream(pdev, &pie->writer.binary[1]);
+        if (code) {
+            goto fail_and_fallback;
+        }
+        code = new_setup_image_filters((gx_device_psdf *) pdev,
+                                  &pie->writer.binary[1], &image[1].pixel,
+                                  pmat, pis, force_lossless, in_line, convert_to_process_colors);
+        if (code == gs_error_rangecheck) {
+
+            for (i=1;i < pie->writer.alt_writer_count; i++) {
+                stream *s = pie->writer.binary[i].strm;
+                cos_stream_t *pcos = cos_stream_from_pipeline(pie->writer.binary[i].strm);
+                s_close_filters(&s, NULL);
+                gs_free_object(pdev->pdf_memory, s, "compressed image stream");
+                pcos->cos_procs->release((cos_object_t *)pcos, "pdf_begin_typed_image_impl");
+                gs_free_object(pdev->pdf_memory, pcos, "compressed image cos_stream");
+            }
+            /* setup_image_compression rejected the alternative compression. */
+            pie->writer.alt_writer_count = 1;
+            memset(pie->writer.binary + 1, 0, sizeof(pie->writer.binary[1]));
+            memset(pie->writer.binary + 2, 0, sizeof(pie->writer.binary[1]));
+        } else if (code) {
+            goto fail_and_fallback;
+        } else if (convert_to_process_colors) {
+            image[1].pixel.ColorSpace = pcs_orig;
+            code = psdf_setup_image_colors_filter(&pie->writer.binary[1],
+                    (gx_device_psdf *)pdev, &image[1].pixel, pis);
+            if (code < 0) {
+                goto fail_and_fallback;
+            }
+            image[1].pixel.ColorSpace = pcs_device;
+        }
+        if (reduce_bits) {
+            code = new_resize_input(&pie->writer.binary[0], pim->Width, gs_color_space_num_components(pim->ColorSpace), reduce_bits, 8);
+            if (code < 0)
+                goto fail_and_fallback;
+        }
+    }
+
+    for (i = 0; i < pie->writer.alt_writer_count; i++) {
+        code = pdf_begin_image_data_decoded(pdev, num_components, pranges, i,
+                             &image[i].pixel, &cs_value, pie);
+        if (code < 0)
+            goto fail_and_fallback;
+    }
+    if (pie->writer.alt_writer_count == 2) {
+        psdf_setup_compression_chooser(&pie->writer.binary[2],
+             (gx_device_psdf *)pdev, pim->Width, pim->Height,
+             num_components, pim->BitsPerComponent);
+        pie->writer.alt_writer_count = 3;
+    }
+    if (pic->type->index == 4 && pdev->CompatibilityLevel < 1.3) {
+        int i;
+
+        /* Create a stream for writing the mask. */
+        i = pie->writer.alt_writer_count;
+        gs_image_t_init_mask_adjust((gs_image_t *)&image[i].type1, true, false);
+        image[i].type1.Width = image[0].pixel.Width;
+        image[i].type1.Height = image[0].pixel.Height;
+        /* Won't use image[2]. */
+        code = pdf_begin_write_image(pdev, &pie->writer, gs_no_id, width,
+                    height, NULL, false);
+        if (code)
+            goto fail_and_fallback;
+        code = psdf_setup_image_filters((gx_device_psdf *) pdev,
+                                  &pie->writer.binary[i], &image[i].pixel,
+                                  pmat, pis, force_lossless, in_line);
+        if (code < 0)
+            goto fail_and_fallback;
+        psdf_setup_image_to_mask_filter(&pie->writer.binary[i],
+             (gx_device_psdf *)pdev, pim->Width, pim->Height,
+             num_components, pim->BitsPerComponent, image[i].type4.MaskColor);
+        code = pdf_begin_image_data_decoded(pdev, num_components, pranges, i,
+                             &image[i].pixel, &cs_value, pie);
+        if (code < 0)
+            goto fail_and_fallback;
+        ++pie->writer.alt_writer_count;
+    }
+
+    gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                              "pdf_begin_typed_image(image)");
+    return 0;
+
+fail_and_fallback:
+    gs_free(mem->non_gc_memory, image, 4, sizeof(image_union_t),
+                                      "pdf_begin_typed_image(image)");
+    gs_free_object(mem, pie, "pdf_begin_image");
+    return gx_default_begin_typed_image
+        ((gx_device *)pdev, pis, pmat, pic, prect, pdcolor, pcpath, mem,
+        pinfo);
+}
+
+static int pdf_begin_typed_image(gx_device_pdf *pdev,
+    const gs_imager_state * pis, const gs_matrix *pmat,
+    const gs_image_common_t *pic, const gs_int_rect * prect,
+    const gx_drawing_color * pdcolor, const gx_clip_path * pcpath,
+    gs_memory_t * mem, gx_image_enum_common_t ** pinfo,
+    pdf_typed_image_context_t context)
+{
+    if (!pdev->UseOldColor) {
+    return new_pdf_begin_typed_image(pdev, pis, pmat, pic, prect,
+                                 pdcolor, pcpath, mem, pinfo,
+                                 context);
+    } else {
+    return old_pdf_begin_typed_image(pdev, pis, pmat, pic, prect,
+                                 pdcolor, pcpath, mem, pinfo,
+                                 context);
+    }
+}
+
 int
 gdev_pdf_begin_typed_image(gx_device * dev, const gs_imager_state * pis,
                            const gs_matrix *pmat, const gs_image_common_t *pic,
diff --git a/gs/base/gdevpdfk.c b/gs/base/gdevpdfk.c
index 3e5092d5d..b54a0d7a3 100644
--- a/gs/base/gdevpdfk.c
+++ b/gs/base/gdevpdfk.c
@@ -271,6 +271,10 @@ pdf_make_iccbased(gx_device_pdf *pdev, cos_array_t *pca, int ncomps,
     bool scale_inputs = false;
     int i;
 
+    /* This code makes no sense to me, and if I remove it we get better
+     * results. So we'll chop it out for the new colour work.
+     */
+    if (pdev->UseOldColor) {
     /* Check the ranges. */
     if (pprange)
         *pprange = 0;
@@ -287,6 +291,7 @@ pdf_make_iccbased(gx_device_pdf *pdev, cos_array_t *pca, int ncomps,
         else if (rmin > 0.0 || rmax < 1.0)
             std_ranges = false;
     }
+    }
 
     /* Range values are a bit tricky to check.
        For example, CIELAB ICC profiles have
diff --git a/gs/base/gdevpdfp.c b/gs/base/gdevpdfp.c
index 7e12fe111..e86424c40 100644
--- a/gs/base/gdevpdfp.c
+++ b/gs/base/gdevpdfp.c
@@ -22,6 +22,7 @@
 #include "gdevpdfo.h"
 #include "gdevpdfg.h"
 #include "gsparamx.h"
+#include "gsicc_manage.h"
 
 /*
  * The pdfwrite device supports the following "real" parameters:
@@ -125,6 +126,7 @@ static const gs_param_item_t pdf_param_items[] = {
     pi("PreserveSMask", gs_param_type_bool, PreserveSMask),
     pi("PreserveTrMode", gs_param_type_bool, PreserveTrMode),
     pi("NoT3CCITT", gs_param_type_bool, NoT3CCITT),
+    pi("PDFUseOldCMS", gs_param_type_bool, UseOldColor),
     pi("FastWebView", gs_param_type_bool, Linearise),
     pi("FirstPage", gs_param_type_int, FirstPage),
     pi("LastPage", gs_param_type_int, LastPage),
@@ -508,30 +510,70 @@ gdev_pdf_put_params_impl(gx_device * dev, const gx_device_pdf * save_dev, gs_par
     ecode = gdev_psdf_put_params(dev, plist);
     if (ecode < 0)
         goto fail;
-    if ((pdev->params.ColorConversionStrategy == ccs_CMYK &&
-         strcmp(pdev->color_info.cm_name, "DeviceCMYK")) ||
-        (pdev->params.ColorConversionStrategy == ccs_sRGB &&
-          strcmp(pdev->color_info.cm_name, "DeviceRGB")) ||
-        (pdev->params.ColorConversionStrategy == ccs_Gray &&
-          strcmp(pdev->color_info.cm_name, "DeviceGray"))) {
-        emprintf(pdev->memory,
-                 "ColorConversionStrategy is incompatible to ProcessColorModel.\n");
-        ecode = gs_note_error(gs_error_rangecheck);
-        pdev->params.ColorConversionStrategy = save_ccs;
-    }
-    if (pdev->params.ColorConversionStrategy == ccs_UseDeviceIndependentColor) {
-        if (!pdev->UseCIEColor) {
+    if (!pdev->UseOldColor) {
+        if (pdev->params.ConvertCMYKImagesToRGB) {
+            if (pdev->params.ColorConversionStrategy == ccs_CMYK) {
+                emprintf(pdev->memory, "ConvertCMYKImagesToRGB is not compatible with ColorConversionStrategy of CMYK\n");
+            } else {
+                if (pdev->params.ColorConversionStrategy == ccs_Gray) {
+                    emprintf(pdev->memory, "ConvertCMYKImagesToRGB is not compatible with ColorConversionStrategy of Gray\n");
+                } else {
+                    if (pdev->icc_struct)
+                        rc_decrement(pdev->icc_struct,
+                                     "reset default profile\n");
+                    pdf_set_process_color_model(pdev,1);
+                    code = gsicc_init_device_profile_struct((gx_device *)pdev, NULL, 0);
+                }
+            }
+        }
+        switch (pdev->params.ColorConversionStrategy) {
+            case ccs_LeaveColorUnchanged:
+            case ccs_UseDeviceDependentColor:
+            case ccs_UseDeviceIndependentColor:
+            case ccs_UseDeviceIndependentColorForImages:
+            case ccs_ByObjectType:
+            case ccs_sRGB:
+                break;
+            case ccs_CMYK:
+                if (pdev->icc_struct)
+                    rc_decrement(pdev->icc_struct,
+                                 "reset default profile\n");
+                pdf_set_process_color_model(pdev, 2);
+                code = gsicc_init_device_profile_struct((gx_device *)pdev, NULL, 0);
+                break;
+            case ccs_Gray:
+                if (pdev->icc_struct)
+                    rc_decrement(pdev->icc_struct,
+                                 "reset default profile\n");
+                pdf_set_process_color_model(pdev,0);
+                code = gsicc_init_device_profile_struct((gx_device *)pdev, NULL, 0);
+                break;
+            case ccs_RGB:
+                /* Only bother to do this if we didn't handle it above */
+                if (!pdev->params.ConvertCMYKImagesToRGB) {
+                    if (pdev->icc_struct)
+                        rc_decrement(pdev->icc_struct,
+                                     "reset default profile\n");
+                    pdf_set_process_color_model(pdev,1);
+                    code = gsicc_init_device_profile_struct((gx_device *)pdev, NULL, 0);
+                }
+                break;
+            default:
+                break;
+        }
+    } else {
+        if ((pdev->params.ColorConversionStrategy == ccs_CMYK &&
+             strcmp(pdev->color_info.cm_name, "DeviceCMYK")) ||
+            (pdev->params.ColorConversionStrategy == ccs_sRGB &&
+              strcmp(pdev->color_info.cm_name, "DeviceRGB")) ||
+            (pdev->params.ColorConversionStrategy == ccs_Gray &&
+              strcmp(pdev->color_info.cm_name, "DeviceGray"))) {
             emprintf(pdev->memory,
-                     "Set UseCIEColor for UseDeviceIndependentColor to work properly.\n");
+                     "ColorConversionStrategy is incompatible to ProcessColorModel.\n");
             ecode = gs_note_error(gs_error_rangecheck);
-            pdev->UseCIEColor = true;
+            pdev->params.ColorConversionStrategy = save_ccs;
         }
-    }
-    if (pdev->params.ColorConversionStrategy == ccs_UseDeviceIndependentColorForImages) {
-        if (!pdev->UseCIEColor) {
-            emprintf(pdev->memory,
-                     "UseDeviceDependentColorForImages is not supported. Use UseDeviceIndependentColor.\n");
-            pdev->params.ColorConversionStrategy = ccs_UseDeviceIndependentColor;
+        if (pdev->params.ColorConversionStrategy == ccs_UseDeviceIndependentColor) {
             if (!pdev->UseCIEColor) {
                 emprintf(pdev->memory,
                          "Set UseCIEColor for UseDeviceIndependentColor to work properly.\n");
@@ -539,20 +581,33 @@ gdev_pdf_put_params_impl(gx_device * dev, const gx_device_pdf * save_dev, gs_par
                 pdev->UseCIEColor = true;
             }
         }
-    }
-    if (pdev->params.ColorConversionStrategy == ccs_UseDeviceDependentColor) {
-        if (!strcmp(pdev->color_info.cm_name, "DeviceCMYK")) {
-            emprintf(pdev->memory,
-                     "Replacing the deprecated device parameter value UseDeviceDependentColor with CMYK.\n");
-            pdev->params.ColorConversionStrategy = ccs_CMYK;
-        } else if (!strcmp(pdev->color_info.cm_name, "DeviceRGB")) {
-            emprintf(pdev->memory,
-                     "Replacing the deprecated device parameter value UseDeviceDependentColor with sRGB.\n");
-            pdev->params.ColorConversionStrategy = ccs_sRGB;
-        } else {
-            emprintf(pdev->memory,
-                     "Replacing the deprecated device parameter value UseDeviceDependentColor with Gray.\n");
-            pdev->params.ColorConversionStrategy = ccs_Gray;
+        if (pdev->params.ColorConversionStrategy == ccs_UseDeviceIndependentColorForImages) {
+            if (!pdev->UseCIEColor) {
+                emprintf(pdev->memory,
+                         "UseDeviceDependentColorForImages is not supported. Use UseDeviceIndependentColor.\n");
+                pdev->params.ColorConversionStrategy = ccs_UseDeviceIndependentColor;
+                if (!pdev->UseCIEColor) {
+                    emprintf(pdev->memory,
+                             "Set UseCIEColor for UseDeviceIndependentColor to work properly.\n");
+                    ecode = gs_note_error(gs_error_rangecheck);
+                    pdev->UseCIEColor = true;
+                }
+            }
+        }
+        if (pdev->params.ColorConversionStrategy == ccs_UseDeviceDependentColor) {
+            if (!strcmp(pdev->color_info.cm_name, "DeviceCMYK")) {
+                emprintf(pdev->memory,
+                         "Replacing the deprecated device parameter value UseDeviceDependentColor with CMYK.\n");
+                pdev->params.ColorConversionStrategy = ccs_CMYK;
+            } else if (!strcmp(pdev->color_info.cm_name, "DeviceRGB")) {
+                emprintf(pdev->memory,
+                         "Replacing the deprecated device parameter value UseDeviceDependentColor with sRGB.\n");
+                pdev->params.ColorConversionStrategy = ccs_sRGB;
+            } else {
+                emprintf(pdev->memory,
+                         "Replacing the deprecated device parameter value UseDeviceDependentColor with Gray.\n");
+                pdev->params.ColorConversionStrategy = ccs_Gray;
+            }
         }
     }
     if (cl < 1.5 && pdev->params.ColorImage.Filter != NULL &&
diff --git a/gs/base/gdevpdfx.h b/gs/base/gdevpdfx.h
index bc0545d9e..7a444433a 100644
--- a/gs/base/gdevpdfx.h
+++ b/gs/base/gdevpdfx.h
@@ -842,6 +842,9 @@ struct gx_device_pdf_s {
                                      * This parameter is present only to allow
                                      * ps2write output to work on those pritners.
                                      */
+    bool UseOldColor;               /* Use the old pdfwrite colour conversions instead of the CMS
+                                     * temporary variable
+                                     */
     bool Linearise;                 /* Whether to Linearizse the file, the next 2 parameter
                                      * are only used if this is true.
                                      */
@@ -859,8 +862,6 @@ struct gx_device_pdf_s {
 
 #define is_in_page(pdev)\
   ((pdev)->contents_id != 0)
-#define is_in_document(pdev)\
-  (is_in_page(pdev) || (pdev)->last_resource != 0)
 
 /* Enumerate the individual pointers in a gx_device_pdf. */
 #define gx_device_pdf_do_ptrs(m)\
diff --git a/gs/base/gdevpsdf.h b/gs/base/gdevpsdf.h
index 8fefe6237..a71ff70ea 100644
--- a/gs/base/gdevpsdf.h
+++ b/gs/base/gdevpsdf.h
@@ -116,12 +116,15 @@ typedef struct psdf_distiller_params_s {
         ccs_UseDeviceIndependentColorForImages,
         ccs_sRGB,
         ccs_CMYK,
-        ccs_Gray
+        ccs_Gray,
+        ccs_RGB,
+        ccs_ByObjectType
     } ColorConversionStrategy;
 #define psdf_ccs_names\
         "LeaveColorUnchanged", "UseDeviceDependentColor",\
         "UseDeviceIndependentColor", "UseDeviceIndependentColorForImages",\
-        "sRGB", "CMYK", "Gray"
+        "sRGB", "CMYK", "Gray", "RGB", "ByObjectType"
+
     bool PreserveHalftoneInfo;
     bool PreserveOverprintSettings;
     enum psdf_transfer_function_info {
@@ -407,12 +410,23 @@ int psdf_setup_image_filters(gx_device_psdf *pdev, psdf_binary_writer *pbw,
                              const gs_imager_state * pis, bool lossless,
                              bool in_line);
 
+int new_setup_image_filters(gx_device_psdf *pdev, psdf_binary_writer *pbw,
+                             gs_pixel_image_t *pim, const gs_matrix *pctm,
+                             const gs_imager_state * pis, bool lossless,
+                             bool in_line, bool colour_conversion);
+
 /* Set up compression filters for a lossless image, with no downsampling, */
 /* no color space conversion, and only lossless filters. */
 /* Note that this may modify the image parameters. */
 int psdf_setup_lossless_filters(gx_device_psdf *pdev, psdf_binary_writer *pbw,
                                 gs_pixel_image_t *pim, bool in_line);
 
+int new_setup_lossless_filters(gx_device_psdf *pdev, psdf_binary_writer *pbw,
+                                gs_pixel_image_t *pim, bool in_line, bool colour_conversion);
+
+
+int new_resize_input(psdf_binary_writer *pbw, int width, int num_comps, int bpc_in, int bpc_out);
+
 /* Finish writing binary data. */
 int psdf_end_binary(psdf_binary_writer * pbw);
 
diff --git a/gs/base/gdevpsdi.c b/gs/base/gdevpsdi.c
index 31304e423..ca33cc0b4 100644
--- a/gs/base/gdevpsdi.c
+++ b/gs/base/gdevpsdi.c
@@ -48,7 +48,7 @@ extern stream_state_proc_put_params(s_CF_put_params, stream_CF_state);
 /*
  * Add a filter to expand or reduce the pixel width if needed.
  * At least one of bpc_in and bpc_out is 8; the other is 1, 2, 4, or 8,
- * except if bpc_out is 8, bpc_in may be 12.
+ * except if bpc_out is 8, bpc_in may be 12 (or 16).
  */
 static int
 pixel_resize(psdf_binary_writer * pbw, int width, int num_components,
@@ -62,9 +62,9 @@ pixel_resize(psdf_binary_writer * pbw, int width, int num_components,
     if (bpc_out == bpc_in)
         return 0;
     if (bpc_in != 8) {
-        static const stream_template *const exts[13] = {
+        static const stream_template *const exts[17] = {
             0, &s_1_8_template, &s_2_8_template, 0, &s_4_8_template,
-            0, 0, 0, 0, 0, 0, 0, &s_12_8_template
+            0, 0, 0, 0, 0, 0, 0, &s_12_8_template, 0, 0, 0, &s_16_8_template
         };
 
         templat = exts[bpc_in];
@@ -105,7 +105,7 @@ convert_color(gx_device *pdev, const gs_color_space *pcs, const gs_imager_state
     return 0;
 }
 
-/* A hewristic choice of DCT compression parameters - see bug 687174. */
+/* A heuristic choice of DCT compression parameters - see bug 687174. */
 static int
 choose_DCT_params(gx_device *pdev, const gs_color_space *pcs,
                   const gs_imager_state * pis,
@@ -743,3 +743,149 @@ psdf_setup_image_colors_filter(psdf_binary_writer *pbw,
     }
     return 0;
 }
+
+/* Set up compression and downsampling filters for an image. */
+/* Note that this may modify the image parameters. */
+int
+new_setup_image_filters(gx_device_psdf * pdev, psdf_binary_writer * pbw,
+                         gs_pixel_image_t * pim, const gs_matrix * pctm,
+                         const gs_imager_state * pis, bool lossless, bool in_line,
+                         bool colour_conversion)
+{
+    /*
+     * The following algorithms are per Adobe Tech Note # 5151,
+     * "Acrobat Distiller Parameters", revised 16 September 1996
+     * for Acrobat(TM) Distiller(TM) 3.0.
+     *
+     * The control structure is a little tricky, because filter
+     * pipelines must be constructed back-to-front.
+     */
+    int code = 0;
+    psdf_image_params params;
+    int bpc = pim->BitsPerComponent;
+    int bpc_out = pim->BitsPerComponent = min(bpc, 8);
+    int ncomp;
+    double resolution;
+
+    /*
+     * The Adobe documentation doesn't say this, but mask images are
+     * compressed on the same basis as 1-bit-deep monochrome images,
+     * except that anti-aliasing (resolution/depth tradeoff) is not
+     * allowed.
+     */
+    if (pim->ColorSpace == NULL) { /* mask image */
+        params = pdev->params.MonoImage;
+        params.Depth = 1;
+        ncomp = 1;
+    } else {
+        ncomp = gs_color_space_num_components(pim->ColorSpace);
+        if (pim->ColorSpace->type->index == gs_color_space_index_Indexed) {
+            params = pdev->params.ColorImage;
+            /* Ensure we don't use JPEG on a /Indexed colour space */
+            params.AutoFilter = false;
+            params.Filter = "FlateEncode";
+        } else {
+            if (ncomp == 1) {
+                if (bpc == 1)
+                    params = pdev->params.MonoImage;
+                else
+                    params = pdev->params.GrayImage;
+                if (params.Depth == -1)
+                    params.Depth = bpc;
+            } else {
+                params = pdev->params.ColorImage;
+            /* params.Depth is reset below */
+            }
+        }
+    }
+
+    /*
+     * We can compute the image resolution by:
+     *    W / (W * ImageMatrix^-1 * CTM / HWResolution).
+     * We can replace W by 1 to simplify the computation.
+     */
+    if (pctm == 0)
+        resolution = -1;
+    else {
+        gs_point pt;
+
+        /* We could do both X and Y, but why bother? */
+        code = gs_distance_transform_inverse(1.0, 0.0, &pim->ImageMatrix, &pt);
+        if (code < 0)
+            return code;
+        gs_distance_transform(pt.x, pt.y, pctm, &pt);
+        resolution = 1.0 / hypot(pt.x / pdev->HWResolution[0],
+                                 pt.y / pdev->HWResolution[1]);
+    }
+    if (ncomp == 1 && pim->ColorSpace && pim->ColorSpace->type->index != gs_color_space_index_Indexed) {
+        /* Monochrome, gray, or mask */
+        /* Check for downsampling. */
+        if (do_downsample(&params, pim, resolution)) {
+            /* Use the downsampled depth, not the original data depth. */
+            if (params.Depth == 1) {
+                params.Filter = pdev->params.MonoImage.Filter;
+                params.filter_template = pdev->params.MonoImage.filter_template;
+                params.Dict = pdev->params.MonoImage.Dict;
+                adjust_auto_filter_strategy_mono(pdev, &params, pdev->params.MonoImage.Dict, pim, in_line);
+            } else {
+                params.Filter = pdev->params.GrayImage.Filter;
+                params.filter_template = pdev->params.GrayImage.filter_template;
+                params.Dict = pdev->params.GrayImage.Dict;
+                adjust_auto_filter_strategy(pdev, &params, pdev->params.GrayImage.Dict, pim, in_line);
+            }
+            code = setup_downsampling(pbw, &params, pim, pis, resolution, lossless);
+        } else {
+            adjust_auto_filter_strategy(pdev, &params, pdev->params.GrayImage.Dict, pim, in_line);
+            code = setup_image_compression(pbw, &params, pim, pis, lossless);
+        }
+        if (code < 0)
+            return code;
+        code = pixel_resize(pbw, pim->Width, ncomp, bpc, bpc_out);
+    } else {
+        /* Color */
+        if (params.Depth == -1)
+            params.Depth = (colour_conversion ? 8 : bpc_out);
+        if (do_downsample(&params, pim, resolution)) {
+            adjust_auto_filter_strategy(pdev, &params, pdev->params.ColorImage.Dict, pim, in_line);
+            code = setup_downsampling(pbw, &params, pim, pis, resolution, lossless);
+        } else {
+            adjust_auto_filter_strategy(pdev, &params, pdev->params.ColorImage.Dict, pim, in_line);
+            code = setup_image_compression(pbw, &params, pim, pis, lossless);
+        }
+        if (code < 0)
+            return code;
+        code = pixel_resize(pbw, pim->Width, ncomp, bpc, bpc_out);
+        if (code < 0)
+            return code;
+    }
+    return code;
+}
+
+int
+new_setup_lossless_filters(gx_device_psdf *pdev, psdf_binary_writer *pbw,
+                            gs_pixel_image_t *pim, bool in_line,
+                            bool colour_conversion)
+{
+    /*
+     * Set up a device with modified parameters for computing the image
+     * compression filters.  Don't allow downsampling or lossy compression.
+     */
+    gx_device_psdf ipdev;
+
+    ipdev = *pdev;
+    ipdev.params.ColorImage.AutoFilter = false;
+    ipdev.params.ColorImage.Downsample = false;
+    ipdev.params.ColorImage.Filter = "FlateEncode";
+    ipdev.params.ColorImage.filter_template = &s_zlibE_template;
+    ipdev.params.ConvertCMYKImagesToRGB = false;
+    ipdev.params.GrayImage.AutoFilter = false;
+    ipdev.params.GrayImage.Downsample = false;
+    ipdev.params.GrayImage.Filter = "FlateEncode";
+    ipdev.params.GrayImage.filter_template = &s_zlibE_template;
+    return new_setup_image_filters(&ipdev, pbw, pim, NULL, NULL, true, in_line, colour_conversion);
+}
+
+int new_resize_input(psdf_binary_writer *pbw, int width, int num_comps, int bpc_in, int bpc_out)
+{
+    return pixel_resize(pbw, width, num_comps, bpc_in, bpc_out);
+}
diff --git a/gs/base/gdevpsds.c b/gs/base/gdevpsds.c
index 94065bf3a..8c662b5ab 100644
--- a/gs/base/gdevpsds.c
+++ b/gs/base/gdevpsds.c
@@ -76,6 +76,15 @@ s_12_init(stream_state * st)
     ss->bits_per_sample = 12;   /* not needed */
     return 0;
 }
+static int
+s_16_init(stream_state * st)
+{
+    stream_1248_state *const ss = (stream_1248_state *) st;
+
+    ss->left = ss->samples_per_row;
+    ss->bits_per_sample = 16;   /* not needed */
+    return 0;
+}
 
 /* Process one buffer. */
 #define BEGIN_1248\
@@ -207,6 +216,22 @@ s_12_8_process(stream_state * st, stream_cursor_read * pr,
     END_1248;
 }
 
+/* 16-to-8 "expansion" */
+static int
+s_16_8_process(stream_state * st, stream_cursor_read * pr,
+               stream_cursor_write * pw, bool last)
+{
+    BEGIN_1248;
+
+    n = ss->samples_per_row;    /* misuse n to avoid a compiler warning */
+    status = 0;
+    for (; rlimit - p >= 2; ++q) {
+        q[1] = (byte)p[1];                /* Set output to the high byte of the input */
+        p+=2;                   /* Discard the low byte */
+    }
+    END_1248;
+}
+
 /* 8-to-N reduction */
 #define FOREACH_8_N(out, nin)\
         byte out;\
@@ -297,6 +322,9 @@ const stream_template s_4_8_template = {
 const stream_template s_12_8_template = {
     &st_1248_state, s_12_init, s_12_8_process, 1, 2
 };
+const stream_template s_16_8_template = {
+    &st_1248_state, s_16_init, s_16_8_process, 1, 2
+};
 
 const stream_template s_8_1_template = {
     &st_1248_state, s_1_init, s_8_N_process, 8, 1
@@ -1108,6 +1136,21 @@ s_image_colors_set_color_space(stream_image_colors_state * ss, gx_device *pdev,
     memcpy(ss->Decode, Decode, ss->depth * sizeof(Decode[0]) * 2);
 }
 
+void
+s_new_image_colors_set_color_space(stream_image_colors_state * ss, gx_device *pdev,
+                               const gs_color_space *pcs, const gs_imager_state *pis,
+                               float *Decode)
+{
+    ss->output_depth = pdev->color_info.num_components;
+    ss->output_component_index = ss->output_depth;
+    ss->output_bits_per_sample = pdev->color_info.comp_bits[0]; /* Same precision for all components. */
+    ss->convert_color = s_image_colors_convert_to_device_color;
+    ss->pdev = pdev;
+    ss->pcs = pcs;
+    ss->pis = pis;
+    memcpy(ss->Decode, Decode, ss->depth * sizeof(Decode[0]) * 2);
+}
+
 /* Process a buffer. */
 static int
 s_image_colors_process(stream_state * st, stream_cursor_read * pr,
diff --git a/gs/base/gdevpsds.h b/gs/base/gdevpsds.h
index 6d54c4e57..5917863b4 100644
--- a/gs/base/gdevpsds.h
+++ b/gs/base/gdevpsds.h
@@ -34,14 +34,15 @@ typedef struct stream_1248_state_s {
     uint left;                  /* # of samples left in current row */
 } stream_1248_state;
 
-/* Convert N (1, 2, 4, 12) bits to 8. */
+/* Convert N (1, 2, 4, 12, 16) bits to 8. */
 extern const stream_template s_1_8_template;
 extern const stream_template s_2_8_template;
 extern const stream_template s_4_8_template;
 extern const stream_template s_12_8_template;
+extern const stream_template s_16_8_template;
 
 /* Reduce 8 bits to N (1, 2, 4). */
-/* We do not currently support converting 8 bits to 12. */
+/* We do not currently support converting 8 bits to 12 or 16. */
 extern const stream_template s_8_1_template;
 extern const stream_template s_8_2_template;
 extern const stream_template s_8_4_template;
@@ -215,8 +216,6 @@ struct stream_image_colors_state_s {
     "stream_image_colors_state", stream_image_colors_enum_ptrs,\
     stream_image_colors_reloc_ptrs, pcs, pdev, pis)
 
-extern const stream_template s_image_colors_template;
-
 void s_image_colors_set_dimensions(stream_image_colors_state * st,
                                int width, int height, int depth, int bits_per_sample);
 
@@ -226,6 +225,10 @@ void s_image_colors_set_color_space(stream_image_colors_state * ss, gx_device *p
                                const gs_color_space *pcs, const gs_imager_state *pis,
                                float *Decode);
 
+void s_new_image_colors_set_color_space(stream_image_colors_state * ss, gx_device *pdev,
+                               const gs_color_space *pcs, const gs_imager_state *pis,
+                               float *Decode);
+
 extern const stream_template s__image_colors_template;
 
 #endif /* gdevpsds_INCLUDED */