color.h

Go to the documentation of this file.

// Copyright (C) 2004-2025 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.
 
#ifndef MUPDF_FITZ_COLOR_H
#define MUPDF_FITZ_COLOR_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/store.h"
 
#if FZ_ENABLE_ICC
typedef struct fz_icc_profile fz_icc_profile;
#endif

typedef struct fz_colorspace fz_colorspace;

typedef struct fz_pixmap fz_pixmap;
 
/* Color handling parameters: rendering intent, overprint, etc. */
 
enum
{
    /* Same order as needed by lcms */
    FZ_RI_PERCEPTUAL,
    FZ_RI_RELATIVE_COLORIMETRIC,
    FZ_RI_SATURATION,
    FZ_RI_ABSOLUTE_COLORIMETRIC,
};
 
/* We abuse the top bit of the rendering intent to hold details of
 * whether we are in a softmask or not. This should not be used by
 * non-internal code. */
enum
{
    FZ_RI_IN_SOFTMASK = 0x80
};
 
typedef struct
{
    uint8_t ri; /* rendering intent */
    uint8_t bp; /* black point compensation */
    uint8_t op; /* overprinting */
    uint8_t opm;    /* overprint mode */
}  fz_color_params;
 
FZ_DATA extern const fz_color_params fz_default_color_params;

int fz_lookup_rendering_intent(const char *name);

const char *fz_rendering_intent_name(int ri);

enum { FZ_MAX_COLORS = 32 };

enum { FZ_MAX_SAMPLES = 1 << 30 };
 
enum fz_colorspace_type
{
    FZ_COLORSPACE_NONE,
    FZ_COLORSPACE_GRAY,
    FZ_COLORSPACE_RGB,
    FZ_COLORSPACE_BGR,
    FZ_COLORSPACE_CMYK,
    FZ_COLORSPACE_LAB,
    FZ_COLORSPACE_INDEXED,
    FZ_COLORSPACE_SEPARATION,
};
 
enum
{
    FZ_COLORSPACE_IS_DEVICE = 1,
    FZ_COLORSPACE_IS_ICC = 2,
    FZ_COLORSPACE_HAS_CMYK = 4,
    FZ_COLORSPACE_HAS_SPOTS = 8,
    FZ_COLORSPACE_HAS_CMYK_AND_SPOTS = 4|8,
};

fz_colorspace *fz_new_colorspace(fz_context *ctx, enum fz_colorspace_type type, int flags, int n, const char *name);

fz_colorspace *fz_keep_colorspace(fz_context *ctx, fz_colorspace *colorspace);

void fz_drop_colorspace(fz_context *ctx, fz_colorspace *colorspace);

fz_colorspace *fz_new_indexed_colorspace(fz_context *ctx, fz_colorspace *base, int high, unsigned char *lookup);

fz_colorspace *fz_new_icc_colorspace(fz_context *ctx, enum fz_colorspace_type type, int flags, const char *name, fz_buffer *buf);
 

fz_colorspace *fz_new_cal_gray_colorspace(fz_context *ctx, float wp[3], float bp[3], float gamma);

fz_colorspace *fz_new_cal_rgb_colorspace(fz_context *ctx, float wp[3], float bp[3], float gamma[3], float matrix[9]);

enum fz_colorspace_type fz_colorspace_type(fz_context *ctx, fz_colorspace *cs);

const char *fz_colorspace_name(fz_context *ctx, fz_colorspace *cs);

int fz_colorspace_n(fz_context *ctx, fz_colorspace *cs);

int fz_colorspace_is_subtractive(fz_context *ctx, fz_colorspace *cs);

int fz_colorspace_device_n_has_only_cmyk(fz_context *ctx, fz_colorspace *cs);

int fz_colorspace_device_n_has_cmyk(fz_context *ctx, fz_colorspace *cs);

