Addition of support for allowing control over the use of black point compensation in color management

Black point compensation is a new extended graphic state entry in the extended graphic
state with PDF 2.0 .  This change adds it to the graphic state.  This update also allows
the same type of override control for black point that we currently have for the
rendering intent.   This includes specification of its use by source object type with
the use of -sSourceObjectICC for source RGB and CMYK graphic, images and text objects.
Alternatively, control can be achieved for the whole document via object type
by specification  -dBlackPtComp=0/1.  Alternatively, you can specify control
on an object based method using  -dGraphBlackPt=0/1
-dImageBlackPtComp=0/1  -dTextBlackPtComp=0/1.  All of these
will require the setting of -dOverrideBP to ensure that the document content does not
interfere with the command line setting.  Note that these are not true/false settings
but integer values like the rendering intent.  This is to allow the easy expansion
to other black point compensation options as described by Bug 692223.

27 files changed, 417 insertions, 99 deletions

diff --git a/gs/Resource/Init/gs_lev2.ps b/gs/Resource/Init/gs_lev2.ps
index baef96a49..5f6a12514 100644
--- a/gs/Resource/Init/gs_lev2.ps
+++ b/gs/Resource/Init/gs_lev2.ps
@@ -672,7 +672,7 @@ currentuserparams /WaitTimeout known
 
 mark    % collect dict key value pairs for anything set in systemdict (command line options)
 [ /DefaultRGBProfile /DefaultGrayProfile /DefaultCMYKProfile /DeviceNProfile
-  /NamedProfile /SourceObjectICC /OverrideICC /OverrideRI
+  /NamedProfile /SourceObjectICC /OverrideICC /OverrideRI /OverrideBP
 ]
 { dup //systemdict exch .knownget not {
     pop         % discard keys not in systemdict
diff --git a/gs/base/gdevp14.c b/gs/base/gdevp14.c
index ddc6d55e8..6be554d3a 100644
--- a/gs/base/gdevp14.c
+++ b/gs/base/gdevp14.c
@@ -901,7 +901,7 @@ pdf14_pop_transparency_group(gs_imager_state *pis, pdf14_ctx *ctx,
                 curr_icc_profile != NULL) {
                 /* Use the ICC color management for buffer color conversion */
                 /* Define the rendering intents */
-                rendering_params.black_point_comp = BP_ON;
+                rendering_params.black_point_comp = gsBLACKPTCOMP_ON;
                 rendering_params.graphics_type_tag = GS_IMAGE_TAG;
                 rendering_params.rendering_intent = gsPERCEPTUAL;
                 /* Request the ICC link for the transform that we will need to use */
@@ -1136,12 +1136,13 @@ pdf14_pop_transparency_mask(pdf14_ctx *ctx, gs_imager_state *pis, gx_device *dev
     gsicc_rendering_param_t rendering_params;
     gsicc_link_t *icc_link;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile;
 
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &src_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     ctx->smask_depth -= 1;
     /* icc_match == -1 means old non-icc code.
        icc_match == 0 means use icc code
@@ -1269,7 +1270,7 @@ pdf14_pop_transparency_mask(pdf14_ctx *ctx, gs_imager_state *pis, gx_device *dev
                 } else {
                     /* ICC case where we use the CMM */
                     /* Request the ICC link for the transform that we will need to use */
-                    rendering_params.black_point_comp = BP_OFF;
+                    rendering_params.black_point_comp = gsBLACKPTCOMP_OFF;
                     rendering_params.graphics_type_tag = GS_IMAGE_TAG;
                     rendering_params.rendering_intent = gsPERCEPTUAL;
                     icc_link = gsicc_get_link_profile(pis, dev, des_profile,
@@ -1549,6 +1550,7 @@ pdf14_put_image(gx_device * dev, gs_imager_state * pis, gx_device * target)
     bool data_blended = false;
     int num_rows_left;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     cmm_dev_profile_t *dev_profile;
 
     if_debug0m('v', dev->memory, "[v]pdf14_put_image\n");
@@ -1634,7 +1636,8 @@ pdf14_put_image(gx_device * dev, gs_imager_state * pis, gx_device * target)
        and the target will be CIELAB */
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile,
-                          &(pcs->cmm_icc_profile_data), &rendering_intent);
+                          &(pcs->cmm_icc_profile_data), &rendering_intent,
+                          &blackptcomp);
     /* pcs takes a reference to the profile data it just retrieved. */
     rc_increment(pcs->cmm_icc_profile_data);
     gscms_set_icc_range(&(pcs->cmm_icc_profile_data));
@@ -3397,13 +3400,14 @@ pdf14_begin_transparency_group(gx_device *dev,
     cmm_profile_t *curr_profile;
     cmm_profile_t *group_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     cmm_dev_profile_t *dev_profile;
 
     sep_target = (strcmp(pdev->dname, "pdf14cmykspot") == 0) ||
                  (dev_proc(dev, dev_spec_op)(dev, gxdso_supports_devn, NULL, 0));
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &group_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     /* If the target device supports separations, then
        we should should NOT create the group.  The exception to this
        rule would be if we just popped a transparency mask */
@@ -3496,11 +3500,12 @@ pdf14_end_transparency_group(gx_device *dev,
     pdf14_parent_color_t *parent_color;
     cmm_profile_t *group_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     cmm_dev_profile_t *dev_profile;
 
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &group_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     if_debug0m('v', dev->memory, "[v]pdf14_end_transparency_group\n");
     vd_get_dc('c');
     vd_set_shift(0, 0);
@@ -3573,6 +3578,7 @@ pdf14_update_device_color_procs(gx_device *dev,
     int k;
     bool has_tags = dev->graphics_type_tag & GS_DEVICE_ENCODES_TAGS;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile;
 
@@ -3725,7 +3731,7 @@ pdf14_update_device_color_procs(gx_device *dev,
             code = dev_proc(dev, get_profile)(dev,  &dev_profile);
             gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile,
                                   &(parent_color_info->icc_profile),
-                                  &rendering_intent);
+                                  &rendering_intent, &blackptcomp);
         }
         /* Set new information */
         /* If we are in a soft mask and we are using compressed color
@@ -3795,6 +3801,7 @@ pdf14_update_device_color_procs_push_c(gx_device *dev,
     bool has_tags = dev->graphics_type_tag & GS_DEVICE_ENCODES_TAGS;
     cmm_profile_t *icc_profile_dev;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile;
 
@@ -3868,7 +3875,7 @@ pdf14_update_device_color_procs_push_c(gx_device *dev,
                 /* Check if the profile is different. */
                 code = dev_proc(dev, get_profile)(dev,  &dev_profile);
                 gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &icc_profile_dev,
-                                      &rendering_intent);
+                                      &rendering_intent, &blackptcomp);
                 if (icc_profile_dev->hashcode != icc_profile->hashcode) {
                     update_color_info = true;
                     new_num_comps = icc_profile->num_comps;
@@ -4046,12 +4053,13 @@ pdf14_push_parent_color(gx_device *dev, const gs_imager_state *pis)
     pdf14_parent_color_t *new_parent_color;
     cmm_profile_t *icc_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile;
 
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &icc_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     if_debug0m('v', dev->memory, "[v]pdf14_push_parent_color\n");
     /* Allocate a new one */
     new_parent_color = gs_alloc_struct(dev->memory, pdf14_parent_color_t,
@@ -5011,11 +5019,12 @@ gs_pdf14_device_push(gs_memory_t *mem, gs_imager_state * pis,
     bool has_tags = target->graphics_type_tag & GS_DEVICE_ENCODES_TAGS;
     cmm_profile_t *icc_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     cmm_dev_profile_t *dev_profile;
 
     code = dev_proc(target, get_profile)(target,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &icc_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     if_debug0m('v', mem, "[v]gs_pdf14_device_push\n");
     code = get_pdf14_device_proto(target, &dev_proto,
                                  &temp_dev_proto, pis, pdf14pct);
@@ -5153,12 +5162,13 @@ c_pdf14trans_write(const gs_composite_t	* pct, byte * data, uint * psize,
     int64_t hashcode = 0;
     cmm_profile_t *icc_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     cmm_dev_profile_t *dev_profile;
 
     code = dev_proc((gx_device *) cdev, get_profile)((gx_device *) cdev,
                                                      &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &icc_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     *pbuf++ = opcode;                   /* 1 byte */
     switch (opcode) {
         default:                        /* Should not occur. */
@@ -6090,11 +6100,12 @@ pdf14_create_clist_device(gs_memory_t *mem, gs_imager_state * pis,
     bool has_tags = target->graphics_type_tag & GS_DEVICE_ENCODES_TAGS;
     cmm_profile_t *target_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     cmm_dev_profile_t *dev_profile;
 
     code = dev_proc(target, get_profile)(target,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &target_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     if_debug0m('v', pis->memory, "[v]pdf14_create_clist_device\n");
     code = get_pdf14_clist_device_proto(target, &dev_proto,
                                  &temp_dev_proto, pis, pdf14pct);
@@ -6869,15 +6880,16 @@ pdf14_clist_fill_path(gx_device	*dev, const gs_imager_state *pis,
     gx_device_forward * fdev = (gx_device_forward *)dev;
     cmm_dev_profile_t *dev_profile, *fwd_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     cmm_profile_t *icc_profile_fwd, *icc_profile_dev;
 
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     code = dev_proc(fdev->target, get_profile)(fdev->target,  &fwd_profile);
 
     gsicc_extract_profile(GS_UNKNOWN_TAG, fwd_profile, &icc_profile_fwd,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &icc_profile_dev,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
 
     /*
      * Ensure that that the PDF 1.4 reading compositor will have the current
@@ -7304,15 +7316,16 @@ c_pdf14trans_clist_read_update(gs_composite_t *	pcte, gx_device	* cdev,
     gx_device_clist_reader *pcrdev = (gx_device_clist_reader *)cdev;
     cmm_profile_t *cl_icc_profile, *p14_icc_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile;
 
     code = dev_proc(cdev, get_profile)(cdev,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &cl_icc_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     code = dev_proc(p14dev, get_profile)((gx_device *)p14dev,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &p14_icc_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
 
     /*
      * We only handle the push/pop operations. Save and restore the color_info
diff --git a/gs/base/gscms.h b/gs/base/gscms.h
index 96b462092..70f6bcf1a 100644
--- a/gs/base/gscms.h
+++ b/gs/base/gscms.h
@@ -122,7 +122,19 @@ typedef enum {
     gsABSOLUTECOLORIMETRIC_OR   /* in particular through the clist */
 } gsicc_rendering_intents_t;
 
+/* We make an enumerated type in case someone wants to add different types
+   of black point compensation.  Like lcms provides the option for. If 
+   any are added, be sure to add in the regular and the source overide 
+   option. Also not that we have at most 4 options due to gsBP_OVERRIDE  */
+typedef enum {
+    gsBLACKPTCOMP_OFF = 0,
+    gsBLACKPTCOMP_ON,
+    gsBLACKPTCOMP_OFF_OR = 4, /* These are needed for keeping track of the  */                                   
+    gsBLACKPTCOMP_ON_OR,      /* source blackpt is to overide dest. setting */
+} gsicc_blackptcomp_t;
+
 #define gsRI_OVERRIDE 0x4
+#define gsBP_OVERRIDE 0x4 
 #define gsRI_MASK 0x3;
 
 /* Enumerate the types of profiles */
@@ -146,8 +158,10 @@ typedef enum {
 typedef struct cmm_srcgtag_profile_s {
         cmm_profile_t  *rgb_profiles[NUM_SOURCE_PROFILES];
         gsicc_rendering_intents_t rgb_intent[NUM_SOURCE_PROFILES];
+        gsicc_blackptcomp_t rgb_blackptcomp[NUM_SOURCE_PROFILES];
         cmm_profile_t  *cmyk_profiles[NUM_SOURCE_PROFILES];
         gsicc_rendering_intents_t cmyk_intent[NUM_SOURCE_PROFILES];
+        gsicc_blackptcomp_t cmyk_blackptcomp[NUM_SOURCE_PROFILES];
         cmm_profile_t  *color_warp_profile;
         gs_memory_t *memory;
         int name_length;            /* Length of file name */
@@ -189,6 +203,7 @@ typedef struct cmm_dev_profile_s {
         cmm_profile_t  *link_profile;
         cmm_profile_t  *oi_profile;  /* output intent profile */
         gsicc_rendering_intents_t intent[NUM_DEVICE_PROFILES];
+        gsicc_blackptcomp_t blackptcomp[NUM_DEVICE_PROFILES];
         bool devicegraytok;        /* Used for forcing gray to pure black */
         bool usefastcolor;         /* Used when we want to use no cm */
         bool supports_devn;        /* If the target handles devn colors */
@@ -198,15 +213,6 @@ typedef struct cmm_dev_profile_s {
         rc_header rc;
 } cmm_dev_profile_t;
 
-/*  Doing this an an enum type for now.  There is alot going on with respect
- *  to this and V2 versus V4 profiles
- */
-
-typedef enum {
-    BP_ON = 0,
-    BP_OFF,
-} gsicc_black_point_comp_t;
-
 /*  Used so that we can specify if we want to link with Device input color spaces
     during the link creation process. For the DeviceN case, the DeviceN profile
     must match the DeviceN profile in colorant order and number of colorants.
@@ -214,7 +220,6 @@ typedef enum {
     the icc manager.  This is useful for reducing clist size since we will encode
     this value instead of the ICC profile.
 */
-
 typedef enum {
     DEFAULT_NONE,   /* A profile that was actually embedded in a doc */
     DEFAULT_GRAY,   /* The default DeviceGray profile */
@@ -424,6 +429,7 @@ typedef struct gsicc_manager_s {
     gsicc_smask_t *smask_profiles;  /* Profiles used when we are in a softmask group */
     bool override_internal;         /* Set via the user params */
     bool override_ri;               /* Override rend intent. Set via the user params */
+    bool override_bp;               /* Override black point setting.  Set via user params */
     cmm_srcgtag_profile_t *srcgtag_profile;
     gs_memory_t *memory;
     rc_header rc;
@@ -444,7 +450,7 @@ typedef enum {
 typedef struct gsicc_rendering_param_s {
     gsicc_rendering_intents_t rendering_intent;
     gs_graphics_type_tag_t    graphics_type_tag;
-    gsicc_black_point_comp_t  black_point_comp;
+    gsicc_blackptcomp_t       black_point_comp;
 } gsicc_rendering_param_t;
 
 #endif /* ifndef gscms_INCLUDED */
diff --git a/gs/base/gscsepr.c b/gs/base/gscsepr.c
index 57ff898bd..1715b2d5c 100644
--- a/gs/base/gscsepr.c
+++ b/gs/base/gscsepr.c
@@ -328,7 +328,7 @@ gx_concretize_Separation(const gs_client_color *pc, const gs_color_space *pcs,
             gsicc_rendering_param_t rendering_params;
 
             /* Define the rendering intents. */
-            rendering_params.black_point_comp = BP_ON;
+            rendering_params.black_point_comp = pis->blackptcomp;
             rendering_params.graphics_type_tag = GS_PATH_TAG;
             rendering_params.rendering_intent = pis->renderingintent;
 
diff --git a/gs/base/gscspace.c b/gs/base/gscspace.c
index 756184c58..072064f72 100644
--- a/gs/base/gscspace.c
+++ b/gs/base/gscspace.c
@@ -613,10 +613,11 @@ int gx_set_overprint_cmyk(const gs_color_space * pcs, gs_state * pgs)
     int                     code;
     bool                    profile_ok = false;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
 
     code = dev_proc(dev, get_profile)(dev, &dev_profile);
     gsicc_extract_profile(dev->graphics_type_tag, dev_profile, &(output_profile),
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
 
     /* check if color model behavior must be determined */
     if (pcinfo->opmode == GX_CINFO_OPMODE_UNKNOWN)
diff --git a/gs/base/gsdparam.c b/gs/base/gsdparam.c
index d6794b200..fa368f623 100644
--- a/gs/base/gsdparam.c
+++ b/gs/base/gsdparam.c
@@ -13,7 +13,6 @@
    CA  94903, U.S.A., +1(415)492-9861, for further information.
 */
 
-
 /* Default device parameters for Ghostscript library */
 #include "memory_.h"            /* for memcpy */
 #include "string_.h"            /* for strlen */
@@ -25,11 +24,6 @@
 #include "gxfixed.h"
 #include "gsicc_manage.h"
 
-
-static const char *const std_intent_keys[] = {
-        GSICC_STANDARD_INTENT_KEYS
-    };
-
 /* Define whether we accept PageSize as a synonym for MediaSize. */
 /* This is for backward compatibility only. */
 #define PAGESIZE_IS_MEDIASIZE
@@ -82,6 +76,7 @@ gx_default_get_params(gx_device * dev, gs_param_list * plist)
     gs_param_string dns, pcms, profile_array[NUM_DEVICE_PROFILES];
     gs_param_string proof_profile, link_profile, icc_colorants;
     gsicc_rendering_intents_t profile_intents[NUM_DEVICE_PROFILES];
+    gsicc_blackptcomp_t blackptcomps[NUM_DEVICE_PROFILES];
     bool devicegraytok = true;  /* Default if device profile stuct not set */
     bool usefastcolor = false;  /* set for unmanaged color */
     bool prebandthreshold = true;
@@ -147,10 +142,12 @@ gx_default_get_params(gx_device * dev, gs_param_list * plist)
                 || dev_profile->device_profile[k]->name == NULL) {
                 param_string_from_string(profile_array[k], null_str);
                 profile_intents[k] = gsPERCEPTUAL;
+                blackptcomps[k] = gsBLACKPTCOMP_ON;
             } else {
                 param_string_from_string(profile_array[k], 
                     dev_profile->device_profile[k]->name);
                 profile_intents[k] = dev_profile->intent[k];
+                blackptcomps[k] = dev_profile->blackptcomp[k];
             }
         }
         /* The proof and link profile */
@@ -189,6 +186,7 @@ gx_default_get_params(gx_device * dev, gs_param_list * plist)
         for (k = 0; k < NUM_DEVICE_PROFILES; k++) {
             param_string_from_string(profile_array[k], null_str);
             profile_intents[k] = gsPERCEPTUAL;
+            blackptcomps[k] = gsBLACKPTCOMP_ON;
         }
         param_string_from_string(proof_profile, null_str);
         param_string_from_string(link_profile, null_str);
@@ -234,6 +232,10 @@ gx_default_get_params(gx_device * dev, gs_param_list * plist)
         (code = param_write_int(plist,"GraphicIntent", (const int *) &(profile_intents[1]))) < 0 ||
         (code = param_write_int(plist,"ImageIntent", (const int *) &(profile_intents[2]))) < 0 ||
         (code = param_write_int(plist,"TextIntent", (const int *) &(profile_intents[3]))) < 0 ||
+        (code = param_write_int(plist,"BlackPtComp", (const int *) (&(blackptcomps[0])))) < 0 ||
+        (code = param_write_int(plist,"GraphBlackPt", (const int *) &(blackptcomps[1]))) < 0 ||
+        (code = param_write_int(plist,"ImageBlackPt", (const int *) &(blackptcomps[2]))) < 0 ||
+        (code = param_write_int(plist,"TextBlackPt", (const int *) &(blackptcomps[3]))) < 0 ||
         (code = param_write_int_array(plist, "HWSize", &hwsa)) < 0 ||
         (code = param_write_float_array(plist, ".HWMargins", &hwma)) < 0 ||
         (code = param_write_float_array(plist, ".MarginsHWResolution", &mhwra)) < 0 ||
@@ -591,7 +593,7 @@ gx_default_put_usefastcolor(bool fastcolor, gx_device * dev)
 }
 
 static void
-gx_default_put_intent(gsicc_profile_types_t icc_intent, gx_device * dev,  
+gx_default_put_intent(gsicc_rendering_intents_t icc_intent, gx_device * dev,  
                    gsicc_profile_types_t index) 
 {
     int code;
@@ -618,6 +620,33 @@ gx_default_put_intent(gsicc_profile_types_t icc_intent, gx_device * dev,
 }
 
 static void
+gx_default_put_blackptcomp(gsicc_blackptcomp_t blackptcomp, gx_device * dev,  
+                           gsicc_profile_types_t index) 
+{
+    int code;
+    cmm_dev_profile_t *profile_struct;
+
+    if (dev->procs.get_profile == NULL) {
+        /* This is an odd case where the device has not yet fully been 
+           set up with its procedures yet.  We want to make sure that
+           we catch this so we assume here that we are dealing with 
+           the target device */
+        if (dev->icc_struct == NULL) {
+            /* Intializes the device structure.  Not the profile though for index */
+            dev->icc_struct = gsicc_new_device_profile_array(dev->memory);
+        }
+        code = gsicc_set_device_blackptcomp(dev, blackptcomp, index);
+    } else {
+        code = dev_proc(dev, get_profile)(dev,  &profile_struct);
+        if (profile_struct == NULL) {
+            /* Create now  */
+            dev->icc_struct = gsicc_new_device_profile_array(dev->memory);
+        }
+        code = gsicc_set_device_blackptcomp(dev, blackptcomp, index);
+    }
+}
+
+static void
 gx_default_put_icc_colorants(gs_param_string *colorants, gx_device * dev)
 {
     char *tempstr;
@@ -697,16 +726,28 @@ gx_default_put_params(gx_device * dev, gs_param_list * plist)
     int gab = dev->color_info.anti_alias.graphics_bits;
     int mpbm = dev->MaxPatternBitmap;
     int rend_intent[NUM_DEVICE_PROFILES];
+    int blackptcomp[NUM_DEVICE_PROFILES];
     gs_param_string cms;
     int leadingedge = dev->LeadingEdge;
     int k;
     bool devicegraytok = true;
     bool usefastcolor = false;
     bool prebandthreshold = false;
-
+    bool rend_intent_set[NUM_DEVICE_PROFILES];  /* needed so that global forces */
+    bool blackptcomp_set[NUM_DEVICE_PROFILES];  /* all the types if no types set */
+    int  profile_types[NUM_DEVICE_PROFILES] = {gsDEFAULTPROFILE,
+                                               gsGRAPHICPROFILE,
+                                               gsIMAGEPROFILE,
+                                               gsTEXTPROFILE}; 
+
+    for (k = 0; k < NUM_DEVICE_PROFILES; k++) {
+        rend_intent_set[k] = false;
+        blackptcomp_set[k] = false;
+    }
     if (dev->icc_struct != NULL) {
         for (k = 0; k < NUM_DEVICE_PROFILES; k++) {
             rend_intent[k] = dev->icc_struct->intent[k];
+            blackptcomp[k] = dev->icc_struct->blackptcomp[k];
         }
         devicegraytok = dev->icc_struct->devicegraytok;
         usefastcolor = dev->icc_struct->usefastcolor;
@@ -714,6 +755,7 @@ gx_default_put_params(gx_device * dev, gs_param_list * plist)
     } else {
         for (k = 0; k < NUM_DEVICE_PROFILES; k++) {
             rend_intent[k] = gsPERCEPTUAL;
+            blackptcomp[k] = gsBLACKPTCOMP_ON;
         }
     }
 
@@ -918,21 +960,57 @@ nce:
                                                     &(rend_intent[0]))) < 0) {
         ecode = code;
         param_signal_error(plist, param_name, ecode);
+    } else if (code == 0) {
+        rend_intent_set[0] = true;
     }
     if ((code = param_read_int(plist, (param_name = "GraphicIntent"), 
                                                     &(rend_intent[1]))) < 0) {
         ecode = code;
         param_signal_error(plist, param_name, ecode);
+    } else if (code == 0) {
+        rend_intent_set[1] = true;
     }
     if ((code = param_read_int(plist, (param_name = "ImageIntent"), 
                                                     &(rend_intent[2]))) < 0) {
         ecode = code;
         param_signal_error(plist, param_name, ecode);
+    } else if (code == 0) {
+        rend_intent_set[2] = true;
     }
     if ((code = param_read_int(plist, (param_name = "TextIntent"), 
                                                     &(rend_intent[3]))) < 0) {
         ecode = code;
         param_signal_error(plist, param_name, ecode);
+    } else if (code == 0) {
+        rend_intent_set[3] = true;
+    }
+    if ((code = param_read_int(plist, (param_name = "BlackPtComp"), 
+                                                    &(blackptcomp[0]))) < 0) {
+        ecode = code;
+        param_signal_error(plist, param_name, ecode);
+    } else if (code == 0) {
+        blackptcomp_set[0] = true;
+    }
+    if ((code = param_read_int(plist, (param_name = "GraphBlackPt"), 
+                                                    &(blackptcomp[1]))) < 0) {
+        ecode = code;
+        param_signal_error(plist, param_name, ecode);
+    } else if (code == 0) {
+        blackptcomp_set[1] = true;
+    }
+    if ((code = param_read_int(plist, (param_name = "ImageBlackPt"), 
+                                                    &(blackptcomp[2]))) < 0) {
+        ecode = code;
+        param_signal_error(plist, param_name, ecode);
+    } else if (code == 0) {
+        blackptcomp_set[2] = true;
+    }
+    if ((code = param_read_int(plist, (param_name = "TextBlackPt"), 
+                                                    &(blackptcomp[3]))) < 0) {
+        ecode = code;
+        param_signal_error(plist, param_name, ecode);
+    } else if (code == 0) {
+        blackptcomp_set[3] = true;
     }
     if ((code = param_read_bool(plist, (param_name = "DeviceGrayToK"), 
                                                         &devicegraytok)) < 0) {
@@ -1142,12 +1220,27 @@ nce:
     dev->MaxPatternBitmap = mpbm;
     gx_device_decache_colors(dev);
 
-    /* Take care of the rendering intents */
+    /* Take care of the rendering intents and blackpts.  For those that
+       are not set special, the default provides an override */
     if (dev->icc_struct != NULL) {
+        /* Set the default object */
         gx_default_put_intent(rend_intent[0], dev, gsDEFAULTPROFILE); 
-        gx_default_put_intent(rend_intent[1], dev, gsGRAPHICPROFILE); 
-        gx_default_put_intent(rend_intent[2], dev, gsIMAGEPROFILE); 
-        gx_default_put_intent(rend_intent[3], dev, gsTEXTPROFILE); 
+        gx_default_put_blackptcomp(blackptcomp[0], dev, gsDEFAULTPROFILE);
+
+        /* If the default was specified and not a specialized one (e.g. graphic
+           image or text) then the special one will get set to the default */
+        for (k = 1; k < NUM_DEVICE_PROFILES; k++) {
+            if (rend_intent_set[0] && !rend_intent_set[k]) {
+                gx_default_put_intent(rend_intent[0], dev, profile_types[k]);
+            } else {
+                gx_default_put_intent(rend_intent[k], dev, profile_types[k]);
+            }
+            if (blackptcomp_set[0] && !blackptcomp_set[k]) {
+                gx_default_put_blackptcomp(blackptcomp[0], dev, profile_types[k]); 
+            } else {
+                gx_default_put_blackptcomp(blackptcomp[k], dev, profile_types[k]); 
+            }
+        }
     }
     gx_default_put_graytok(devicegraytok, dev);
     gx_default_put_usefastcolor(usefastcolor, dev);
diff --git a/gs/base/gsequivc.c b/gs/base/gsequivc.c
index 84dd1007f..8d105e2fe 100644
--- a/gs/base/gsequivc.c
+++ b/gs/base/gsequivc.c
@@ -453,6 +453,7 @@ capture_spot_equivalent_cmyk_colors(gx_device * pdev, const gs_state * pgs,
     color_capture_device temp_device = { 0 };
     gx_device_color dev_color;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile;
     cmm_profile_t *curr_output_profile;
@@ -461,7 +462,7 @@ capture_spot_equivalent_cmyk_colors(gx_device * pdev, const gs_state * pgs,
     code = dev_proc(pdev, get_profile)(pdev, &dev_profile);
     gsicc_extract_profile(pdev->graphics_type_tag,
                           dev_profile, &(curr_output_profile),
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     /*
      * Create a temp device.  The primary purpose of this device is pass the
      * separation number and a pointer to the original device's equivalent
diff --git a/gs/base/gsicc.c b/gs/base/gsicc.c
index aa202c41e..245fe7b87 100644
--- a/gs/base/gsicc.c
+++ b/gs/base/gsicc.c
@@ -355,7 +355,7 @@ gx_remap_ICC(const gs_client_color * pcc, const gs_color_space * pcs,
 
     code = dev_proc(dev, get_profile)(dev, &dev_profile);
     num_des_comps = gsicc_get_device_profile_comps(dev_profile);
-    rendering_params.black_point_comp = BP_ON;
+    rendering_params.black_point_comp = pis->blackptcomp;
     rendering_params.graphics_type_tag = dev->graphics_type_tag;
     /* Need to figure out which one rules here on rendering intent.  The
        source of the device */
@@ -444,7 +444,7 @@ gx_remap_ICC_imagelab(const gs_client_color * pcc, const gs_color_space * pcs,
 
     code = dev_proc(dev, get_profile)(dev, &dev_profile);
     num_des_comps = gsicc_get_device_profile_comps(dev_profile);
-    rendering_params.black_point_comp = BP_ON;
+    rendering_params.black_point_comp = pis->blackptcomp;
     rendering_params.graphics_type_tag = dev->graphics_type_tag;
     /* Need to figure out which one rules here on rendering intent.  The
        source of the device */
@@ -511,7 +511,7 @@ gx_concretize_ICC(
     code = dev_proc(dev, get_profile)(dev, &dev_profile);
     num_des_comps = gsicc_get_device_profile_comps(dev_profile);
     /* Define the rendering intents.  MJV to fix */
-    rendering_params.black_point_comp = BP_ON;
+    rendering_params.black_point_comp = pis->blackptcomp;
     rendering_params.graphics_type_tag = dev->graphics_type_tag;
     rendering_params.rendering_intent = pis->renderingintent;
     for (k = 0; k < pcs->cmm_icc_profile_data->num_comps; k++) {
diff --git a/gs/base/gsicc_cache.c b/gs/base/gsicc_cache.c
index 6539f8561..533654007 100644
--- a/gs/base/gsicc_cache.c
+++ b/gs/base/gsicc_cache.c
@@ -316,12 +316,13 @@ gsicc_get_cspace_hash(gsicc_manager_t *icc_manager, gx_device *dev,
     cmm_dev_profile_t *dev_profile;
     cmm_profile_t *icc_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t blackptcomp;
     int code;
 
     if (cmm_icc_profile_data == NULL ) {
         code = dev_proc(dev, get_profile)(dev,  &dev_profile);
         gsicc_extract_profile(dev->graphics_type_tag, dev_profile,
-                               &(icc_profile), &rendering_intent);
+                               &(icc_profile), &rendering_intent, &blackptcomp);
         *hash = icc_profile->hashcode;
         return;
     }
@@ -455,6 +456,7 @@ gsicc_get_link(const gs_imager_state *pis, gx_device *dev_in,
     gs_state *pgs;
     gx_device *dev;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t blackptcomp;
     bool use_src_intent = false;
     cmm_dev_profile_t *dev_profile;
     int code;
@@ -483,14 +485,16 @@ gsicc_get_link(const gs_imager_state *pis, gx_device *dev_in,
                     gsicc_get_srcprofile(gs_input_profile->data_cs,
                                       dev->graphics_type_tag,
                                       pis->icc_manager->srcgtag_profile,
-                                      &(gs_srcgtag_profile), &rendering_intent);
+                                      &(gs_srcgtag_profile), &rendering_intent,
+                                      &blackptcomp);
                 if (gs_srcgtag_profile != NULL) {
                     /* In this case, the user is letting the source profiles
                        drive the color management.  Let that set the 
-                       rendering intent too as they must know what they 
-                       are doing. */
+                       rendering intent and blackpoint compensation also as they 
+                       must know what they are doing. */
                     gs_input_profile = gs_srcgtag_profile;
-                    rendering_params->rendering_intent = rendering_intent; 
+                    rendering_params->rendering_intent = rendering_intent;
+                    rendering_params->black_point_comp = blackptcomp;
                     use_src_intent = true;
                 }
             }
@@ -500,8 +504,9 @@ gsicc_get_link(const gs_imager_state *pis, gx_device *dev_in,
         devicegraytok = false;
     } else {
         /* Use the device profile. Only use the rendering intent if override_ri
-           is set. Note that this can conflict with intents set from the source
-           objects so the user needs to understand what options to set.  */
+           is set. Also, only use the blackpoint if overide_bp is set.
+           Note that this can conflict with intents set from the source
+           objects so the user needs to understand what options to set. */
         gs_color_space_index index = 
                             gsicc_get_default_type(gs_input_profile);
         code = dev_proc(dev, get_profile)(dev,  &dev_profile);
@@ -520,8 +525,9 @@ gsicc_get_link(const gs_imager_state *pis, gx_device *dev_in,
             }
         }
         gsicc_extract_profile(dev->graphics_type_tag, dev_profile,
-                               &(gs_output_profile), &rendering_intent);
-        /* Check if the incoming rendering itent was source based
+                               &(gs_output_profile), &rendering_intent, 
+                               &blackptcomp);
+        /* Check if the incoming rendering intent was source based
            (this can occur for high level images in the clist) in
            that case we need to use the source ri and not the device one */
         if (!(rendering_params->rendering_intent & gsRI_OVERRIDE)) {
@@ -529,6 +535,12 @@ gsicc_get_link(const gs_imager_state *pis, gx_device *dev_in,
                 rendering_params->rendering_intent = rendering_intent;      
             }
         }
+        /* Similar to the black point compensation */
+        if (!(rendering_params->black_point_comp & gsBP_OVERRIDE)) {
+            if (pis->icc_manager != NULL && pis->icc_manager->override_bp == true) {
+                rendering_params->black_point_comp = blackptcomp;      
+            }
+        }
         devicegraytok = dev_profile->devicegraytok;
     }
     /* If we are going from DeviceGray to DeviceCMYK and devicegraytok
@@ -938,6 +950,7 @@ gsicc_transform_named_color(float tint_value, byte *color_name, uint name_size,
     gsicc_link_t *icc_link;
     cmm_profile_t *curr_output_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t blackptcomp;
     cmm_dev_profile_t *dev_profile;
 
     /* Check if the data that we have has already been generated. */
@@ -1066,7 +1079,7 @@ gsicc_transform_named_color(float tint_value, byte *color_name, uint name_size,
                     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
                     gsicc_extract_profile(dev->graphics_type_tag,
                                           dev_profile, &(curr_output_profile),
-                                          &rendering_intent);
+                                          &rendering_intent, &blackptcomp);
                 }
                 icc_link = gsicc_get_link_profile(pis, dev,
                                                 pis->icc_manager->lab_profile,
diff --git a/gs/base/gsicc_lcms2.c b/gs/base/gsicc_lcms2.c
index 7f09dd0b6..7f167eeb9 100644
--- a/gs/base/gsicc_lcms2.c
+++ b/gs/base/gsicc_lcms2.c
@@ -330,6 +330,7 @@ gscms_get_link(gcmmhprofile_t  lcms_srchandle,
     cmsColorSpaceSignature src_color_space,des_color_space;
     int src_nChannels,des_nChannels;
     int lcms_src_color_space, lcms_des_color_space;
+    unsigned int flag;
 
     /* Check for case of request for a transfrom from a device link profile
        in that case, the destination profile is NULL */
@@ -363,11 +364,15 @@ gscms_get_link(gcmmhprofile_t  lcms_srchandle,
     des_data_type = des_data_type | ENDIAN16_SH(1);
 #endif
 /* Create the link */
-    return(cmsCreateTransformTHR((cmsContext)memory,
+    flag = cmsFLAGS_HIGHRESPRECALC;
+    if (rendering_params->black_point_comp == gsBLACKPTCOMP_ON
+        || rendering_params->black_point_comp == gsBLACKPTCOMP_ON_OR) {
+        flag = (flag | cmsFLAGS_BLACKPOINTCOMPENSATION);
+    }
+    return cmsCreateTransformTHR((cmsContext)memory,
                lcms_srchandle, src_data_type,
                lcms_deshandle, des_data_type,
-               rendering_params->rendering_intent,
-               (cmsFLAGS_BLACKPOINTCOMPENSATION | cmsFLAGS_HIGHRESPRECALC)));
+               rendering_params->rendering_intent,flag);
     /* cmsFLAGS_HIGHRESPRECALC)  cmsFLAGS_NOTPRECALC  cmsFLAGS_LOWRESPRECALC*/
 }
 
@@ -387,6 +392,7 @@ gscms_get_link_proof_devlink(gcmmhprofile_t lcms_srchandle,
     int lcms_src_color_space, lcms_des_color_space;
     cmsHPROFILE hProfiles[5]; 
     int nProfiles = 0;
+    unsigned int flag;
 
    /* First handle all the source stuff */
     src_color_space  = cmsGetColorSpace(lcms_srchandle);
@@ -420,10 +426,14 @@ gscms_get_link_proof_devlink(gcmmhprofile_t lcms_srchandle,
     if (lcms_devlinkhandle != NULL) {
         hProfiles[nProfiles++] = lcms_devlinkhandle;
     }
-    return(cmsCreateMultiprofileTransformTHR((cmsContext)memory,
+    flag = cmsFLAGS_HIGHRESPRECALC;
+    if (rendering_params->black_point_comp == gsBLACKPTCOMP_ON
+        || rendering_params->black_point_comp == gsBLACKPTCOMP_ON_OR) {
+        flag = (flag | cmsFLAGS_BLACKPOINTCOMPENSATION);
+    }
+    return cmsCreateMultiprofileTransformTHR((cmsContext)memory,
                 hProfiles, nProfiles, src_data_type,
-                des_data_type, rendering_params->rendering_intent,
-                (cmsFLAGS_BLACKPOINTCOMPENSATION | cmsFLAGS_HIGHRESPRECALC)));
+                des_data_type, rendering_params->rendering_intent, flag);
 }
 
 /* Do any initialization if needed to the CMS */
diff --git a/gs/base/gsicc_manage.c b/gs/base/gsicc_manage.c
index 474e55826..71d5d0b1c 100644
--- a/gs/base/gsicc_manage.c
+++ b/gs/base/gsicc_manage.c
@@ -463,6 +463,7 @@ gsicc_set_srcgtag_struct(gsicc_manager_t *icc_manager, const char* pname,
     static const char *const srcgtag_keys[] = {GSICC_SRCGTAG_KEYS};
     cmm_profile_t *icc_profile;
     int ri;
+    int blackptcomp;
     cmm_srcgtag_profile_t *srcgtag;
     bool start = true;
 
@@ -552,6 +553,11 @@ gsicc_set_srcgtag_struct(gsicc_manager_t *icc_manager, const char* pname,
                     curr_ptr = strtok(NULL, "\t,\32\n\r");
                     count = sscanf(curr_ptr, "%d", &ri);
                     srcgtag->cmyk_intent[gsSRC_GRAPPRO] = ri | gsRI_OVERRIDE;
+                    /* Get the black point compensation setting */
+                    curr_ptr = strtok(NULL, "\t,\32\n\r");
+                    count = sscanf(curr_ptr, "%d", &blackptcomp);
+                    srcgtag->cmyk_blackptcomp[gsSRC_GRAPPRO] = 
+                                            blackptcomp | gsBP_OVERRIDE;
                     break;
                 case IMAGE_CMYK:
                     srcgtag->cmyk_profiles[gsSRC_IMAGPRO] = icc_profile;
@@ -559,6 +565,11 @@ gsicc_set_srcgtag_struct(gsicc_manager_t *icc_manager, const char* pname,
                     curr_ptr = strtok(NULL, "\t,\32\n\r");
                     count = sscanf(curr_ptr, "%d", &ri);
                     srcgtag->cmyk_intent[gsSRC_IMAGPRO] = ri | gsRI_OVERRIDE;
+                    /* Get the black point compensation setting */
+                    curr_ptr = strtok(NULL, "\t,\32\n\r");
+                    count = sscanf(curr_ptr, "%d", &blackptcomp);
+                    srcgtag->cmyk_blackptcomp[gsSRC_IMAGPRO] = 
+                                            blackptcomp | gsBP_OVERRIDE;
                     break;
                 case TEXT_CMYK:
                     srcgtag->cmyk_profiles[gsSRC_TEXTPRO] = icc_profile;
@@ -566,6 +577,11 @@ gsicc_set_srcgtag_struct(gsicc_manager_t *icc_manager, const char* pname,
                     curr_ptr = strtok(NULL, "\t,\32\n\r");
                     count = sscanf(curr_ptr, "%d", &ri);
                     srcgtag->cmyk_intent[gsSRC_TEXTPRO] = ri | gsRI_OVERRIDE;
+                    /* Get the black point compensation setting */
+                    curr_ptr = strtok(NULL, "\t,\32\n\r");
+                    count = sscanf(curr_ptr, "%d", &blackptcomp);
+                    srcgtag->cmyk_blackptcomp[gsSRC_TEXTPRO] = 
+                                            blackptcomp | gsBP_OVERRIDE;
                     break;
                 case GRAPHIC_RGB:
                     srcgtag->rgb_profiles[gsSRC_GRAPPRO] = icc_profile;
@@ -573,6 +589,11 @@ gsicc_set_srcgtag_struct(gsicc_manager_t *icc_manager, const char* pname,
                     curr_ptr = strtok(NULL, "\t,\32\n\r");
                     count = sscanf(curr_ptr, "%d", &ri);
                     srcgtag->rgb_intent[gsSRC_GRAPPRO] = ri | gsRI_OVERRIDE;
+                    /* Get the black point compensation setting */
+                    curr_ptr = strtok(NULL, "\t,\32\n\r");
+                    count = sscanf(curr_ptr, "%d", &blackptcomp);
+                    srcgtag->rgb_blackptcomp[gsSRC_GRAPPRO] = 
+                                            blackptcomp | gsBP_OVERRIDE;
                    break;
                 case IMAGE_RGB:
                     srcgtag->rgb_profiles[gsSRC_IMAGPRO] = icc_profile;
@@ -580,6 +601,11 @@ gsicc_set_srcgtag_struct(gsicc_manager_t *icc_manager, const char* pname,
                     curr_ptr = strtok(NULL, "\t,\32\n\r");
                     count = sscanf(curr_ptr, "%d", &ri);
                     srcgtag->rgb_intent[gsSRC_IMAGPRO] = ri | gsRI_OVERRIDE;
+                    /* Get the black point compensation setting */
+                    curr_ptr = strtok(NULL, "\t,\32\n\r");
+                    count = sscanf(curr_ptr, "%d", &blackptcomp);
+                    srcgtag->rgb_blackptcomp[gsSRC_IMAGPRO] = 
+                                            blackptcomp | gsBP_OVERRIDE;
                     break;
                 case TEXT_RGB:
                     srcgtag->rgb_profiles[gsSRC_TEXTPRO] = icc_profile;
@@ -587,6 +613,11 @@ gsicc_set_srcgtag_struct(gsicc_manager_t *icc_manager, const char* pname,
                     curr_ptr = strtok(NULL, "\t,\32\n\r");
                     count = sscanf(curr_ptr, "%d", &ri);
                     srcgtag->rgb_intent[gsSRC_TEXTPRO] = ri | gsRI_OVERRIDE;
+                    /* Get the black point compensation setting */
+                    curr_ptr = strtok(NULL, "\t,\32\n\r");
+                    count = sscanf(curr_ptr, "%d", &blackptcomp);
+                    srcgtag->rgb_blackptcomp[gsSRC_TEXTPRO] = 
+                                            blackptcomp | gsBP_OVERRIDE;
                     break;
                 case GSICC_NUM_SRCGTAG_KEYS:
                     /* Failed to match the key */
@@ -1081,6 +1112,7 @@ gsicc_new_device_profile_array(gs_memory_t *memory)
     for (k = 0; k < NUM_DEVICE_PROFILES; k++) {
         result->device_profile[k] = NULL;
         result->intent[k] = gsPERCEPTUAL;
+        result->blackptcomp[k] = gsBLACKPTCOMP_ON;
     }
     result->proof_profile = NULL;
     result->link_profile = NULL;
@@ -1095,7 +1127,7 @@ gsicc_new_device_profile_array(gs_memory_t *memory)
 }
 
 int
-gsicc_set_device_profile_intent(gx_device *dev, gsicc_profile_types_t intent,
+gsicc_set_device_profile_intent(gx_device *dev, gsicc_rendering_intents_t intent,
                                 gsicc_profile_types_t profile_type)
 {
     int code;
@@ -1112,6 +1144,24 @@ gsicc_set_device_profile_intent(gx_device *dev, gsicc_profile_types_t intent,
     return 0;
 }
 
+int
+gsicc_set_device_blackptcomp(gx_device *dev, gsicc_blackptcomp_t blackptcomp,
+                                gsicc_profile_types_t profile_type)
+{
+    int code;
+    cmm_dev_profile_t *profile_struct;
+   
+    if (dev->procs.get_profile == NULL) {
+        profile_struct = dev->icc_struct;
+    } else {
+        code = dev_proc(dev, get_profile)(dev,  &profile_struct);
+    }
+    if (profile_struct ==  NULL)
+        return 0;
+    profile_struct->blackptcomp[profile_type] = blackptcomp;
+    return 0;
+}
+
 /* This is used to set up the equivalent cmyk colors for the spots that may
    exist in an output DeviceN profile.  We do this by faking a new separation
    space for each one */
@@ -2067,7 +2117,8 @@ gsicc_get_srcprofile(gsicc_colorbuffer_t data_cs,
                      gs_graphics_type_tag_t graphics_type_tag,
                      cmm_srcgtag_profile_t *srcgtag_profile,
                      cmm_profile_t **profile, 
-                     gsicc_rendering_intents_t *rendering_intent)
+                     gsicc_rendering_intents_t *rendering_intent,
+                     gsicc_blackptcomp_t *blackptcomp)
 {
     (*profile) = NULL;
     *rendering_intent = gsPERCEPTUAL;
@@ -2080,27 +2131,33 @@ gsicc_get_srcprofile(gsicc_colorbuffer_t data_cs,
             if (data_cs == gsRGB) {
                 (*profile) = srcgtag_profile->rgb_profiles[gsSRC_GRAPPRO];
                 *rendering_intent =  srcgtag_profile->rgb_intent[gsSRC_GRAPPRO];
+                *blackptcomp = srcgtag_profile->rgb_blackptcomp[gsSRC_GRAPPRO];
             } else if (data_cs == gsCMYK) {
                 (*profile) = srcgtag_profile->cmyk_profiles[gsSRC_GRAPPRO];
                 *rendering_intent =  srcgtag_profile->cmyk_intent[gsSRC_GRAPPRO];
+                *blackptcomp = srcgtag_profile->cmyk_blackptcomp[gsSRC_GRAPPRO];
             }
             break;
         case GS_IMAGE_TAG:
             if (data_cs == gsRGB) {
                 (*profile) = srcgtag_profile->rgb_profiles[gsSRC_IMAGPRO];
                 *rendering_intent =  srcgtag_profile->rgb_intent[gsSRC_IMAGPRO];
+                *blackptcomp = srcgtag_profile->rgb_blackptcomp[gsSRC_IMAGPRO];
             } else if (data_cs == gsCMYK) {
                 (*profile) = srcgtag_profile->cmyk_profiles[gsSRC_IMAGPRO];
                 *rendering_intent =  srcgtag_profile->cmyk_intent[gsSRC_IMAGPRO];
+                *blackptcomp = srcgtag_profile->cmyk_blackptcomp[gsSRC_IMAGPRO];
             }
             break;
         case GS_TEXT_TAG:
             if (data_cs == gsRGB) {
                 (*profile) = srcgtag_profile->rgb_profiles[gsSRC_TEXTPRO];
                 *rendering_intent =  srcgtag_profile->rgb_intent[gsSRC_TEXTPRO];
+                *blackptcomp = srcgtag_profile->rgb_blackptcomp[gsSRC_TEXTPRO];
             } else if (data_cs == gsCMYK) {
                 (*profile) = srcgtag_profile->cmyk_profiles[gsSRC_TEXTPRO];
                 *rendering_intent =  srcgtag_profile->cmyk_intent[gsSRC_TEXTPRO];
+                *blackptcomp = srcgtag_profile->cmyk_blackptcomp[gsSRC_TEXTPRO];
             }
             break;
         }
@@ -2110,7 +2167,8 @@ void
 gsicc_extract_profile(gs_graphics_type_tag_t graphics_type_tag,
                        cmm_dev_profile_t *profile_struct,
                        cmm_profile_t **profile,
-                       gsicc_rendering_intents_t *rendering_intent)
+                       gsicc_rendering_intents_t *rendering_intent,
+                       gsicc_blackptcomp_t *blackptcomp)
 {
     switch (graphics_type_tag & ~GS_DEVICE_ENCODES_TAGS) {
         case GS_UNKNOWN_TAG:
@@ -2118,32 +2176,39 @@ gsicc_extract_profile(gs_graphics_type_tag_t graphics_type_tag,
         default:
             (*profile) = profile_struct->device_profile[0];
             *rendering_intent =  profile_struct->intent[0];
+            *blackptcomp = profile_struct->blackptcomp[0];
             break;
         case GS_PATH_TAG:
             if (profile_struct->device_profile[1] != NULL) {
                 (*profile) = profile_struct->device_profile[1];
                 *rendering_intent =  profile_struct->intent[1];
+                *blackptcomp = profile_struct->blackptcomp[1];
             } else {
                 (*profile) = profile_struct->device_profile[0];
-                *rendering_intent =  profile_struct->intent[0];
+                *rendering_intent =  profile_struct->intent[1];
+                *blackptcomp = profile_struct->blackptcomp[1];
             }
             break;
         case GS_IMAGE_TAG:
             if (profile_struct->device_profile[2] != NULL) {
                 (*profile) = profile_struct->device_profile[2];
                 *rendering_intent =  profile_struct->intent[2];
+                *blackptcomp = profile_struct->blackptcomp[2];
             } else {
                 (*profile) = profile_struct->device_profile[0];
-                *rendering_intent =  profile_struct->intent[0];
+                *rendering_intent =  profile_struct->intent[2];
+                *blackptcomp = profile_struct->blackptcomp[2];
             }
             break;
         case GS_TEXT_TAG:
             if (profile_struct->device_profile[3] != NULL) {
                 (*profile) = profile_struct->device_profile[3];
                 *rendering_intent =  profile_struct->intent[3];
+                *blackptcomp = profile_struct->blackptcomp[3];
             } else {
                 (*profile) = profile_struct->device_profile[0];
-                *rendering_intent =  profile_struct->intent[0];
+                *rendering_intent =  profile_struct->intent[3];
+                *blackptcomp =  profile_struct->blackptcomp[3];
             }
             break;
         }
@@ -2182,7 +2247,22 @@ gs_currentoverride_ri(const gs_imager_state *pis)
         return false;
     }
 }
-
+void
+gs_setoverride_bp(gs_imager_state *pis, bool value)
+{
+    if (pis->icc_manager != NULL) {
+        pis->icc_manager->override_bp = value;
+    }
+}
+bool
+gs_currentoverride_bp(const gs_imager_state *pis)
+{
+    if (pis->icc_manager != NULL) {
+        return pis->icc_manager->override_bp;
+    } else {
+        return false;
+    }
+}
 void
 gsicc_setrange_lab(cmm_profile_t *profile)
 {
diff --git a/gs/base/gsicc_manage.h b/gs/base/gsicc_manage.h
index a7593b4b5..7ebb47ffb 100644
--- a/gs/base/gsicc_manage.h
+++ b/gs/base/gsicc_manage.h
@@ -43,8 +43,6 @@
 #define GSICC_STANDARD_PROFILES\
   "srgb.icc", "sgray.icc"
 #define GSICC_NUMBER_STANDARD_PROFILES 2
-#define GSICC_STANDARD_INTENT_KEYS\
-  "per", "col" , "sat", "abs"
 /* This enumeration has to be in sync with GSICC_SRCGTAG_KEYS */
 typedef enum {
     COLOR_TUNE,  
@@ -69,19 +67,25 @@ void gsicc_profile_reference(cmm_profile_t *icc_profile, int delta);
 void gsicc_extract_profile(gs_graphics_type_tag_t graphics_type_tag,
                        cmm_dev_profile_t *profile_struct,
                        cmm_profile_t **profile,
-                       gsicc_rendering_intents_t *rendering_intent);
+                       gsicc_rendering_intents_t *rendering_intent,
+                       gsicc_blackptcomp_t *blackptcomp);
 void gsicc_get_srcprofile(gsicc_colorbuffer_t data_cs,
                      gs_graphics_type_tag_t graphics_type_tag,
                      cmm_srcgtag_profile_t *srcgtag_profile,
                      cmm_profile_t **profile, 
-                     gsicc_rendering_intents_t *rendering_intent);
+                     gsicc_rendering_intents_t *rendering_intent,
+                     gsicc_blackptcomp_t *blackptcomp);
 int gsicc_getsrc_channel_count(cmm_profile_t *icc_profile);
 int gsicc_init_iccmanager(gs_state * pgs);
 int gsicc_init_gs_colors(gs_state *pgs);
 void  gsicc_profile_serialize(gsicc_serialized_profile_t *profile_data,
                               cmm_profile_t *iccprofile);
-int gsicc_set_device_profile_intent(gx_device *dev, gsicc_profile_types_t intent,
-                                gsicc_profile_types_t profile_type);
+int gsicc_set_device_profile_intent(gx_device *dev, 
+                                    gsicc_rendering_intents_t intent,
+                                    gsicc_profile_types_t profile_type);
+int gsicc_set_device_blackptcomp(gx_device *dev, 
+                                    gsicc_blackptcomp_t blackptcomp,
+                                    gsicc_profile_types_t profile_type);
 void gsicc_set_devicen_equiv_colors(gx_device *dev, const gs_imager_state * pis,
                                     cmm_profile_t *profile);
 int gsicc_set_device_profile_colorants(gx_device *dev, char *name_str);
@@ -121,6 +125,8 @@ void gs_setoverrideicc(gs_imager_state *pis, bool value);
 bool gs_currentoverrideicc(const gs_imager_state *pis);
 void gs_setoverride_ri(gs_imager_state *pis, bool value);
 bool gs_currentoverride_ri(const gs_imager_state *pis);
+void gs_setoverride_bp(gs_imager_state *pis, bool value);
+bool gs_currentoverride_bp(const gs_imager_state *pis);
 cmm_profile_t* gsicc_set_iccsmaskprofile(const char *pname, int namelen, 
                                          gsicc_manager_t *icc_manager, 
                                          gs_memory_t *mem);
diff --git a/gs/base/gsstate.c b/gs/base/gsstate.c
index 3f519806c..516fc7016 100644
--- a/gs/base/gsstate.c
+++ b/gs/base/gsstate.c
@@ -751,6 +751,19 @@ gs_currentrenderingintent(const gs_state * pgs)
     return pgs->renderingintent;
 }
 
+int
+gs_setblackptcomp(gs_state *pgs, bool bkpt) {
+    pgs->blackptcomp = bkpt;
+    return 0;
+}
+
+/* currentrenderingintent */
+bool
+gs_currentblackptcomp(const gs_state * pgs)
+{
+    return pgs->blackptcomp;
+}
+
 /*
  * Reset most of the graphics state.
  *
diff --git a/gs/base/gsstate.h b/gs/base/gsstate.h
index 7f450ccdf..00ca92ab8 100644
--- a/gs/base/gsstate.h
+++ b/gs/base/gsstate.h
@@ -57,6 +57,9 @@ int gs_do_set_overprint(gs_state *);
 int gs_currentrenderingintent(const gs_state *);
 int gs_setrenderingintent(gs_state *, int);
 
+int gs_currentblackptcomp(const gs_state *);
+int gs_setblackptcomp(gs_state *, int);
+
 int gs_initgraphics(gs_state *);
 
 bool gs_currentcpsimode(const gs_memory_t *);
diff --git a/gs/base/gstrans.c b/gs/base/gstrans.c
index 3a7e279cc..ac5873e44 100644
--- a/gs/base/gstrans.c
+++ b/gs/base/gstrans.c
@@ -728,12 +728,13 @@ gs_push_pdf14trans_device(gs_state * pgs, bool is_pattern)
     gs_pdf14trans_params_t params = { 0 };
     cmm_profile_t *icc_profile;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile;
 
     code = dev_proc(pgs->device, get_profile)(pgs->device,  &dev_profile);
     gsicc_extract_profile(GS_UNKNOWN_TAG, dev_profile, &icc_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
 
     params.pdf14_op = PDF14_PUSH_DEVICE;
     /*
diff --git a/gs/base/gxclimag.c b/gs/base/gxclimag.c
index 3eb7fcfc8..1e4bf5e85 100644
--- a/gs/base/gxclimag.c
+++ b/gs/base/gxclimag.c
@@ -361,8 +361,10 @@ clist_begin_typed_image(gx_device * dev,
     cmm_profile_t *src_profile;
     cmm_srcgtag_profile_t *srcgtag_profile;
     gsicc_rendering_intents_t renderingintent = pis->renderingintent;
+    gsicc_blackptcomp_t blackptcomp = pis->blackptcomp;
     gs_imager_state *pis_nonconst = (gs_imager_state*) pis;   
     bool intent_changed = false;
+    bool bp_changed = false;
     cmm_dev_profile_t *dev_profile = NULL;
     cmm_profile_t *gs_output_profile;
     bool is_planar_dev = dev_proc(dev, dev_spec_op)(dev, gxdso_is_native_planar, NULL, 0);
@@ -514,6 +516,8 @@ clist_begin_typed_image(gx_device * dev,
                                 srcgtag_profile->rgb_profiles[gsSRC_IMAGPRO];
                             pis_nonconst->renderingintent = 
                                 srcgtag_profile->rgb_intent[gsSRC_IMAGPRO];
+                            pis_nonconst->blackptcomp = 
+                                srcgtag_profile->rgb_blackptcomp[gsSRC_IMAGPRO];
                         }
                     } else if (src_profile->data_cs == gsCMYK) {
                         if (srcgtag_profile->cmyk_profiles[gsSRC_IMAGPRO] != NULL) {
@@ -521,6 +525,8 @@ clist_begin_typed_image(gx_device * dev,
                                 srcgtag_profile->cmyk_profiles[gsSRC_IMAGPRO];
                             pis_nonconst->renderingintent = 
                                 srcgtag_profile->cmyk_intent[gsSRC_IMAGPRO];
+                            pis_nonconst->blackptcomp =
+                                srcgtag_profile->cmyk_blackptcomp[gsSRC_IMAGPRO];
                         }
                     }
                 }
@@ -531,15 +537,36 @@ clist_begin_typed_image(gx_device * dev,
                 if (!(pis_nonconst->renderingintent & gsRI_OVERRIDE)) {
                     if (pis->icc_manager != NULL && 
                         pis->icc_manager->override_ri == true) {
+                        gsicc_blackptcomp_t temp_blackpt;
                         code = dev_proc(dev, get_profile)(dev,  &dev_profile);
                         gsicc_extract_profile(dev->graphics_type_tag, dev_profile,
                                               &(gs_output_profile), 
                                               (gsicc_rendering_intents_t *)\
-                                              (&(pis_nonconst->renderingintent)));
+                                              (&(pis_nonconst->renderingintent)),
+                                              (gsicc_blackptcomp_t *)\
+                                              (&(temp_blackpt)));
+                    }
+                }
+                /* We have a similar issue to deal with with respect to the 
+                   black point.  Keeping rendering intent and bp comp 
+                   disentangled. */
+                if (!(pis_nonconst->blackptcomp & gsBP_OVERRIDE)) {
+                    if (pis->icc_manager != NULL && 
+                        pis->icc_manager->override_bp == true) {
+                        gsicc_rendering_intents_t temp_ri;
+                        code = dev_proc(dev, get_profile)(dev,  &dev_profile);
+                        gsicc_extract_profile(dev->graphics_type_tag, dev_profile,
+                                              &(gs_output_profile), 
+                                              (gsicc_rendering_intents_t *)\
+                                              (&(temp_ri)),
+                                              (gsicc_blackptcomp_t *)\
+                                              (&(pis_nonconst->blackptcomp)));
                     }
                 }
                 if (renderingintent != pis_nonconst->renderingintent)
                     intent_changed = true;
+                if (blackptcomp != pis_nonconst->blackptcomp)
+                    bp_changed = true;
                 if (!(src_profile->hash_is_valid)) {
                     int64_t hash;
                     gsicc_get_icc_buff_hash(src_profile->buffer, &hash,
@@ -592,10 +619,11 @@ clist_begin_typed_image(gx_device * dev,
        question is penum->image_parent_type == gs_image_type1 */
     if (dev_profile == NULL) {
         gsicc_rendering_intents_t temp_intent;
+        gsicc_blackptcomp_t temp_bp;
         code = dev_proc(dev, get_profile)(dev,  &dev_profile);
         gsicc_extract_profile(dev->graphics_type_tag, dev_profile,
                                               &(gs_output_profile),
-                                              &(temp_intent));
+                                              &(temp_intent), &(temp_bp));
     }
     if (gx_device_must_halftone(dev) && pim->BitsPerComponent == 8 && !masked &&
         (dev->color_info.num_components == 1 || is_planar_dev) && 
@@ -686,6 +714,8 @@ clist_begin_typed_image(gx_device * dev,
        on the pis here for this and reset back */    
     if (intent_changed)
         pis_nonconst->renderingintent = renderingintent;
+    if (bp_changed)
+        pis_nonconst->blackptcomp = blackptcomp;
 
     cdev->image_enum_id = pie->id;
     return 0;
diff --git a/gs/base/gxcmap.c b/gs/base/gxcmap.c
index 5ae9b22be..0a873f9ee 100644
--- a/gs/base/gxcmap.c
+++ b/gs/base/gxcmap.c
@@ -1182,6 +1182,7 @@ cmap_separation_direct(frac all, gx_device_color * pdc, const gs_imager_state *
     gx_color_index color;
     bool use_rgb2dev_icc = false;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile = NULL;
     cmm_profile_t *des_profile = NULL;
@@ -1189,7 +1190,7 @@ cmap_separation_direct(frac all, gx_device_color * pdc, const gs_imager_state *
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(dev->graphics_type_tag,
                           dev_profile, &des_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     for (i=0; i < ncomps; i++)
         cm_comps[i] = 0;
     if (pis->color_component_map.sep_type == SEP_ALL) {
@@ -1236,7 +1237,7 @@ cmap_separation_direct(frac all, gx_device_color * pdc, const gs_imager_state *
         gsicc_rendering_param_t rendering_params;
         unsigned short psrc[GS_CLIENT_COLOR_MAX_COMPONENTS], psrc_cm[GS_CLIENT_COLOR_MAX_COMPONENTS];
 
-        rendering_params.black_point_comp = BP_ON;
+        rendering_params.black_point_comp = pis->blackptcomp;
         rendering_params.graphics_type_tag = GS_PATH_TAG;
         rendering_params.rendering_intent = pis->renderingintent;
 
@@ -1300,6 +1301,7 @@ devicen_icc_cmyk(frac cm_comps[], const gs_imager_state * pis, gx_device *dev)
     int k;
     unsigned short *psrc_temp;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile = NULL;
     cmm_profile_t *des_profile = NULL;
@@ -1307,9 +1309,9 @@ devicen_icc_cmyk(frac cm_comps[], const gs_imager_state * pis, gx_device *dev)
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(dev->graphics_type_tag,
                           dev_profile, &des_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     /* Define the rendering intents. */
-    rendering_params.black_point_comp = BP_ON;
+    rendering_params.black_point_comp = pis->blackptcomp;
     rendering_params.graphics_type_tag = GS_PATH_TAG;
     rendering_params.rendering_intent = pis->renderingintent;
     /* Sigh, frac to full 16 bit.  Need to clean this up */
@@ -1351,13 +1353,14 @@ cmap_devicen_halftoned(const frac * pcc,
     frac cm_comps[GX_DEVICE_COLOR_MAX_COMPONENTS];
     int code;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     cmm_dev_profile_t *dev_profile = NULL;
     cmm_profile_t *des_profile = NULL;
 
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(dev->graphics_type_tag,
                           dev_profile, &des_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     /* map to the color model */
     for (i=0; i < ncomps; i++)
         cm_comps[i] = 0;
@@ -1398,13 +1401,15 @@ cmap_devicen_direct(const frac * pcc,
     gx_color_index color;
     int code;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
+
     cmm_dev_profile_t *dev_profile = NULL;
     cmm_profile_t *des_profile = NULL;
 
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(dev->graphics_type_tag,
                           dev_profile, &des_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
     /*   See the comment below */
     /* map to the color model */
     for (i=0; i < ncomps; i++)
@@ -1979,6 +1984,7 @@ gx_device_uses_std_cmap_procs(gx_device * dev, const gs_imager_state * pis)
 {
     const gx_cm_color_map_procs *pprocs;
     gsicc_rendering_intents_t rendering_intent;
+    gsicc_blackptcomp_t       blackptcomp;
     int code;
     cmm_dev_profile_t *dev_profile = NULL;
     cmm_profile_t *des_profile = NULL;
@@ -1986,7 +1992,7 @@ gx_device_uses_std_cmap_procs(gx_device * dev, const gs_imager_state * pis)
     code = dev_proc(dev, get_profile)(dev,  &dev_profile);
     gsicc_extract_profile(dev->graphics_type_tag,
                           dev_profile, &des_profile,
-                          &rendering_intent);
+                          &rendering_intent, &blackptcomp);
 
     if (des_profile != NULL) {
         pprocs = dev_proc(dev, get_color_mapping_procs)(dev);
diff --git a/gs/base/gxi12bit.c b/gs/base/gxi12bit.c
index 6e560f793..b6ab27cad 100644
--- a/gs/base/gxi12bit.c
+++ b/gs/base/gxi12bit.c
@@ -158,7 +158,7 @@ gs_image_class_2_fracs(gx_image_enum * penum)
                 }
             }
             /* Define the rendering intents */
-            rendering_params.black_point_comp = BP_ON;
+            rendering_params.black_point_comp = penum->pis->blackptcomp;
             rendering_params.graphics_type_tag = GS_IMAGE_TAG;
             rendering_params.rendering_intent = penum->pis->renderingintent;
             if (gs_color_space_is_PSCIE(penum->pcs) && penum->pcs->icc_equivalent != NULL) {
diff --git a/gs/base/gxicolor.c b/gs/base/gxicolor.c
index 2162603e0..fa47c120a 100644
--- a/gs/base/gxicolor.c
+++ b/gs/base/gxicolor.c
@@ -133,7 +133,7 @@ gs_image_class_4_color(gx_image_enum * penum)
             }
         }
         /* Define the rendering intents */
-        rendering_params.black_point_comp = BP_ON;
+        rendering_params.black_point_comp = penum->pis->blackptcomp;
         rendering_params.graphics_type_tag = GS_IMAGE_TAG;
         rendering_params.rendering_intent = penum->pis->renderingintent;
         if (gs_color_space_is_PSCIE(penum->pcs) && penum->pcs->icc_equivalent != NULL) {
diff --git a/gs/base/gximono.c b/gs/base/gximono.c
index ec696a23c..b8b39bc43 100644
--- a/gs/base/gximono.c
+++ b/gs/base/gximono.c
@@ -115,7 +115,7 @@ gs_image_class_3_mono(gx_image_enum * penum)
             code = dev_proc(penum->dev, get_profile)(penum->dev, &dev_profile);
             num_des_comps = gsicc_get_device_profile_comps(dev_profile);
             /* Define the rendering intents */
-            rendering_params.black_point_comp = BP_ON;
+            rendering_params.black_point_comp = penum->pis->blackptcomp;
             rendering_params.graphics_type_tag = GS_IMAGE_TAG;
             rendering_params.rendering_intent = penum->pis->renderingintent;
             if (gs_color_space_get_index(penum->pcs) ==
diff --git a/gs/base/gxiscale.c b/gs/base/gxiscale.c
index 77048966d..833742c27 100644
--- a/gs/base/gxiscale.c
+++ b/gs/base/gxiscale.c
@@ -336,7 +336,7 @@ gs_image_class_0_interpolate(gx_image_enum * penum)
             }
         }
         /* Define the rendering intents */
-        rendering_params.black_point_comp = BP_ON;
+        rendering_params.black_point_comp = penum->pis->blackptcomp;
         rendering_params.graphics_type_tag = GS_IMAGE_TAG;
         rendering_params.rendering_intent = penum->pis->renderingintent;
         if (gs_color_space_is_PSCIE(penum->pcs) && penum->pcs->icc_equivalent != NULL) {
diff --git a/gs/base/gxistate.h b/gs/base/gxistate.h
index 886733534..d3e9c6e6d 100644
--- a/gs/base/gxistate.h
+++ b/gs/base/gxistate.h
@@ -272,6 +272,7 @@ typedef struct gs_xstate_trans_flags {
         bool have_pattern_streams;\
         float smoothness;\
         int renderingintent; /* See gsstate.c */\
+        bool blackptcomp;\
         gsicc_manager_t *icc_manager; /* ICC color manager, profile */\
         gsicc_link_cache_t *icc_link_cache; /* ICC linked transforms */\
         gsicc_profile_cache_t *icc_profile_cache;  /* ICC profiles from PS. */\
@@ -308,7 +309,7 @@ struct gs_imager_state_s {
   lop_default, gx_max_color_value, BLEND_MODE_Compatible,\
 { 1.0 }, { 1.0 }, {0, 0}, 0, 0/*false*/, 0, 0, 0, 0/*false*/, 0, 0, 0/*false*/, 0, 0, 1.0,  \
    { fixed_half, fixed_half }, 0/*false*/, 0/*false*/, 0/*false*/, 1.0,\
-  1, 0, 0, 0, INIT_CUSTOM_COLOR_PTR     /* 'Custom color' callback pointer */  \
+  1, 1/* bpt true */, 0, 0, 0, INIT_CUSTOM_COLOR_PTR    /* 'Custom color' callback pointer */  \
   gx_default_get_cmap_procs
 
 /* The imager state structure is public only for subclassing. */
diff --git a/gs/base/gxshade.c b/gs/base/gxshade.c
index cd5fd9c3f..42344180c 100644
--- a/gs/base/gxshade.c
+++ b/gs/base/gxshade.c
@@ -382,7 +382,7 @@ top:
     if (gs_color_space_is_PSCIE(pcs) && pcs->icc_equivalent == NULL) {
         gs_colorspace_set_icc_equivalent((gs_color_space *)pcs, &(is_lab), pis->memory);
     }
-    rendering_params.black_point_comp = BP_ON;
+    rendering_params.black_point_comp = pis->blackptcomp;
     rendering_params.graphics_type_tag = GS_PATH_TAG;
     rendering_params.rendering_intent = pis->renderingintent;
     /* Grab the icc link transform that we need now */
diff --git a/gs/psi/zcolor3.c b/gs/psi/zcolor3.c
index 75a6b4549..a90d6e645 100644
--- a/gs/psi/zcolor3.c
+++ b/gs/psi/zcolor3.c
@@ -72,6 +72,31 @@ zsetrenderingintent(i_ctx_t * i_ctx_p)
     return 0;
 }
 
+/* - .currentblackptcomp <int> */
+static int
+zcurrentblackptcomp(i_ctx_t *i_ctx_p)
+{
+    os_ptr op = osp;
+
+    push(1);
+    make_int(op, gs_currentblackptcomp(igs));
+    return 0;
+}
+
+/* <int> .setblackptcomp */
+static int
+zsetblackptcomp(i_ctx_t * i_ctx_p)
+{
+    os_ptr op = osp;
+    int param;
+    int code = int_param(op, max_int, &param);
+
+    if (code < 0 || (code = gs_setblackptcomp(igs, param)) < 0)
+        return code;
+    pop(1);
+    return 0;
+}
+
 /*
  * Initialization procedure
  */
@@ -81,5 +106,7 @@ const op_def    zcolor3_l3_op_defs[] = {
     { "0.setuseciecolor", zsetuseciecolor },
     { "0.currentrenderintent", zcurrentrenderingintent },
     { "1.setrenderingintent", zsetrenderingintent },
+    { "2.currentblackptcomp", zcurrentblackptcomp },
+    { "3.setblackptcomp", zsetblackptcomp },
     op_def_end(0)
 };
diff --git a/gs/psi/zusparam.c b/gs/psi/zusparam.c
index b86b2b92d..7d74c73d0 100644
--- a/gs/psi/zusparam.c
+++ b/gs/psi/zusparam.c
@@ -632,6 +632,19 @@ set_OverrideRI(i_ctx_t *i_ctx_p, bool val)
     return 0;
 }
 static bool
+current_OverrideBP(i_ctx_t *i_ctx_p)
+{
+    const gs_imager_state * pis = (gs_imager_state *) igs;
+    return gs_currentoverride_bp(pis);
+}
+static int
+set_OverrideBP(i_ctx_t *i_ctx_p, bool val)
+{
+    gs_imager_state * pis = (gs_imager_state *) igs;
+    gs_setoverride_bp(pis, val);
+    return 0;
+}
+static bool
 current_OverrideICC(i_ctx_t *i_ctx_p)
 {
     const gs_imager_state * pis = (gs_imager_state *) igs;
@@ -675,7 +688,8 @@ static const bool_param_def_t user_bool_params[] =
     {"LockFilePermissions", current_LockFilePermissions, set_LockFilePermissions},
     {"RenderTTNotdef", current_RenderTTNotdef, set_RenderTTNotdef},
     {"OverrideICC", current_OverrideICC, set_OverrideICC},
-    {"OverrideRI", current_OverrideRI, set_OverrideRI}
+    {"OverrideRI", current_OverrideRI, set_OverrideRI},
+    {"OverrideBP", current_OverrideBP, set_OverrideBP}
 };
 
 /* The user parameter set */
diff --git a/gs/toolbin/color/src_color/objsrc_profiles_example.txt b/gs/toolbin/color/src_color/objsrc_profiles_example.txt
index 4bdd36c04..b416b62ac 100644
--- a/gs/toolbin/color/src_color/objsrc_profiles_example.txt
+++ b/gs/toolbin/color/src_color/objsrc_profiles_example.txt
@@ -1,6 +1,6 @@
-Graphic_CMYK    cmyk_src_cyan.icc       0
-Image_CMYK      cmyk_src_magenta.icc    0
-Text_CMYK       cmyk_src_yellow.icc     0
-Graphic_RGB     rgb_source_red.icc      0
-Image_RGB       rgb_source_green.icc    0
-Text_RGB        rgb_source_blue.icc     0
+Graphic_CMYK    cmyk_src_cyan.icc       0       1
+Image_CMYK      cmyk_src_magenta.icc    0       1       
+Text_CMYK       cmyk_src_yellow.icc     0       1
+Graphic_RGB     rgb_source_red.icc      0       1
+Image_RGB       rgb_source_green.icc    0       1
+Text_RGB        rgb_source_blue.icc     0       1
diff --git a/xps/xpsgradient.c b/xps/xpsgradient.c
index efafd6795..3aed3fb26 100644
--- a/xps/xpsgradient.c
+++ b/xps/xpsgradient.c
@@ -81,7 +81,7 @@ xps_parse_gradient_stops(xps_context_t *ctx, char *base_uri, xps_item_t *node,
                 xps_parse_color(ctx, base_uri, color, &colorspace, sample);
 
                 /* Set the rendering parameters */
-                rendering_params.black_point_comp = BP_ON;
+                rendering_params.black_point_comp = gsBLACKPTCOMP_ON;
                 rendering_params.graphics_type_tag = GS_PATH_TAG;
                 rendering_params.rendering_intent = gsPERCEPTUAL;