Coverage Report

Created: 2025-06-10 06:56

/src/ghostpdl/base/gscspace.c
Line
Count
Source (jump to first uncovered line)
1
/* Copyright (C) 2001-2024 Artifex Software, Inc.
2
   All Rights Reserved.
3
4
   This software is provided AS-IS with no warranty, either express or
5
   implied.
6
7
   This software is distributed under license and may not be copied,
8
   modified or distributed except as expressly authorized under the terms
9
   of the license contained in the file LICENSE in this distribution.
10
11
   Refer to licensing information at http://www.artifex.com or contact
12
   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
13
   CA 94129, USA, for further information.
14
*/
15
16
17
/* Color space operators and support */
18
#include "memory_.h"
19
#include "gx.h"
20
#include "gserrors.h"
21
#include "gsstruct.h"
22
#include "gsccolor.h"
23
#include "gsutil.h"   /* for gs_next_ids */
24
#include "gxcmap.h"
25
#include "gxcspace.h"
26
#include "gxgstate.h"
27
#include "gsovrc.h"
28
#include "gsstate.h"
29
#include "gsdevice.h"
30
#include "gxdevcli.h"
31
#include "gzstate.h"
32
#include "stream.h"
33
#include "gsnamecl.h"  /* Custom color call back define */
34
#include "gsicc.h"
35
#include "gsicc_manage.h"
36
#include "string_.h"
37
#include "strmio.h"         /* needed for sfclose */
38
#include "gsicc_cache.h"    /* Needed for gsicc_get_icc_buff_hash */
39
#include "gxdevsop.h"
40
41
static cs_proc_install_cspace(gx_install_DeviceGray);
42
static cs_proc_install_cspace(gx_install_DeviceRGB);
43
static cs_proc_install_cspace(gx_install_DeviceCMYK);
44
/*
45
 * Define the standard color space types.  We include DeviceCMYK in the base
46
 * build because it's too awkward to omit it, but we don't provide any of
47
 * the PostScript operator procedures (setcmykcolor, etc.) for dealing with
48
 * it.
49
 */
50
static const gs_color_space_type gs_color_space_type_DeviceGray = {
51
    gs_color_space_index_DeviceGray, true, true,
52
    &st_base_color_space, gx_num_components_1,
53
    gx_init_paint_1, gx_restrict01_paint_1,
54
    gx_same_concrete_space,
55
    gx_concretize_DeviceGray, gx_remap_concrete_DGray,
56
    gx_remap_DeviceGray, gx_install_DeviceGray,
57
    gx_spot_colors_set_overprint,
58
    NULL, gx_no_adjust_color_count,
59
    gx_serialize_cspace_type,
60
    gx_cspace_is_linear_default, gx_polarity_additive
61
};
62
static const gs_color_space_type gs_color_space_type_DeviceRGB = {
63
    gs_color_space_index_DeviceRGB, true, true,
64
    &st_base_color_space, gx_num_components_3,
65
    gx_init_paint_3, gx_restrict01_paint_3,
66
    gx_same_concrete_space,
67
    gx_concretize_DeviceRGB, gx_remap_concrete_DRGB,
68
    gx_remap_DeviceRGB, gx_install_DeviceRGB,
69
    gx_spot_colors_set_overprint,
70
    NULL, gx_no_adjust_color_count,
71
    gx_serialize_cspace_type,
72
    gx_cspace_is_linear_default, gx_polarity_additive
73
};
74
75
static cs_proc_set_overprint(gx_set_overprint_DeviceCMYK);
76
77
static const gs_color_space_type gs_color_space_type_DeviceCMYK = {
78
    gs_color_space_index_DeviceCMYK, true, true,
79
    &st_base_color_space, gx_num_components_4,
80
    gx_init_paint_4, gx_restrict01_paint_4,
81
    gx_same_concrete_space,
82
    gx_concretize_DeviceCMYK, gx_remap_concrete_DCMYK,
83
    gx_remap_DeviceCMYK, gx_install_DeviceCMYK,
84
    gx_set_overprint_DeviceCMYK,
85
    NULL, gx_no_adjust_color_count,
86
    gx_serialize_cspace_type,
87
    gx_cspace_is_linear_default, gx_polarity_subtractive
88
};
89
90
/* Structure descriptors */
91
public_st_color_space();
92
public_st_base_color_space();
93
94
/* ------ Create/copy/destroy ------ */
95
96
/* Ghostscript object finalizers can be called many times and hence
97
 * must be idempotent. */
98
static void
99
gs_cspace_final(const gs_memory_t *cmem, void *vptr)
100
2.22M
{
101
2.22M
    gs_color_space *pcs = (gs_color_space *)vptr;
102
2.22M
    (void)cmem; /* unused */
103
104
2.22M
    if (pcs->interpreter_free_cspace_proc != NULL) {
105
88.7k
        (*pcs->interpreter_free_cspace_proc) ((gs_memory_t *)cmem, pcs);
106
88.7k
        pcs->interpreter_free_cspace_proc = NULL;
107
88.7k
    }
108
2.22M
    if (pcs->type->final)
109
1.23M
        pcs->type->final(pcs);
110
2.22M
    if_debug2m('c', cmem, "[c]cspace final "PRI_INTPTR" %d\n", (intptr_t)pcs, (int)pcs->id);
111
2.22M
    rc_decrement_only_cs(pcs->base_space, "gs_cspace_final");
112
2.22M
    pcs->base_space = NULL;
113
2.22M
    if (gs_color_space_get_index(pcs) == gs_color_space_index_DeviceN) {
114
1.17k
        if (pcs->params.device_n.devn_process_space != NULL) {
115
0
            rc_decrement_only_cs(pcs->params.device_n.devn_process_space, "gs_cspace_final");
116
0
            pcs->params.device_n.devn_process_space = NULL;
117
0
        }
118
1.17k
    }
119
    /* No need to decrement the ICC profile data.  It is handled
120
       by the finalize of the ICC space which is called above using
121
       pcs->type->final(pcs);  */
122
2.22M
}
123
124
static gs_color_space *
125
gs_cspace_alloc_with_id(gs_memory_t *mem, ulong id,
126
                   const gs_color_space_type *pcstype)
127
2.22M
{
128
2.22M
    gs_color_space *pcs;
129
130
2.22M
    rc_alloc_struct_1(pcs, gs_color_space, &st_color_space, mem, return NULL,
131
2.22M
                      "gs_cspace_alloc_with_id");
132
2.22M
    if_debug3m('c', mem, "[c]cspace alloc "PRI_INTPTR" %s %d\n",
133
2.22M
               (intptr_t)pcs, pcstype->stype->sname, pcstype->index);
134
2.22M
    pcs->type = pcstype;
135
2.22M
    pcs->id = id;
136
2.22M
    pcs->base_space = NULL;
137
2.22M
    pcs->pclient_color_space_data = NULL;
138
2.22M
    pcs->interpreter_data = NULL;
139
2.22M
    pcs->interpreter_free_cspace_proc = NULL;
140
2.22M
    pcs->cmm_icc_profile_data = NULL;
141
2.22M
    pcs->ICC_Alternate_space = gs_ICC_Alternate_None;
142
2.22M
    pcs->icc_equivalent = NULL;
143
2.22M
    pcs->params.device_n.devn_process_space = NULL;
144
2.22M
    pcs->params.device_n.all_none = false;
145
2.22M
    return pcs;
146
2.22M
}
147
148
static cs_proc_install_cspace(gx_install_DeviceGray);
149
static cs_proc_install_cspace(gx_install_DeviceRGB);
150
static cs_proc_install_cspace(gx_install_DeviceCMYK);
151
152
/*
153
 * Generic allocation function for colorspace implementations. Return
154
 * NULL on allocation failure.
155
 */