int fz_colorspace_is_gray(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_rgb(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_cmyk(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_lab(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_indexed(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_icc(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_device_n(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_device(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_device_gray(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_device_cmyk(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_is_lab_icc(fz_context *ctx, fz_colorspace *cs);

void fz_colorspace_digest(fz_context *ctx, fz_colorspace *cs, unsigned char digest[16]);

int fz_is_valid_blend_colorspace(fz_context *ctx, fz_colorspace *cs);

fz_colorspace *fz_base_colorspace(fz_context *ctx, fz_colorspace *cs);

fz_colorspace *fz_device_gray(fz_context *ctx);
fz_colorspace *fz_device_rgb(fz_context *ctx);
fz_colorspace *fz_device_bgr(fz_context *ctx);
fz_colorspace *fz_device_cmyk(fz_context *ctx);
fz_colorspace *fz_device_lab(fz_context *ctx);

void fz_colorspace_name_colorant(fz_context *ctx, fz_colorspace *cs, int n, const char *name);

const char *fz_colorspace_colorant(fz_context *ctx, fz_colorspace *cs, int n);
 
/* Color conversion */

void fz_clamp_color(fz_context *ctx, fz_colorspace *cs, const float *in, float *out);

void fz_convert_color(fz_context *ctx, fz_colorspace *ss, const float *sv, fz_colorspace *ds, float *dv, fz_colorspace *is, fz_color_params params);
 
/* Default (fallback) colorspace handling */

typedef struct
{
    int refs;
    fz_colorspace *gray;
    fz_colorspace *rgb;
    fz_colorspace *cmyk;
    fz_colorspace *oi;
}  fz_default_colorspaces;

fz_default_colorspaces *fz_new_default_colorspaces(fz_context *ctx);

fz_default_colorspaces* fz_keep_default_colorspaces(fz_context *ctx, fz_default_colorspaces *default_cs);

void fz_drop_default_colorspaces(fz_context *ctx, fz_default_colorspaces *default_cs);

fz_default_colorspaces *fz_clone_default_colorspaces(fz_context *ctx, fz_default_colorspaces *base);

fz_colorspace *fz_default_gray(fz_context *ctx, const fz_default_colorspaces *default_cs);
fz_colorspace *fz_default_rgb(fz_context *ctx, const fz_default_colorspaces *default_cs);
fz_colorspace *fz_default_cmyk(fz_context *ctx, const fz_default_colorspaces *default_cs);
fz_colorspace *fz_default_output_intent(fz_context *ctx, const fz_default_colorspaces *default_cs);

void fz_set_default_gray(fz_context *ctx, fz_default_colorspaces *default_cs, fz_colorspace *cs);
void fz_set_default_rgb(fz_context *ctx, fz_default_colorspaces *default_cs, fz_colorspace *cs);
void fz_set_default_cmyk(fz_context *ctx, fz_default_colorspaces *default_cs, fz_colorspace *cs);
void fz_set_default_output_intent(fz_context *ctx, fz_default_colorspaces *default_cs, fz_colorspace *cs);
 
/* Implementation details: subject to change. */
 
struct fz_colorspace
{
    fz_key_storable key_storable;
    enum fz_colorspace_type type;
    int flags;
    int n;
    char *name;
    union {
#if FZ_ENABLE_ICC
        struct {
            fz_buffer *buffer;
            unsigned char md5[16];
            fz_icc_profile *profile;
        } icc;
#endif
        struct {
            fz_colorspace *base;
            int high;
            unsigned char *lookup;
        } indexed;
        struct {
            fz_colorspace *base;
            void (*eval)(fz_context *ctx, void *tint, const float *s, int sn, float *d, int dn);
            void (*drop)(fz_context *ctx, void *tint);
            void *tint;
            char *colorant[FZ_MAX_COLORS];
        } separation;
    } u;
};
 
void fz_drop_colorspace_imp(fz_context *ctx, fz_storable *cs_);
 
#endif