pixmap.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_PIXMAP_H
#define MUPDF_FITZ_PIXMAP_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/store.h"
#include "mupdf/fitz/separation.h"

 
typedef struct fz_overprint fz_overprint;

fz_irect fz_pixmap_bbox(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_width(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_height(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_x(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_y(fz_context *ctx, const fz_pixmap *pix);

size_t fz_pixmap_size(fz_context *ctx, fz_pixmap *pix);

fz_pixmap *fz_new_pixmap(fz_context *ctx, fz_colorspace *cs, int w, int h, fz_separations *seps, int alpha);

fz_pixmap *fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, fz_irect bbox, fz_separations *seps, int alpha);

fz_pixmap *fz_new_pixmap_with_data(fz_context *ctx, fz_colorspace *colorspace, int w, int h, fz_separations *seps, int alpha, int stride, unsigned char *samples);

fz_pixmap *fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, fz_irect rect, fz_separations *seps, int alpha, unsigned char *samples);

fz_pixmap *fz_new_pixmap_from_pixmap(fz_context *ctx, fz_pixmap *pixmap, const fz_irect *rect);

fz_pixmap *fz_clone_pixmap(fz_context *ctx, const fz_pixmap *old);

fz_pixmap *fz_keep_pixmap(fz_context *ctx, fz_pixmap *pix);

void fz_drop_pixmap(fz_context *ctx, fz_pixmap *pix);

fz_colorspace *fz_pixmap_colorspace(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_components(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_colorants(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_spots(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_alpha(fz_context *ctx, const fz_pixmap *pix);

unsigned char *fz_pixmap_samples(fz_context *ctx, const fz_pixmap *pix);

int fz_pixmap_stride(fz_context *ctx, const fz_pixmap *pix);

void fz_set_pixmap_resolution(fz_context *ctx, fz_pixmap *pix, int xres, int yres);

void fz_clear_pixmap_with_value(fz_context *ctx, fz_pixmap *pix, int value);

void fz_fill_pixmap_with_color(fz_context *ctx, fz_pixmap *pix, fz_colorspace *colorspace, float *color, fz_color_params color_params);

void fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *pix, int value, fz_irect r);

void fz_clear_pixmap(fz_context *ctx, fz_pixmap *pix);

void fz_invert_pixmap(fz_context *ctx, fz_pixmap *pix);

void fz_invert_pixmap_alpha(fz_context *ctx, fz_pixmap *pix);

void fz_invert_pixmap_luminance(fz_context *ctx, fz_pixmap *pix);

void fz_tint_pixmap(fz_context *ctx, fz_pixmap *pix, int black, int white);

void fz_invert_pixmap_rect(fz_context *ctx, fz_pixmap *image, fz_irect rect);

void fz_invert_pixmap_raw(fz_context *ctx, fz_pixmap *pix);

void fz_gamma_pixmap(fz_context *ctx, fz_pixmap *pix, float gamma);

fz_pixmap *fz_convert_pixmap(fz_context *ctx, const fz_pixmap *pix, fz_colorspace *cs_des, fz_colorspace *prf, fz_default_colorspaces *default_cs, fz_color_params color_params, int keep_alpha);

int fz_is_pixmap_monochrome(fz_context *ctx, fz_pixmap *pixmap);
 
/* Implementation details: subject to change.*/
 
fz_pixmap *fz_alpha_from_gray(fz_context *ctx, fz_pixmap *gray);
fz_pixmap *fz_alpha_from_rgb(fz_context *ctx, fz_pixmap *color);
void fz_decode_tile(fz_context *ctx, fz_pixmap *pix, const float *decode);
void fz_md5_pixmap(fz_context *ctx, fz_pixmap *pixmap, unsigned char digest[16]);
 
fz_stream *
fz_unpack_stream(fz_context *ctx, fz_stream *src, int depth, int w, int h, int n, int indexed, int pad, int skip);

struct fz_pixmap
{
    fz_storable storable;
    int x, y, w, h;
    unsigned char n;
    unsigned char s;
    unsigned char alpha;
    unsigned char flags;
    ptrdiff_t stride;
    fz_separations *seps;
    int xres, yres;
    fz_colorspace *colorspace;
    unsigned char *samples;
    fz_pixmap *underlying;
};
 
enum
{
    FZ_PIXMAP_FLAG_INTERPOLATE = 1,
    FZ_PIXMAP_FLAG_FREE_SAMPLES = 2
};
 
/* Create a new pixmap from a warped section of another.
 *
 * Colorspace, resolution etc are inherited from the original.
 * points give the corner points within the original pixmap of a
 * (convex) quadrilateral. These corner points will be 'warped' to be
 * the corner points of the returned bitmap, which will have the given
 * width/height.
 */
fz_pixmap *
fz_warp_pixmap(fz_context *ctx, fz_pixmap *src, fz_quad points, int width, int height);
 
/* As for fz_warp_pixmap, where width/height are automatically 'guessed'. */
fz_pixmap *
fz_autowarp_pixmap(fz_context *ctx, fz_pixmap *src, fz_quad points);
 
/* Search for a "document" within a pixmap (greyscale or rgb, no alpha).
 *
 * points should point to an array of 4 fz_points.
 *
 * If the function return false, no document was found.
 * If true, points has been updated to include the corner positions of
 * the detected document within the src image.
 */
int
fz_detect_document(fz_context *ctx, fz_quad *points, fz_pixmap *src);
 
/*
    Convert between different separation results.
*/
fz_pixmap *fz_clone_pixmap_area_with_different_seps(fz_context *ctx, fz_pixmap *src, const fz_irect *bbox, fz_colorspace *dcs, fz_separations *seps, fz_color_params color_params, fz_default_colorspaces *default_cs);
 
/*
 * Extract alpha channel as a separate pixmap.
 * Returns NULL if there is no alpha channel in the source.
 */
fz_pixmap *fz_new_pixmap_from_alpha_channel(fz_context *ctx, fz_pixmap *src);
 
/*
 * Combine a pixmap without an alpha channel with a soft mask.
 */
fz_pixmap *fz_new_pixmap_from_color_and_mask(fz_context *ctx, fz_pixmap *color, fz_pixmap *mask);
 
/*
 * Scale the pixmap up or down in size to fit the rectangle. Will return `NULL`
 * if the scaling factors are out of range. This applies fancy filtering and
 * will anti-alias the edges for subpixel positioning if using non-integer
 * coordinates. If the clip rectangle is set, the returned pixmap may be subset
 * to fit the clip rectangle. Pass `NULL` to the clip if you want the whole
 * pixmap scaled.
 */
fz_pixmap *fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, const fz_irect *clip);
 
/*
 * Reduces size to:
 * tile->w => (tile->w + 2^factor-1) / 2^factor
 * tile->h => (tile->h + 2^factor-1) / 2^factor
 */
void fz_subsample_pixmap(fz_context *ctx, fz_pixmap *tile, int factor);
 
/*
 * Copies r (clipped to both src and dest) in src to dest.
 */
void fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_irect r, const fz_default_colorspaces *default_cs);
 
#endif