156
gs_color_space *
157
gs_cspace_alloc(gs_memory_t *mem, const gs_color_space_type *pcstype)
158
259k
{
159
259k
    return gs_cspace_alloc_with_id(mem, gs_next_ids(mem, 1), pcstype);
160
259k
}
161
162
/* Constructors for simple device color spaces. */
163
164
gs_color_space *
165
gs_cspace_new_DeviceGray(gs_memory_t *mem)
166
1.49M
{
167
1.49M
    return gs_cspace_alloc_with_id(mem, cs_DeviceGray_id,
168
1.49M
                                   &gs_color_space_type_DeviceGray);
169
1.49M
}
170
171
gs_color_space *
172
gs_cspace_new_DeviceRGB(gs_memory_t *mem)
173
289k
{
174
289k
    return gs_cspace_alloc_with_id(mem, cs_DeviceRGB_id,
175
289k
                                   &gs_color_space_type_DeviceRGB);
176
289k
}
177
gs_color_space *
178
gs_cspace_new_DeviceCMYK(gs_memory_t *mem)
179
181k
{
180
181k
    return gs_cspace_alloc_with_id(mem, cs_DeviceCMYK_id,
181
181k
                                   &gs_color_space_type_DeviceCMYK);
182
181k
}
183
184
/* For use in initializing ICC color spaces for XPS */
185
gs_color_space *
186
gs_cspace_new_scrgb(gs_memory_t *pmem, gs_gstate * pgs)
187
0
{
188
0
    gs_color_space *pcspace = gs_cspace_alloc(pmem, &gs_color_space_type_ICC);
189
0
    cmm_profile_t *profile;
190
0
    stream *str;
191
0
    int code;
192
193
0
    if (pcspace == NULL)
194
0
        return pcspace;
195
196
0
    code = gsicc_open_search(SCRGB, strlen(SCRGB), pmem, pmem->gs_lib_ctx->profiledir,
197
0
        pmem->gs_lib_ctx->profiledir_len, &str);
198
199
0
    if (code < 0 || str == NULL) {
200
0
        rc_decrement(pcspace, "gs_cspace_new_scrgb");
201
0
        return NULL;
202
0
    }
203
204
0
    pcspace->cmm_icc_profile_data = gsicc_profile_new(str, pmem, SCRGB, strlen(SCRGB));
205
0
    code = sfclose(str);
206
0
    if (pcspace->cmm_icc_profile_data == NULL) {
207
0
        rc_decrement(pcspace, "gs_cspace_new_scrgb");
208
0
        return NULL;
209
0
    }
210
211
    /* Get the profile handle */
212
0
    pcspace->cmm_icc_profile_data->profile_handle =
213
0
        gsicc_get_profile_handle_buffer(pcspace->cmm_icc_profile_data->buffer,
214
0
            pcspace->cmm_icc_profile_data->buffer_size, pmem);
215
0
    if (!pcspace->cmm_icc_profile_data->profile_handle) {
216
0
        rc_decrement(pcspace, "gs_cspace_new_scrgb");
217
0
        return NULL;
218
0
    }
219
0
    profile = pcspace->cmm_icc_profile_data;
220
221
    /* Compute the hash code of the profile. Everything in the
222
    ICC manager will have it's hash code precomputed */
223
0
    gsicc_get_icc_buff_hash(profile->buffer, &(profile->hashcode),
224
0
        profile->buffer_size);
225
0
    profile->hash_is_valid = true;
226
0
    profile->num_comps =
227
0
        gscms_get_input_channel_count(profile->profile_handle, profile->memory);
228
0
    profile->num_comps_out =
229
0
        gscms_get_output_channel_count(profile->profile_handle, profile->memory);
230
0
    profile->data_cs =
231
0
        gscms_get_profile_data_space(profile->profile_handle, profile->memory);
232
0
    gsicc_set_icc_range(&profile);
233
0
    return pcspace;
234
0
}
235
236
gs_color_space *
237
gs_cspace_new_ICC(gs_memory_t *pmem, gs_gstate * pgs, int components)
238
136k
{
239
136k
    gsicc_manager_t *icc_manage = pgs->icc_manager;
240
136k
    int code = 0;
241
136k
    gs_color_space *pcspace = gs_cspace_alloc(pmem, &gs_color_space_type_ICC);
242
243
136k
    if (pcspace == NULL)
244
0
        return pcspace;
245
246
136k
    switch (components) {
247
0
        case -1: /* alpha case */
248
0
            if (icc_manage->smask_profiles == NULL) {
249
0
                code = gsicc_initialize_iccsmask(icc_manage);
250
0
            }
251
0
            if (code == 0) {
252
0
                pcspace->cmm_icc_profile_data =
253
0
                    icc_manage->smask_profiles->smask_gray;
254
0
            } else {
255
0
                pcspace->cmm_icc_profile_data = icc_manage->default_gray;
256
0
            }
257
0
            break;
258
0
        case -3: /* alpha case.  needs linear RGB */
259
0
            if (icc_manage->smask_profiles == NULL) {
260
0
                code = gsicc_initialize_iccsmask(icc_manage);
261
0
            }
262
0
            if (code == 0) {
263
0
                pcspace->cmm_icc_profile_data =
264
0
                    icc_manage->smask_profiles->smask_rgb;
265
0
            } else {
266
0
                pcspace->cmm_icc_profile_data = icc_manage->default_rgb;
267
0
            }
268
0
            break;
269
136k
        case 1: pcspace->cmm_icc_profile_data = icc_manage->default_gray; break;
270
0
        case 3: pcspace->cmm_icc_profile_data = icc_manage->default_rgb; break;
271
0
        case 4: pcspace->cmm_icc_profile_data = icc_manage->default_cmyk; break;
272
0
        default: rc_decrement(pcspace,"gs_cspace_new_ICC"); return NULL;
273
136k
    }
274
136k
    gsicc_adjust_profile_rc(pcspace->cmm_icc_profile_data, 1, "gs_cspace_new_ICC");
275
136k
    return pcspace;
276
136k
}
277
278
/* ------ Accessors ------ */
279
280
/* Get the index of a color space. */
281
gs_color_space_index
282
gs_color_space_get_index(const gs_color_space * pcs)
283
3.66M
{
284
3.66M
    return pcs->type->index;
285
3.66M
}
286
287
/* See if the space is CIE based */
288
bool gs_color_space_is_CIE(const gs_color_space * pcs)
289
63.0k
{
290
63.0k
    switch(gs_color_space_get_index(pcs)){
291
0
        case gs_color_space_index_CIEDEFG:
292
0
        case gs_color_space_index_CIEDEF:
293
0
        case gs_color_space_index_CIEABC:
294
0
        case gs_color_space_index_CIEA:
295
63.0k
        case gs_color_space_index_ICC:
296
63.0k
            return true;
297
0
        break;
298
0
        default:
299
0
            return false;
300
63.0k
    }
301
63.0k
}
302
303
/* See if the space is Postscript CIE based */
304
bool gs_color_space_is_PSCIE(const gs_color_space * pcs)
305
453k
{
306
453k
    switch(gs_color_space_get_index(pcs)){
307
0
        case gs_color_space_index_CIEDEFG:
308
0
        case gs_color_space_index_CIEDEF:
309
0
        case gs_color_space_index_CIEABC:
310
0
        case gs_color_space_index_CIEA:
311
0
            return true;
312
0
        break;
313
453k
        default:
314
453k
            return false;
315
453k
}
316
453k
}
317
318
/* See if the space is ICC based */
319
bool gs_color_space_is_ICC(const gs_color_space * pcs)
320
3.47k
{
321
3.47k
    return(gs_color_space_get_index(pcs) == gs_color_space_index_ICC);
322
3.47k
}
323
324
/* Get the number of components in a color space. */
325
int
326
gs_color_space_num_components(const gs_color_space * pcs)
327
402k
{
328
402k
    return cs_num_components(pcs);
329
402k
}
330
331
/* Restrict a color to its legal range. */
332
void
333
gs_color_space_restrict_color(gs_client_color *pcc, const gs_color_space *pcs)
334
0
{
335
0
    cs_restrict_color(pcc, pcs);
336
0
}
337
338
/* Install a DeviceGray color space. */
339
static int
340
gx_install_DeviceGray(gs_color_space * pcs, gs_gstate * pgs)
341
923k
{
342
    /* If we already have profile data installed, nothing to do here. */
343
923k
    if (pcs->cmm_icc_profile_data != NULL)
344
0
        return 0;
345
346
    /* If we haven't initialised the iccmanager, do it now. */
347
923k
    if (pgs->icc_manager->default_gray == NULL) {
348
154k
        int code = gsicc_init_iccmanager(pgs);
349
154k
        if (code < 0)
350
0
            return code;
351
154k
    }
352
353
    /* pcs takes a reference to the default_gray profile data */
354
923k
    pcs->cmm_icc_profile_data = pgs->icc_manager->default_gray;
355
923k
    gsicc_adjust_profile_rc(pgs->icc_manager->default_gray, 1, "gx_install_DeviceGray");
356
923k
    pcs->type = &gs_color_space_type_ICC;
357
923k
    return 0;
358
923k
}
359
360
int
361
gx_num_components_1(const gs_color_space * pcs)
362
167k
{
363
167k
    return 1;
364
167k
}
365
int
366
gx_num_components_3(const gs_color_space * pcs)
367
0
{
368
0
    return 3;
369
0
}
370
int
371
gx_num_components_4(const gs_color_space * pcs)
372
0
{
373
0
    return 4;
374
0
}
375
376
gx_color_polarity_t
377
gx_polarity_subtractive(const gs_color_space * pcs)
378
0
{
379
0
    return GX_CINFO_POLARITY_SUBTRACTIVE;
380
0
}
381
382
gx_color_polarity_t
383
gx_polarity_additive(const gs_color_space * pcs)
384
0
{
385
0
    return GX_CINFO_POLARITY_ADDITIVE;
386
0
}
387
388
gx_color_polarity_t
389
gx_polarity_unknown(const gs_color_space * pcs)
390
0
{
391
0
    return GX_CINFO_POLARITY_UNKNOWN;
392
0
}
393
394
/*
395
 * For color spaces that have a base or alternative color space, return that
396
 * color space. Otherwise return null.
397
 */
