image.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_IMAGE_H
#define MUPDF_FITZ_IMAGE_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/store.h"
#include "mupdf/fitz/pixmap.h"
 
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/stream.h"
#include "mupdf/fitz/compressed-buffer.h"

typedef struct fz_image fz_image;
typedef struct fz_compressed_image fz_compressed_image;
typedef struct fz_pixmap_image fz_pixmap_image;

fz_pixmap *fz_get_pixmap_from_image(fz_context *ctx, fz_image *image, const fz_irect *subarea, fz_matrix *ctm, int *w, int *h);

fz_pixmap *fz_get_pixmap_mask_from_image(fz_context *ctx, fz_image *image, const fz_irect *subarea, fz_matrix *ctm, int *dw, int *dh, int in_smask);

fz_pixmap *fz_get_unscaled_pixmap_from_image(fz_context *ctx, fz_image *image);

fz_image *fz_keep_image(fz_context *ctx, fz_image *image);

void fz_drop_image(fz_context *ctx, fz_image *image);

fz_image *fz_keep_image_store_key(fz_context *ctx, fz_image *image);

void fz_drop_image_store_key(fz_context *ctx, fz_image *image);

typedef void (fz_drop_image_fn)(fz_context *ctx, fz_image *image);

typedef fz_pixmap *(fz_image_get_pixmap_fn)(fz_context *ctx, fz_image *im, fz_irect *subarea, int w, int h, int *l2factor);

typedef void (fz_image_get_digest_fn)(fz_context *ctx, fz_image *im, unsigned char digest[16]);

void fz_image_digest(fz_context *ctx, fz_image *img, unsigned char digest[16]);

typedef size_t (fz_image_get_size_fn)(fz_context *, fz_image *);

fz_image *fz_new_image_of_size(fz_context *ctx,
        int w,
        int h,
        int bpc,
        fz_colorspace *colorspace,
        int xres,
        int yres,
        int interpolate,
        int imagemask,
        const float *decode,
        const int *colorkey,
        fz_image *mask,
        size_t size,
        fz_image_get_pixmap_fn *get_pixmap,
        fz_image_get_size_fn *get_size,
        fz_image_get_digest_fn *get_digest,
        fz_drop_image_fn *drop);
 
#define fz_new_derived_image(CTX,W,H,B,CS,X,Y,I,IM,D,C,M,T,G,S,MD5,Z) \
    ((T*)Memento_label(fz_new_image_of_size(CTX,W,H,B,CS,X,Y,I,IM,D,C,M,sizeof(T),G,S,MD5,Z),#T))

fz_image *fz_new_image_from_compressed_buffer(fz_context *ctx, int w, int h, int bpc, fz_colorspace *colorspace, int xres, int yres, int interpolate, int imagemask, const float *decode, const int *colorkey, fz_compressed_buffer *buffer, fz_image *mask);

fz_image *fz_new_image_from_pixmap(fz_context *ctx, fz_pixmap *pixmap, fz_image *mask);

fz_image *fz_new_image_from_buffer(fz_context *ctx, fz_buffer *buffer);
fz_image *fz_new_jpx_image_from_buffer(fz_context *ctx, fz_buffer *buffer, fz_colorspace *cs);

fz_image *fz_new_image_from_file(fz_context *ctx, const char *path);

void fz_drop_image_imp(fz_context *ctx, fz_storable *image);

void fz_drop_image_base(fz_context *ctx, fz_image *image);

fz_pixmap *fz_decomp_image_from_stream(fz_context *ctx, fz_stream *stm, fz_compressed_image *image, fz_irect *subarea, int indexed, int l2factor, int *l2extra);

fz_pixmap *fz_convert_indexed_pixmap_to_base(fz_context *ctx, const fz_pixmap *src);

fz_pixmap *fz_convert_separation_pixmap_to_base(fz_context *ctx, const fz_pixmap *src);

size_t fz_image_size(fz_context *ctx, fz_image *im);

int fz_compressed_image_type(fz_context *ctx, fz_image *image);
 

struct fz_image
{
    fz_key_storable key_storable;
    int w, h;
    uint8_t n;
    uint8_t bpc;
    unsigned int imagemask:1;
    unsigned int interpolate:1;
    unsigned int use_colorkey:1;
    unsigned int use_decode:1;
    unsigned int decoded:1;
    unsigned int scalable:1;
    unsigned int intent:2;
    unsigned int has_intent:1;
    uint8_t orientation;
    fz_image *mask;
    int xres; /* As given in the image, not necessarily as rendered */
    int yres; /* As given in the image, not necessarily as rendered */
    fz_colorspace *colorspace;
    fz_drop_image_fn *drop_image;
    fz_image_get_pixmap_fn *get_pixmap;
    fz_image_get_digest_fn *get_digest;
    fz_image_get_size_fn *get_size;
    int colorkey[FZ_MAX_COLORS * 2];
    float decode[FZ_MAX_COLORS * 2];
};

void fz_image_resolution(fz_image *image, int *xres, int *yres);

uint8_t fz_image_orientation(fz_context *ctx, fz_image *image);
 
/*
    Return true if the image source is a lossy format such as JPEG,
    JPEG2000, or JPEG-XR.
*/
int fz_is_lossy_image(fz_context *ctx, fz_image *image);
 
fz_matrix
fz_image_orientation_matrix(fz_context *ctx, fz_image *image);

fz_compressed_buffer *fz_compressed_image_buffer(fz_context *ctx, fz_image *image);
void fz_set_compressed_image_buffer(fz_context *ctx, fz_compressed_image *cimg, fz_compressed_buffer *buf);

fz_pixmap *fz_pixmap_image_tile(fz_context *ctx, fz_pixmap_image *cimg);
void fz_set_pixmap_image_tile(fz_context *ctx, fz_pixmap_image *cimg, fz_pixmap *pix);
 
/* Implementation details: subject to change. */

fz_pixmap *fz_load_jpx(fz_context *ctx, const unsigned char *data, size_t size, fz_colorspace *cs);

void fz_opj_lock(fz_context *ctx);
void fz_opj_unlock(fz_context *ctx);
 

int fz_load_tiff_subimage_count(fz_context *ctx, const unsigned char *buf, size_t len);
fz_pixmap *fz_load_tiff_subimage(fz_context *ctx, const unsigned char *buf, size_t len, int subimage);
int fz_load_pnm_subimage_count(fz_context *ctx, const unsigned char *buf, size_t len);
fz_pixmap *fz_load_pnm_subimage(fz_context *ctx, const unsigned char *buf, size_t len, int subimage);
int fz_load_jbig2_subimage_count(fz_context *ctx, const unsigned char *buf, size_t len);
fz_pixmap *fz_load_jbig2_subimage(fz_context *ctx, const unsigned char *buf, size_t len, int subimage);
int fz_load_bmp_subimage_count(fz_context *ctx, const unsigned char *buf, size_t len);
fz_pixmap *fz_load_bmp_subimage(fz_context *ctx, const unsigned char *buf, size_t len, int subimage);
 
#endif