398
const gs_color_space *
399
gs_cspace_base_space(const gs_color_space * pcspace)
400
10.5k
{
401
10.5k
    return pcspace->base_space;
402
10.5k
}
403
404
const gs_color_space *
405
gs_cspace_devn_process_space(const gs_color_space * pcspace)
406
0
{
407
0
    return pcspace->params.device_n.devn_process_space;
408
0
}
409
410
/* Abstract the reference counting for color spaces
411
   so that we can also increment the ICC profile
412
   if there is one associated with the color space */
413
414
void rc_increment_cs(gs_color_space *pcs)
415
1.23M
{
416
1.23M
    rc_increment(pcs);
417
1.23M
}
418
419
333k
void rc_decrement_cs(gs_color_space *pcs, const char *cname) {
420
421
333k
    if (pcs) {
422
333k
        rc_decrement(pcs, cname);
423
333k
    }
424
333k
}
425
426
void rc_decrement_only_cs(gs_color_space *pcs, const char *cname)
427
4.54M
{
428
4.54M
    if (pcs) {
429
2.32M
        rc_decrement_only(pcs, cname);
430
2.32M
    }
431
4.54M
}
432
433
void cs_adjust_counts_icc(gs_gstate *pgs, int delta)
434
6.08M
{
435
6.08M
    gs_color_space *pcs = gs_currentcolorspace_inline(pgs);
436
437
6.08M
    if (pcs) {
438
4.06M
        cs_adjust_color_count(pgs, delta);
439
4.06M
        rc_adjust_const(pcs, delta, "cs_adjust_counts_icc");
440
4.06M
    }
441
6.08M
}
442
443
void cs_adjust_swappedcounts_icc(gs_gstate *pgs, int delta)
444
6.08M
{
445
6.08M
    gs_color_space *pcs = gs_swappedcolorspace_inline(pgs);
446
447
6.08M
    if (pcs) {
448
4.06M
        cs_adjust_swappedcolor_count(pgs, delta);
449
4.06M
        rc_adjust_const(pcs, delta, "cs_adjust_swappedcounts_icc");
450
4.06M
    }
451
6.08M
}
452
453
/* ------ Other implementation procedures ------ */
454
455
/* Null color space installation procedure. */
456
int
457
gx_no_install_cspace(gs_color_space * pcs, gs_gstate * pgs)
458
0
{
459
0
    return 0;
460
0
}
461
462
/* Install a DeviceRGB color space. */
463
static int
464
gx_install_DeviceRGB(gs_color_space * pcs, gs_gstate * pgs)
465
30.5k
{
466
    /* If we already have profile_data, nothing to do here. */
467
30.5k
    if (pcs->cmm_icc_profile_data != NULL)
468
0
        return 0;
469
470
    /* If the icc manager hasn't been set up yet, then set it up. */
471
30.5k
    if (pgs->icc_manager->default_rgb == NULL)
472
0
        gsicc_init_iccmanager(pgs);
473
474
    /* pcs takes a reference to default_rgb */
475
30.5k
    pcs->cmm_icc_profile_data = pgs->icc_manager->default_rgb;
476
30.5k
    gsicc_adjust_profile_rc(pcs->cmm_icc_profile_data, 1, "gx_install_DeviceRGB");
477
30.5k
    pcs->type = &gs_color_space_type_ICC;
478
30.5k
    return 0;
479
30.5k
}
480
481
/* Install a DeviceCMYK color space. */
482
static int
483
gx_install_DeviceCMYK(gs_color_space * pcs, gs_gstate * pgs)
484
8.84k
{
485
    /* If we already have profile data, nothing to do here. */
486
8.84k
    if (pcs->cmm_icc_profile_data != NULL)
487
0
        return 0;
488
489
    /* If the icc manager hasn't been set up yet, then set it up. */
490
8.84k
    if (pgs->icc_manager->default_cmyk == NULL)
491
0
        gsicc_init_iccmanager(pgs);
492
493
    /* pcs takes a reference to default_cmyk */
494
8.84k
    pcs->cmm_icc_profile_data = pgs->icc_manager->default_cmyk;
495
8.84k
    gsicc_adjust_profile_rc(pcs->cmm_icc_profile_data, 1, "gx_install_DeviceCMYK");
496
8.84k
    pcs->type = &gs_color_space_type_ICC;
497
8.84k
    return 0;
498
8.84k
}
499
500
/*
501
 * Communicate to the overprint compositor that this particular
502
 * state overprint is not enabled.  This could be due to a
503
 * mismatched color space, or that overprint is false or the
504
 * device does not support it.
505
 */
506
int
507
gx_set_no_overprint(gs_gstate* pgs)
508
14.5k
{
509
14.5k
    gs_overprint_params_t   params = { 0 };
510
511
14.5k
    params.retain_any_comps = false;
512
14.5k
    params.op_state = OP_STATE_NONE;
513
14.5k
    params.is_fill_color = pgs->is_fill_color;
514
14.5k
    params.effective_opm = pgs->color[0].effective_opm = 0;
515
516
14.5k
    return gs_gstate_update_overprint(pgs, &params);
517
14.5k
}
518
519
/* Retain all the spot colorants and not the process
520
   colorants.  This occurs if we have a process color
521
   mismatch between the source and the destination but
522
   the output device supports spot colors */
523
int
524
gx_set_spot_only_overprint(gs_gstate* pgs)
525
0
{
526
0
    gs_overprint_params_t   params = { 0 };
527
0
    gx_device* dev = pgs->device;
528
0
    gx_color_index drawn_comps = dev == NULL ? 0 : gx_get_process_comps(dev);
529
530
0
    params.retain_any_comps = true;
531
0
    params.op_state = OP_STATE_NONE;
532
0
    params.is_fill_color = pgs->is_fill_color;
533
0
    params.effective_opm = pgs->color[0].effective_opm = 0;
534
0
    params.drawn_comps = drawn_comps;
535
536
0
    return gs_gstate_update_overprint(pgs, &params);
537
0
}
538
539
/*
540
 * Push an overprint compositor onto the current device indicating that,
541
 * at most, the spot color parameters are to be preserved.
542
 *
543
 * This routine should be used for all Device, CIEBased, and ICCBased
544
 * color spaces, except for DeviceCMKY.
545
 */
546
int
547
gx_spot_colors_set_overprint(const gs_color_space * pcs, gs_gstate * pgs)
548
0
{
549
0
    gs_overprint_params_t   params = {0};
550
0
    bool op = pgs->is_fill_color ? pgs->overprint : pgs->stroke_overprint;
551
552
0
    if (!op)
553
0
        params.retain_any_comps = false;
554
0
    else
555
0
        params.retain_any_comps = true;
556
557
0
    params.is_fill_color = pgs->is_fill_color;
558
0
    params.op_state = OP_STATE_NONE;
559
560
    /* Only DeviceCMYK case can have overprint mode set to true */
561
0
    params.effective_opm = pgs->color[0].effective_opm = 0;
562
0
    return gs_gstate_update_overprint(pgs, &params);
563
0
}
564
565
static bool
566
check_single_comp(int comp, frac targ_val, int ncomps, const frac * pval)
567
28
{
568
28
    int     i;
569
570
140
    for (i = 0; i < ncomps; i++) {
571
112
        if ( (i != comp && pval[i] != frac_0)  ||
572
112
             (i == comp && pval[i] != targ_val)  )
573
0
            return false;
574
112
    }
575
28
    return true;
576
28
}
577
578
/*
579
 * Determine if the current color model is a "DeviceCMYK" color model, and
580
 * if so what are its process color components. This information is required
581
 * when PLRM defines special rules for CMYK devices. This includes:
582
 * 1. DeviceGray to CMYK color conversion
583
 * 2. when overprint is true and overprint mode is set to 1.
584
 *
585
 * A color model is considered a "DeviceCMYK" color model if it supports the
586
 * cyan, magenta, yellow, and black color components, and maps the DeviceCMYK
587
 * color model components directly to these color components. Note that this
588
 * does not require any particular component order, allows for additional
589
 * spot color components, and does admit DeviceN color spaces if they have
590
 * the requisite behavior.
591
 *
592
 * If the color model is a "DeviceCMYK" color model, return the set of
593
 * process color components; otherwise return 0.
594
 */
595
gx_color_index
596
check_cmyk_color_model_comps(gx_device * dev)
597
7
{
598
7
    gx_device_color_info *          pcinfo = &dev->color_info;
599
7
    uchar                           ncomps = pcinfo->num_components;
600
7
    int                             cyan_c, magenta_c, yellow_c, black_c;
601
7
    frac                            frac_14 = frac_1 / 4;
602
7
    frac                            out[GX_DEVICE_COLOR_MAX_COMPONENTS];
603
7
    gx_color_index                  process_comps;
604
7
    const gx_cm_color_map_procs    *cmprocs;
605
7
    const gx_device                *cmdev;
606
607
608
7
    if (pcinfo->num_components < 4                     ||
609
7
        pcinfo->polarity == GX_CINFO_POLARITY_ADDITIVE ||
610
7
        pcinfo->gray_index == GX_CINFO_COMP_NO_INDEX) {
611
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
612
0
        return 0;
613
0
    }
614
615
    /* check for the appropriate components */
616
7
    if ( ncomps < 4                                       ||
617
7
         (cyan_c = dev_proc(dev, get_color_comp_index)(
618
7
                       dev,
619
7
                       "Cyan",
620
7
                       sizeof("Cyan") - 1,
621
7
                       NO_COMP_NAME_TYPE_OP)) < 0           ||
622
7
         cyan_c == GX_DEVICE_COLOR_MAX_COMPONENTS         ||
623
7
         (magenta_c = dev_proc(dev, get_color_comp_index)(
624
7
                          dev,
625
7
                          "Magenta",
626
7
                          sizeof("Magenta") - 1,
627
7
                          NO_COMP_NAME_TYPE_OP)) < 0        ||
628
7
         magenta_c == GX_DEVICE_COLOR_MAX_COMPONENTS      ||
629
7
         (yellow_c = dev_proc(dev, get_color_comp_index)(
630
7
                        dev,
631
7
                        "Yellow",
632
7
                        sizeof("Yellow") - 1,
633
7
                        NO_COMP_NAME_TYPE_OP)) < 0               ||
634
7
         yellow_c == GX_DEVICE_COLOR_MAX_COMPONENTS       ||
635
7
         (black_c = dev_proc(dev, get_color_comp_index)(
636
7
                        dev,
637
7
                        "Black",
638
7
                        sizeof("Black") - 1,
639
7
                        NO_COMP_NAME_TYPE_OP)) < 0                         ||
640
7
         black_c == GX_DEVICE_COLOR_MAX_COMPONENTS          )
641
0
        return 0;
642
643
    /* check the mapping */
644
7
    cmprocs = dev_proc(dev, get_color_mapping_procs)(dev, &cmdev);
645
646
7
    ncomps -= device_encodes_tags(dev);
647
7
    cmprocs->map_cmyk(cmdev, frac_14, frac_0, frac_0, frac_0, out);
648
7
    if (!check_single_comp(cyan_c, frac_14, ncomps, out)) {
649
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
650
0
        return 0;
651
0
    }
652
7
    cmprocs->map_cmyk(cmdev, frac_0, frac_14, frac_0, frac_0, out);
653
7
    if (!check_single_comp(magenta_c, frac_14, ncomps, out)) {
654
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
655
0
        return 0;
656
0
    }
657
7
    cmprocs->map_cmyk(cmdev, frac_0, frac_0, frac_14, frac_0, out);
658
7
    if (!check_single_comp(yellow_c, frac_14, ncomps, out)) {
659
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
660
0
        return 0;
661
0
    }
662
7
    cmprocs->map_cmyk(cmdev, frac_0, frac_0, frac_0, frac_14, out);
663
7
    if (!check_single_comp(black_c, frac_14, ncomps, out)) {
664
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
665
0
        return 0;
666
0
    }
667
668
7
    process_comps =  ((gx_color_index)1 << cyan_c)
669
7
                   | ((gx_color_index)1 << magenta_c)
670
7
                   | ((gx_color_index)1 << yellow_c)
671
7
                   | ((gx_color_index)1 << black_c);
672
7
    pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED;
673
7
    pcinfo->process_comps = process_comps;
674
7
    pcinfo->black_component = black_c;
675
7
    return process_comps;
676
7
}
677
678
static void
679
check_rgb_color_model_comps(gx_device * dev)
680
153
{
681
153
    gx_device_color_info *          pcinfo = &dev->color_info;
682
153
    uchar                           ncomps = pcinfo->num_components;
683
153
    int                             red_c, green_c, blue_c;
684
153
    frac                            frac_14 = frac_1 / 4;
685
153
    frac                            out[GX_DEVICE_COLOR_MAX_COMPONENTS];
686
153
    gx_color_index                  process_comps;
687
153
    const gx_cm_color_map_procs    *cmprocs;
688
153
    const gx_device                *cmdev;
689
690
691
153
    if (pcinfo->num_components < 3                     ||
692
153
        pcinfo->polarity != GX_CINFO_POLARITY_ADDITIVE ||
693
153
        pcinfo->gray_index == GX_CINFO_COMP_NO_INDEX   ||
694
153
        dev_proc(dev, dev_spec_op)(dev, gxdso_is_sep_supporting_additive_device, NULL, 0) <= 0
695
153
        ) {
696
153
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
697
153
        return;
698
153
    }
699
700
    /* check for the appropriate components */
701
0
    if ( ncomps < 3                                      ||
702
0
         (red_c = dev_proc(dev, get_color_comp_index)(
703
0
                       dev,
704
0
                       "Red",
705
0
                       sizeof("Red") - 1,
706
0
                       NO_COMP_NAME_TYPE_OP)) < 0        ||
707
0
         red_c == GX_DEVICE_COLOR_MAX_COMPONENTS         ||
708
0
         (green_c = dev_proc(dev, get_color_comp_index)(
709
0
                          dev,
710
0
                          "Green",
711
0
                          sizeof("Green") - 1,
712
0
                          NO_COMP_NAME_TYPE_OP)) < 0     ||
713
0
         green_c == GX_DEVICE_COLOR_MAX_COMPONENTS       ||
714
0
         (blue_c = dev_proc(dev, get_color_comp_index)(
715
0
                        dev,
716
0
                        "Blue",
717
0
                        sizeof("Blue") - 1,
718
0
                        NO_COMP_NAME_TYPE_OP)) < 0       ||
719
0
         blue_c == GX_DEVICE_COLOR_MAX_COMPONENTS)
720
0
    {
721
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
722
0
        return;
723
0
    }
724
725
    /* check the mapping */
726
0
    cmprocs = dev_proc(dev, get_color_mapping_procs)(dev, &cmdev);
727
728
0
    ncomps -= device_encodes_tags(dev);
729
0
    cmprocs->map_rgb(cmdev, NULL, frac_14, frac_0, frac_0, out);
730
0
    if (!check_single_comp(red_c, frac_14, ncomps, out)) {
731
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
732
0
        return;
733
0
    }
734
0
    cmprocs->map_rgb(cmdev, NULL, frac_0, frac_14, frac_0, out);
735
0
    if (!check_single_comp(green_c, frac_14, ncomps, out)) {
736
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
737
0
        return;
738
0
    }
739
0
    cmprocs->map_rgb(cmdev, NULL, frac_0, frac_0, frac_14, out);
740
0
    if (!check_single_comp(blue_c, frac_14, ncomps, out)) {
741
0
        pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED_NOT;
742
0
        return;
743
0
    }
744
745
0
    process_comps =  ((gx_color_index)1 << red_c)
746
0
                   | ((gx_color_index)1 << green_c)
747
0
                   | ((gx_color_index)1 << blue_c);
748
0
    pcinfo->opmsupported = GX_CINFO_OPMSUPPORTED;
749
0
    pcinfo->process_comps = process_comps;
750
0
    pcinfo->black_component = 0; /* ? */
751
0
}
752
753
void check_opmsupported(gx_device * dev)
754
160
{
755
160
    if (dev->color_info.polarity == GX_CINFO_POLARITY_ADDITIVE)
756
153
        check_rgb_color_model_comps(dev);
757
7
    else
758
7
        (void)check_cmyk_color_model_comps(dev);
759
160
}
760
761
/*
762
 * This set_overprint method is unique. If overprint is true, overprint
763
 * mode is set to 1, the process color model has DeviceCMYK behavior (see
764
 * the comment ahead of gx_is_cmyk_color_model above), and the device
765
 * color is set, the device color needs to be considered in setting up
766
 * the set of drawn components.
767
 */
768
static int
769
gx_set_overprint_DeviceCMYK(const gs_color_space * pcs, gs_gstate * pgs)
770
0
{
771
0
    gx_device *             dev = pgs->device;
772
0
    gx_device_color_info *  pcinfo = (dev == 0 ? 0 : &dev->color_info);
773
774
    /* check if we require special handling */
775
0
    if ( !pgs->overprint                      ||
776
0
         pgs->overprint_mode != 1             ||
777
0
         pcinfo == 0                          ||
778
0
         pcinfo->opmsupported == GX_CINFO_OPMSUPPORTED_NOT)
779
0
        return gx_spot_colors_set_overprint(pcs, pgs);
780
    /* Share code with CMYK ICC case */
781
0
    return gx_set_overprint_cmyk(pcs, pgs);
782
0
}
783
784
/* A few comments about ICC profiles and overprint simulation.  In order
785
   to do proper overprint simulation, the source ICC profile and the
786
   destination ICC profile must be the same.  If they are not, then
787
   we end up mapping the source CMYK data to a different CMYK value.  In
788
   this case, the non-zero components, which with overprint mode = 1 specify
789
   which are to be overprinted will not be correct to produce the proper
790
   overprint simulation.  This is seen with AR when doing output preview,
791
   overprint simulation enabled of the file overprint_icc.pdf (see our
792
   test files) which has SWOP ICC based CMYK fills.  In AR, if we use a
793
   simulation ICC profile that is different than the source profile,
794
   overprinting is no longer previewed. We follow the same logic here.
795
   If the source and destination ICC profiles do not match, then there is
796
   effectively no overprinting enabled.  This is bug 692433.  However,
797
   even with the mismatch, if the device supports spot colorants, those
798
   colors should be maintained. This is bug 702725. */
799
int gx_set_overprint_cmyk(const gs_color_space * pcs, gs_gstate * pgs)
800
10
{
801
10
    gx_device *             dev = pgs->device;
802
10
    gx_color_index          drawn_comps = 0;
803
10
    gs_overprint_params_t   params = { 0 };
804
10
    gx_device_color        *pdc;
805
10
    cmm_dev_profile_t      *dev_profile;
806
10
    cmm_profile_t          *output_profile = 0;
807
10
    int                     code;
808
10
    bool                    profile_ok = false;
809
10
    gsicc_rendering_param_t        render_cond;
810
10
    bool                    eop;
811
812
10
    if_debug0m(gs_debug_flag_overprint, pgs->memory,
813
10
        "[overprint] gx_set_overprint_cmyk\n");
814
815
10
    if (dev) {
816
10
        code = dev_proc(dev, get_profile)(dev, &dev_profile);
817
10
        if (code < 0)
818
0
            return code;
819
820
10
        gsicc_extract_profile(dev->graphics_type_tag, dev_profile, &(output_profile),
821
10
                              &render_cond);
822
823
10
        drawn_comps = gx_get_process_comps(dev);
824
10
    }
825
826
10
    if_debug1m(gs_debug_flag_overprint, pgs->memory,
827
10
        "[overprint] gx_set_overprint_cmyk. drawn_comps = 0x%x\n", (uint)drawn_comps);
828
829
10
    if (drawn_comps == 0)
830
0
        return gx_spot_colors_set_overprint(pcs, pgs);
831
832
    /* correct for any zero'ed color components.  But only if profiles
833
       match AND pgs->overprint_mode is true */
834
10
    if (pcs->cmm_icc_profile_data != NULL && output_profile != NULL) {
835
10
        if (gsicc_profiles_equal(output_profile, pcs->cmm_icc_profile_data)) {
836
10
            profile_ok = true;
837
10
        }
838
10
    }
839
840
10
    eop = gs_currentcolor_eopm(pgs);
841
842
10
    if_debug3m(gs_debug_flag_overprint, pgs->memory,
843
10
        "[overprint] gx_set_overprint_cmyk. is_fill_color = %d, pgs->color[0].effective_opm = %d pgs->color[1].effective_opm = %d\n",
844
10
        pgs->is_fill_color, pgs->color[0].effective_opm, pgs->color[1].effective_opm);
845
846
10
    if (profile_ok && eop) {
847
10
        gx_color_index  nz_comps, one, temp;
848
10
        int             code;
849
10
        int             num_colorant[4], k;
850
10
        bool            colorant_ok;
851
10
        dev_color_proc_get_nonzero_comps((*procp));
852
853
10
        if_debug0m(gs_debug_flag_overprint, pgs->memory,
854
10
            "[overprint] gx_set_overprint_cmyk. color_is_set, profile_ok and eop\n");
855
856
10
        code = gx_set_dev_color(pgs);
857
10
        if (code < 0)
858
0
            return code;
859
10
        pdc = gs_currentdevicecolor_inline(pgs);
860
10
        procp = pdc->type->get_nonzero_comps;
861
10
        if (pdc->ccolor_valid) {
862
            /* If we have the source colors, then use those in making the
863
               decision as to which ones are non-zero.  Then we avoid
864
               accidently looking at small values that get quantized to zero
865
               Note that to get here in the code, the source color data color
866
               space has to be CMYK. Trick is that we do need to worry about
867
               the colorant order on the target device */
868
10
            num_colorant[0] = (dev_proc(dev, get_color_comp_index))\
869
10
                             (dev, "Cyan", strlen("Cyan"), NO_COMP_NAME_TYPE_OP);
870
10
            num_colorant[1] = (dev_proc(dev, get_color_comp_index))\
871
10
                             (dev, "Magenta", strlen("Magenta"), NO_COMP_NAME_TYPE_OP);
872
10
            num_colorant[2] = (dev_proc(dev, get_color_comp_index))\
873
10
                             (dev, "Yellow", strlen("Yellow"), NO_COMP_NAME_TYPE_OP);
874
10
            num_colorant[3] = (dev_proc(dev, get_color_comp_index))\
875
10
                             (dev, "Black", strlen("Black"), NO_COMP_NAME_TYPE_OP);
876
10
            nz_comps = 0;
877
10
            one = 1;
878
10
            colorant_ok = true;
879
50
            for (k = 0; k < 4; k++) {
880
                /* Note: AR assumes the value is zero if it
881
                   is less than 0.5 out of 255 */
882
40
                if (pdc->ccolor.paint.values[k] > (0.5 / 255.0)) {
883
10
                    if (num_colorant[k] == -1) {
884
0
                        colorant_ok = false;
885
10
                    } else {
886
10
                        temp = one << num_colorant[k];
887
10
                        nz_comps = nz_comps | temp;
888
10
                    }
889
10
                }
890
40
            }
891
            /* For some reason we don't have one of the standard colorants */
892
10
            if (!colorant_ok) {
893
0
                if ((code = procp(pdc, dev, &nz_comps)) < 0)
894
0
                    return code;
895
0
            }
896
10
        } else {
897
0
            if ((code = procp(pdc, dev, &nz_comps)) < 0)
898
0
                return code;
899
0
        }
900
10
        drawn_comps &= nz_comps;
901
10
    }
902
10
    params.is_fill_color = pgs->is_fill_color;
903
10
    params.retain_any_comps = true;
904
10
    params.drawn_comps = drawn_comps;
905
10
    params.op_state = OP_STATE_NONE;
906
907
10
    if_debug2m(gs_debug_flag_overprint, pgs->memory,
908
10
        "[overprint] gx_set_overprint_cmyk. retain_any_comps = %d, drawn_comps = 0x%x\n",
909
10
        params.retain_any_comps, (uint)(params.drawn_comps));
910
911
    /* We are in CMYK, the profiles match and overprint is true.  Set effective
912
       overprint mode to overprint mode but only if effective has not already
913
       been set to 0 */
914
10
    params.effective_opm = pgs->color[0].effective_opm =
915
10
        pgs->overprint_mode && gs_currentcolor_eopm(pgs);
916
10
    return gs_gstate_update_overprint(pgs, &params);
917
10
}
918
919
int gx_set_overprint_rgb(const gs_color_space * pcs, gs_gstate * pgs)
920
0
{
921
0
    gx_device *             dev = pgs->device;
922
0
    gx_color_index          drawn_comps = 0;
923
0
    gs_overprint_params_t   params = { 0 };
924
0
    gx_device_color        *pdc;
925
0
    cmm_dev_profile_t      *dev_profile;
926
0
    cmm_profile_t          *output_profile = 0;
927
0
    int                     code;
928
0
    bool                    profile_ok = false;
929
0
    gsicc_rendering_param_t        render_cond;
930
0
    bool                    eop;
931
932
0
    if_debug0m(gs_debug_flag_overprint, pgs->memory,
933
0
        "[overprint] gx_set_overprint_rgb\n");
934
935
0
    if (dev) {
936
0
        code = dev_proc(dev, get_profile)(dev, &dev_profile);
937
0
        if (code < 0)
938
0
            return code;
939
940
0
        gsicc_extract_profile(dev->graphics_type_tag, dev_profile, &(output_profile),
941
0
                              &render_cond);
942
943
0
        drawn_comps = gx_get_process_comps(dev);
944
0
    }
945
946
0
    if_debug1m(gs_debug_flag_overprint, pgs->memory,
947
0
        "[overprint] gx_set_overprint_rgb. drawn_comps = 0x%x\n", (uint)drawn_comps);
948
949
0
    if (drawn_comps == 0)
950
0
        return gx_spot_colors_set_overprint(pcs, pgs);
951
952
    /* correct for any zero'ed color components.  But only if profiles
953
       match AND pgs->overprint_mode is true */
954
0
    if (pcs->cmm_icc_profile_data != NULL && output_profile != NULL) {
955
0
        if (gsicc_profiles_equal(output_profile, pcs->cmm_icc_profile_data)) {
956
0
            profile_ok = true;
957
0
        }
958
0
    }
959
960
0
    eop = gs_currentcolor_eopm(pgs);
961
962
0
    if_debug3m(gs_debug_flag_overprint, pgs->memory,
963
0
        "[overprint] gx_set_overprint_rgb. is_fill_color = %d, pgs->color[0].effective_opm = %d pgs->color[1].effective_opm = %d\n",
964
0
        pgs->is_fill_color, pgs->color[0].effective_opm, pgs->color[1].effective_opm);
965
966
0
    if (profile_ok && eop) {
967
0
        gx_color_index  nz_comps, one, temp;
968
0
        int             code;
969
0
        int             num_colorant[3], k;
970
0
        bool            colorant_ok;
971
0
        dev_color_proc_get_nonzero_comps((*procp));
972
973
0
        if_debug0m(gs_debug_flag_overprint, pgs->memory,
974
0
            "[overprint] gx_set_overprint_cmyk. color_is_set, profile_ok and eop\n");
975
976
0
        code = gx_set_dev_color(pgs);
977
0
        if (code < 0)
978
0
            return code;
979
0
        pdc = gs_currentdevicecolor_inline(pgs);
980
0
        procp = pdc->type->get_nonzero_comps;
981
0
        if (pdc->ccolor_valid) {
982
            /* If we have the source colors, then use those in making the
983
               decision as to which ones are non-zero.  Then we avoid
984
               accidently looking at small values that get quantized to zero
985
               Note that to get here in the code, the source color data color
986
               space has to be CMYK. Trick is that we do need to worry about
987
               the colorant order on the target device */
988
0
            num_colorant[0] = (dev_proc(dev, get_color_comp_index))\
989
0
                             (dev, "Red", strlen("Red"), NO_COMP_NAME_TYPE_OP);
990
0
            num_colorant[1] = (dev_proc(dev, get_color_comp_index))\
991
0
                             (dev, "Green", strlen("Green"), NO_COMP_NAME_TYPE_OP);
992
0
            num_colorant[2] = (dev_proc(dev, get_color_comp_index))\
993
0
                             (dev, "Blue", strlen("Blue"), NO_COMP_NAME_TYPE_OP);
994
0
            nz_comps = 0;
995
0
            one = 1;
996
0
            colorant_ok = true;
997
0
            for (k = 0; k < 3; k++) {
998
                /* Note: AR assumes the value is zero if it
999
                   is less than 0.5 out of 255 */
1000
0
                if (pdc->ccolor.paint.values[k] > (0.5 / 255.0)) {
1001
0
                    if (num_colorant[k] == -1) {
1002
0
                        colorant_ok = false;
1003
0
                    } else {
1004
0
                        temp = one << num_colorant[k];
1005
0
                        nz_comps = nz_comps | temp;
1006
0
                    }
1007
0
                }
1008
0
            }
1009
            /* For some reason we don't have one of the standard colorants */
1010
0
            if (!colorant_ok) {
1011
0
                if ((code = procp(pdc, dev, &nz_comps)) < 0)
1012
0
                    return code;
1013
0
            }
1014
0
        } else {
1015
0
            if ((code = procp(pdc, dev, &nz_comps)) < 0)
1016
0
                return code;
1017
0
        }
1018
0
        drawn_comps &= nz_comps;
1019
0
    }
1020
0
    params.is_fill_color = pgs->is_fill_color;
1021
0
    params.retain_any_comps = true;
1022
0
    params.drawn_comps = drawn_comps;
1023
0
    params.op_state = OP_STATE_NONE;
1024
1025
0
    if_debug2m(gs_debug_flag_overprint, pgs->memory,
1026
0
        "[overprint] gx_set_overprint_rgb. retain_any_comps = %d, drawn_comps = 0x%x\n",
1027
0
        params.retain_any_comps, (uint)(params.drawn_comps));
1028
1029
    /* We are in RGB, the profiles match and overprint is true.  Set effective
1030
       overprint mode to overprint mode but only if effective has not already
1031
       been set to 0 */
1032
0
    params.effective_opm = pgs->color[0].effective_opm =
1033
0
        pgs->overprint_mode && gs_currentcolor_eopm(pgs);
1034
0
    return gs_gstate_update_overprint(pgs, &params);
1035
0
}
1036
/* A stub for a color mapping linearity check, when it is inapplicable. */
1037
int
1038
gx_cspace_no_linear(const gs_color_space *cs, const gs_gstate * pgs,
1039
                gx_device * dev,
1040
                const gs_client_color *c0, const gs_client_color *c1,
1041
                const gs_client_color *c2, const gs_client_color *c3,
1042
                float smoothness, gsicc_link_t *icclink)
1043
0
{
1044
0
    return_error(gs_error_rangecheck);
1045
0
}
1046
1047
static inline int
1048
cc2dc(const gs_color_space *cs, const gs_gstate * pgs, gx_device *dev,
1049
            gx_device_color *dc, const gs_client_color *cc)
1050
1.15M
{
1051
1.15M
    return cs->type->remap_color(cc, cs, dc, pgs, dev, gs_color_select_texture);
1052
1.15M
}
1053
1054
static inline void
1055
interpolate_cc(gs_client_color *c,
1056
        const gs_client_color *c0, const gs_client_color *c1, double t, int n)
1057
617k
{
1058
617k
    int i;
1059
1060
1.30M
    for (i = 0; i < n; i++)
1061
684k
        c->paint.values[i] = c0->paint.values[i] * t + c1->paint.values[i] * (1 - t);
1062
617k
}
1063
1064
static inline bool
1065
is_dc_nearly_linear(const gx_device *dev, const gx_device_color *c,
1066
        const gx_device_color *c0, const gx_device_color *c1,
1067
        double t, uchar n, float smoothness)
1068
617k
{
1069
617k
    uchar i;
1070
1071
617k
    if (c0->type == &gx_dc_type_data_pure) {
1072
617k
        gx_color_index pure0 = c0->colors.pure;
1073
617k
        gx_color_index pure1 = c1->colors.pure;
1074
617k
        gx_color_index pure = c->colors.pure;
1075
1076
3.07M
        for (i = 0; i < n; i++) {
1077
2.46M
            int shift = dev->color_info.comp_shift[i];
1078
2.46M
            int mask = (1 << dev->color_info.comp_bits[i]) - 1;
1079
2.46M
            int max_color = (i == dev->color_info.gray_index ? dev->color_info.max_gray
1080
2.46M
                                                             : dev->color_info.max_color);
1081
2.46M
            float max_diff = max(1, max_color * smoothness);
1082
2.46M
            int b0 = (pure0 >> shift) & mask, b1 = (pure1 >> shift) & mask;
1083
2.46M
            int b = (pure >> shift) & mask;
1084
2.46M
            double bb = b0 * t + b1 * (1 - t);
1085
1086
2.46M
            if (any_abs(b - bb) > max_diff)
1087
7.52k
                return false;
1088
2.46M
        }
1089
610k
        return true;
1090
617k
    } else if (c0->type == &gx_dc_type_data_devn) {
1091
0
        for (i = 0; i < n; i++) {
1092
0
            int max_color = (i == dev->color_info.gray_index ? dev->color_info.max_gray
1093
0
                : dev->color_info.max_color);
1094
0
            double max_diff = max(1, max_color * smoothness);
1095
            /* Color values are 16 bit.  We are basing the smoothness on the
1096
               device bit depth.  So make sure to adjust the above max diff
1097
               based upon our device bit depth */
1098
0
            double ratio = (double)max_color / (double)gx_max_color_value;
1099
0
            double b0 = (c0->colors.devn.values[i]) * ratio;
1100
0
            double b1 = (c1->colors.devn.values[i]) * ratio;
1101
0
            double b = (c->colors.devn.values[i]) * ratio;
1102
0
            double bb = b0 * t + b1 * (1 - t);
1103
0
            if (any_abs(b - bb) > max_diff)
1104
0
                return false;
1105
0
        }
1106
0
        return true;
1107
0
    } else {
1108
        /* Halftones must not paint with fill_linear_color_*. */
1109
0
        return false;
1110
0
    }
1111
617k
}
1112
1113
/* Default color mapping linearity check, a 2-points case. */
1114
static int
1115
gx_cspace_is_linear_in_line(const gs_color_space *cs, const gs_gstate * pgs,
1116
                gx_device *dev,
1117
                const gs_client_color *c0, const gs_client_color *c1,
1118
                float smoothness)
1119
145k
{
1120
145k
    gs_client_color c01a, c01b;
1121
145k
    gx_device_color d[2], d01a, d01b;
1122
145k
    int n = cs->type->num_components(cs);
1123
145k
    uchar ndev = dev->color_info.num_components;
1124
145k
    int code;
1125
1126
145k
    code = cc2dc(cs, pgs, dev, &d[0], c0);
1127
145k
    if (code < 0)
1128
0
        return code;
1129
145k
    code = cc2dc(cs, pgs, dev, &d[1], c1);
1130
145k
    if (code < 0)
1131
0
        return code;
1132
145k
    interpolate_cc(&c01a, c0, c1, 0.3, n);
1133
145k
    code = cc2dc(cs, pgs, dev, &d01a, &c01a);
1134
145k
    if (code < 0)
1135
0
        return code;
1136
145k
    if (!is_dc_nearly_linear(dev, &d01a, &d[0], &d[1], 0.3, ndev, smoothness))
1137
6.79k
        return 0;
1138
139k
    interpolate_cc(&c01b, c0, c1, 0.7, n);
1139
139k
    code = cc2dc(cs, pgs, dev, &d01b, &c01b);
1140
139k
    if (code < 0)
1141
0
        return code;
1142
139k
    if (!is_dc_nearly_linear(dev, &d01b, &d[0], &d[1], 0.7, ndev, smoothness))
1143
528
        return 0;
1144
138k
    return 1;
1145
139k
}
1146
1147
/* Default color mapping linearity check, a triangle case. */
1148
static int
1149
gx_cspace_is_linear_in_triangle(const gs_color_space *cs, const gs_gstate * pgs,
1150
                gx_device *dev,
1151
                const gs_client_color *c0, const gs_client_color *c1,
1152
                const gs_client_color *c2, float smoothness)
1153
83.3k
{
1154
    /* We check 4 points - the median center, and middle points of 3 sides.
1155
       Hopely this is enough for reasonable color spaces and color renderings.
1156
       Note it gives 7 points for a quadrangle. */
1157
83.3k
    gs_client_color c01, c12, c20, c012;
1158
83.3k
    gx_device_color d[3], d01, d12, d20, d012;
1159
1160
    /* Note that the device and the client color space
1161
       can have a different number of components */
1162
1163
83.3k
    int n = cs->type->num_components(cs);
1164
83.3k
    uchar ndev = dev->color_info.num_components;
1165
1166
83.3k
    int code;
1167
1168
83.3k
    code = cc2dc(cs, pgs, dev, &d[0], c0);
1169
83.3k
    if (code < 0)
1170
0
        return code;
1171
83.3k
    code = cc2dc(cs, pgs, dev, &d[1], c1);
1172
83.3k
    if (code < 0)
1173
0
        return code;
1174
83.3k
    code = cc2dc(cs, pgs, dev, &d[2], c2);
1175
83.3k
    if (code < 0)
1176
0
        return code;
1177
1178
83.3k
    interpolate_cc(&c01, c0, c1, 0.5, n);
1179
83.3k
    code = cc2dc(cs, pgs, dev, &d01, &c01);
1180
83.3k
    if (code < 0)
1181
0
        return code;
1182
83.3k
    if (!is_dc_nearly_linear(dev, &d01, &d[0], &d[1], 0.5, ndev, smoothness))
1183
120
        return 0;
1184
1185
83.2k
    interpolate_cc(&c012, c2, &c01, 2.0 / 3, n);
1186
83.2k
    code = cc2dc(cs, pgs, dev, &d012, &c012);
1187
83.2k
    if (code < 0)
1188
0
        return code;
1189
83.2k
    if (!is_dc_nearly_linear(dev, &d012, &d[2], &d01, 2.0 / 3, ndev, smoothness))
1190
80
        return 0;
1191
1192
83.1k
    interpolate_cc(&c12, c1, c2, 0.5, n);
1193
83.1k
    code = cc2dc(cs, pgs, dev, &d12, &c12);
1194
83.1k
    if (code < 0)
1195
0
        return code;
1196
83.1k
    if (!is_dc_nearly_linear(dev, &d12, &d[1], &d[2], 0.5, ndev, smoothness))
1197
0
        return 0;
1198
1199
83.1k
    interpolate_cc(&c20, c2, c0, 0.5, n);
1200
83.1k
    code = cc2dc(cs, pgs, dev, &d20, &c20);
1201
83.1k
    if (code < 0)
1202
0
        return code;
1203
83.1k
    if (!is_dc_nearly_linear(dev, &d20, &d[2], &d[0], 0.5, ndev, smoothness))
1204
0
        return 0;
1205
83.1k
    return 1;
1206
83.1k
}
1207
1208
/* Default color mapping linearity check. */
1209
int
1210
gx_cspace_is_linear_default(const gs_color_space *cs, const gs_gstate * pgs,
1211
                gx_device *dev,
1212
                const gs_client_color *c0, const gs_client_color *c1,
1213
                const gs_client_color *c2, const gs_client_color *c3,
1214
                float smoothness, gsicc_link_t *icclink)
1215
229k
{
1216
    /* Assuming 2 <= nc <= 4. We don't need other cases. */
1217
    /* With nc == 4 assuming a convex plain quadrangle in the client color space. */
1218
229k
    int code;
1219
1220
229k
    if (!colors_are_separable_and_linear(&dev->color_info))
1221
0
        return_error(gs_error_rangecheck);
1222
229k
    if (c2 == NULL)
1223
145k
        return gx_cspace_is_linear_in_line(cs, pgs, dev, c0, c1, smoothness);
1224
83.3k
    code = gx_cspace_is_linear_in_triangle(cs, pgs, dev, c0, c1, c2, smoothness);
1225
83.3k
    if (code <= 0)
1226
200
        return code;
1227
83.1k
    if (c3 == NULL)
1228
83.1k
        return 1;
1229
0
    return gx_cspace_is_linear_in_triangle(cs, pgs, dev, c1, c2, c3, smoothness);
1230
83.1k
}
1231
1232
/* Serialization. */
1233
int
1234
gx_serialize_cspace_type(const gs_color_space * pcs, stream * s)
1235
0
{
1236
0
    const gs_color_space_type * type = pcs->type;
1237
0
    uint n;
1238
0
    return sputs(s, (const byte *)&type->index, sizeof(type->index), &n);
1239
0
}
1240
1241
/* GC procedures */
1242
1243
static
1244
ENUM_PTRS_BEGIN_PROC(color_space_enum_ptrs)
1245
653k
{
1246
653k
    EV_CONST gs_color_space *pcs = vptr;
1247
1248
653k
    if (index == 0)
1249
130k
        return ENUM_OBJ(pcs->base_space);
1250
522k
    if (index == 1)
1251
130k
        return ENUM_OBJ(pcs->pclient_color_space_data);
1252
391k
    if (index == 2)
1253
130k
        return ENUM_OBJ(pcs->icc_equivalent);
1254
261k
    if (index == 3) {
1255
130k
        if (gs_color_space_get_index(pcs) == gs_color_space_index_DeviceN)
1256
0
            return ENUM_OBJ(pcs->params.device_n.devn_process_space);
1257
130k
        else
1258
130k
            return ENUM_OBJ(NULL);
1259
130k
    }
1260
1261
130k
    return ENUM_USING(*pcs->type->stype, vptr, size, index - 4);
1262
261k
    ENUM_PTRS_END_PROC
1263
261k
}
1264
static
1265
130k
RELOC_PTRS_WITH(color_space_reloc_ptrs, gs_color_space *pcs)
1266
130k
{
1267
130k
    RELOC_VAR(pcs->base_space);
1268
130k
    RELOC_VAR(pcs->pclient_color_space_data);
1269
130k
    RELOC_VAR(pcs->icc_equivalent);
1270
130k
    if (gs_color_space_get_index(pcs) == gs_color_space_index_DeviceN)
1271
130k
        RELOC_VAR(pcs->params.device_n.devn_process_space);
1272
130k
    RELOC_USING(*pcs->type->stype, vptr, size);
1273
130k
}
1274
130k
RELOC_PTRS_END