landaiqing/go-fitz
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init commit
Some checks failed
Test / test (1.22.x, macos-latest) (push) Has been cancelled
Details
Test / test (1.22.x, ubuntu-latest) (push) Has been cancelled
Details

Browse Source
This commit is contained in:
landaiqing
2026-02-10 14:45:18 +08:00
parent a530a79566
commit 5ce88674da
142 changed files with 12394 additions and 4280 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
include/mupdf/fitz.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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 MUDPF_FITZ_H
#define MUDPF_FITZ_H
@@ -9,6 +31,8 @@ extern "C" {
#include "mupdf/fitz/config.h"
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/log.h"
#include "mupdf/fitz/crypt.h"
#include "mupdf/fitz/getopt.h"
@@ -26,14 +50,14 @@ extern "C" {
#include "mupdf/fitz/compress.h"
#include "mupdf/fitz/compressed-buffer.h"
#include "mupdf/fitz/filter.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/archive.h"
#include "mupdf/fitz/heap.h"
/* Resources */
#include "mupdf/fitz/store.h"
#include "mupdf/fitz/colorspace.h"
#include "mupdf/fitz/color.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/glyph.h"
#include "mupdf/fitz/bitmap.h"
#include "mupdf/fitz/image.h"
#include "mupdf/fitz/shade.h"
@@ -41,7 +65,7 @@ extern "C" {
#include "mupdf/fitz/path.h"
#include "mupdf/fitz/text.h"
#include "mupdf/fitz/separation.h"
#include "mupdf/fitz/color-management.h"
#include "mupdf/fitz/glyph.h"
#include "mupdf/fitz/device.h"
#include "mupdf/fitz/display-list.h"
@@ -54,22 +78,17 @@ extern "C" {
#include "mupdf/fitz/link.h"
#include "mupdf/fitz/outline.h"
#include "mupdf/fitz/document.h"
#include "mupdf/fitz/annotation.h"
#include "mupdf/fitz/util.h"
/* Output formats */
#include "mupdf/fitz/writer.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/output-pnm.h"
#include "mupdf/fitz/output-png.h"
#include "mupdf/fitz/output-pwg.h"
#include "mupdf/fitz/output-pcl.h"
#include "mupdf/fitz/output-pclm.h"
#include "mupdf/fitz/output-ps.h"
#include "mupdf/fitz/output-psd.h"
#include "mupdf/fitz/write-pixmap.h"
#include "mupdf/fitz/output-svg.h"
#include "mupdf/fitz/output-tga.h"
#include "mupdf/fitz/story.h"
#include "mupdf/fitz/story-writer.h"
#ifdef __cplusplus
}

43
include/mupdf/fitz/annotation.h
View File

@@ -1,43 +0,0 @@
#ifndef MUPDF_FITZ_ANNOTATION_H
#define MUPDF_FITZ_ANNOTATION_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/document.h"
/*
fz_new_annot_of_size: Create and initialize an annotation struct.
*/
fz_annot *fz_new_annot_of_size(fz_context *ctx, int size);
#define fz_new_derived_annot(CTX, TYPE) \
((TYPE *)Memento_label(fz_new_annot_of_size(CTX,sizeof(TYPE)),#TYPE))
/*
fz_keep_annot: Take a new reference to an annotation.
*/
fz_annot *fz_keep_annot(fz_context *ctx, fz_annot *annot);
/*
fz_drop_annot: Drop a reference to an annotation. If the
reference count reaches zero, annot will be destroyed.
*/
void fz_drop_annot(fz_context *ctx, fz_annot *annot);
/*
fz_first_annot: Return a pointer to the first annotation on a page.
*/
fz_annot *fz_first_annot(fz_context *ctx, fz_page *page);
/*
fz_next_annot: Return a pointer to the next annotation on a page.
*/
fz_annot *fz_next_annot(fz_context *ctx, fz_annot *annot);
/*
fz_bound_annot: Return the bounding rectangle of the annotation.
*/
fz_rect *fz_bound_annot(fz_context *ctx, fz_annot *annot, fz_rect *rect);
#endif

366
include/mupdf/fitz/archive.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2022 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_ARCHIVE_H
#define MUPDF_FITZ_ARCHIVE_H
@@ -5,32 +27,25 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/stream.h"
#include "mupdf/fitz/tree.h"
typedef struct fz_archive_s fz_archive;
/* PUBLIC API */
struct fz_archive_s
{
fz_stream *file;
const char *format;
/**
fz_archive:
void (*drop_archive)(fz_context *ctx, fz_archive *arch);
int (*count_entries)(fz_context *ctx, fz_archive *arch);
const char *(*list_entry)(fz_context *ctx, fz_archive *arch, int idx);
int (*has_entry)(fz_context *ctx, fz_archive *arch, const char *name);
fz_buffer *(*read_entry)(fz_context *ctx, fz_archive *arch, const char *name);
fz_stream *(*open_entry)(fz_context *ctx, fz_archive *arch, const char *name);
};
fz_archive provides methods for accessing "archive" files.
An archive file is a conceptual entity that contains multiple
files, which can be counted, enumerated, and read.
/*
fz_new_archive: Create and initialize an archive struct.
Implementations of fz_archive based upon directories, zip
and tar files are included.
*/
fz_archive *fz_new_archive_of_size(fz_context *ctx, fz_stream *file, int size);
#define fz_new_derived_archive(C,F,M) \
((M*)Memento_label(fz_new_archive_of_size(C, F, sizeof(M)), #M))
typedef struct fz_archive fz_archive;
/*
fz_open_archive: Open a zip or tar archive
/**
Open a zip or tar archive
Open a file and identify its archive type based on the archive
signature contained inside.
@@ -39,16 +54,25 @@ fz_archive *fz_new_archive_of_size(fz_context *ctx, fz_stream *file, int size);
*/
fz_archive *fz_open_archive(fz_context *ctx, const char *filename);
/*
fz_open_archive_with_stream: Open zip or tar archive stream.
/**
Open zip or tar archive stream.
Open an archive using a seekable stream object rather than
opening a file or directory on disk.
*/
fz_archive *fz_open_archive_with_stream(fz_context *ctx, fz_stream *file);
/*
fz_open_directory: Open a directory as if it was an archive.
/**
Open zip or tar archive stream.
Does the same as fz_open_archive_with_stream, but will not throw
an error in the event of failing to recognise the format. Will
still throw errors in other cases though!
*/
fz_archive *fz_try_open_archive_with_stream(fz_context *ctx, fz_stream *file);
/**
Open a directory as if it was an archive.
A special case where a directory is opened as if it was an
archive.
@@ -61,38 +85,63 @@ fz_archive *fz_open_archive_with_stream(fz_context *ctx, fz_stream *file);
*/
fz_archive *fz_open_directory(fz_context *ctx, const char *path);
/**
Determine if a given path is a directory.
In the case of the path not existing, or having no access
we will return 0.
*/
int fz_is_directory(fz_context *ctx, const char *path);
/*
fz_drop_archive: Release an open archive.
/**
Drop a reference to an archive.
Any allocations for the archive are freed.
When the last reference is dropped, this closes and releases
any memory or filehandles associated with the archive.
*/
void fz_drop_archive(fz_context *ctx, fz_archive *arch);
/*
fz_archive_format: Returns the name of the archive format.
/**
Keep a reference to an archive.
*/
fz_archive *
fz_keep_archive(fz_context *ctx, fz_archive *arch);
/**
Return a pointer to a string describing the format of the
archive.
The lifetime of the string is unspecified (in current
implementations the string will persist until the archive
is closed, but this is not guaranteed).
*/
const char *fz_archive_format(fz_context *ctx, fz_archive *arch);
/*
fz_count_archive_entries: Number of entries in archive.
/**
Number of entries in archive.
Will always return a value >= 0.
May throw an exception if this type of archive cannot count the
entries (such as a directory).
*/
int fz_count_archive_entries(fz_context *ctx, fz_archive *arch);
/*
fz_list_archive_entry: Get listed name of entry position idx.
/**
Get listed name of entry position idx.
idx: Must be a value >= 0 < return value from
fz_count_archive_entries. If not in range NULL will be
returned.
May throw an exception if this type of archive cannot list the
entries (such as a directory).
*/
const char *fz_list_archive_entry(fz_context *ctx, fz_archive *arch, int idx);
/*
fz_has_archive_entry: Check if entry by given name exists.
/**
Check if entry by given name exists.
If named entry does not exist 0 will be returned, if it does
exist 1 is returned.
@@ -102,35 +151,76 @@ const char *fz_list_archive_entry(fz_context *ctx, fz_archive *arch, int idx);
*/
int fz_has_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);
/*
fz_open_archive_entry: Opens an archive entry as a stream.
/**
Opens an archive entry as a stream.
name: Entry name to look for, this must be an exact match to
the entry name in the archive.
Throws an exception if a matching entry cannot be found.
*/
fz_stream *fz_open_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);
/*
fz_read_archive_entry: Reads all bytes in an archive entry
/**
Opens an archive entry as a stream.
Returns NULL if a matching entry cannot be found, otherwise
behaves exactly as fz_open_archive_entry.
*/
fz_stream *fz_try_open_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);
/**
Reads all bytes in an archive entry
into a buffer.
name: Entry name to look for, this must be an exact match to
the entry name in the archive.
*/
Throws an exception if a matching entry cannot be found.
*/
fz_buffer *fz_read_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);
/*
fz_is_tar_archive: Detect if stream object is a tar achieve.
/**
Reads all bytes in an archive entry
into a buffer.
name: Entry name to look for, this must be an exact match to
the entry name in the archive.
Returns NULL if a matching entry cannot be found. Otherwise behaves
the same as fz_read_archive_entry. Exceptions may be thrown.
*/
fz_buffer *fz_try_read_archive_entry(fz_context *ctx, fz_archive *arch, const char *name);
/**
fz_archive: tar implementation
*/
/**
Detect if stream object is a tar archive.
Assumes that the stream object is seekable.
*/
int fz_is_tar_archive(fz_context *ctx, fz_stream *file);
/*
fz_open_tar_archive: Open a tar archive file.
/**
Detect if stream object is an archive supported by libarchive.
An exception is throw if the file is not a tar archive as
Assumes that the stream object is seekable.
*/
int fz_is_libarchive_archive(fz_context *ctx, fz_stream *file);
/**
Detect if stream object is a cfb archive.
Assumes that the stream object is seekable.
*/
int fz_is_cfb_archive(fz_context *ctx, fz_stream *file);
/**
Open a tar archive file.
An exception is thrown if the file is not a tar archive as
indicated by the presence of a tar signature.
filename: a path to a tar archive file as it would be given to
@@ -138,29 +228,73 @@ int fz_is_tar_archive(fz_context *ctx, fz_stream *file);
*/
fz_archive *fz_open_tar_archive(fz_context *ctx, const char *filename);
/*
fz_open_tar_archive_with_stream: Open a tar archive stream.
/**
Open a tar archive stream.
Open an archive using a seekable stream object rather than
opening a file or directory on disk.
An exception is throw if the stream is not a tar archive as
An exception is thrown if the stream is not a tar archive as
indicated by the presence of a tar signature.
*/
fz_archive *fz_open_tar_archive_with_stream(fz_context *ctx, fz_stream *file);
/*
fz_is_zip_archive: Detect if stream object is a zip archive.
/**
Open an archive using libarchive.
An exception is thrown if the file is not supported by libarchive.
filename: a path to an archive file as it would be given to
open(2).
*/
fz_archive *fz_open_libarchive_archive(fz_context *ctx, const char *filename);
/**
Open an archive using libarchive.
Open an archive using a seekable stream object rather than
opening a file or directory on disk.
An exception is thrown if the stream is not supported by libarchive.
*/
fz_archive *fz_open_libarchive_archive_with_stream(fz_context *ctx, fz_stream *file);
/**
Open a cfb file as an archive.
An exception is thrown if the file is not recognised as a cfb.
filename: a path to an archive file as it would be given to
open(2).
*/
fz_archive *fz_open_cfb_archive(fz_context *ctx, const char *filename);
/**
Open a cfb file as an archive.
Open an archive using a seekable stream object rather than
opening a file or directory on disk.
An exception is thrown if the file is not recognised as a chm.
*/
fz_archive *fz_open_cfb_archive_with_stream(fz_context *ctx, fz_stream *file);
/**
fz_archive: zip implementation
*/
/**
Detect if stream object is a zip archive.
Assumes that the stream object is seekable.
*/
int fz_is_zip_archive(fz_context *ctx, fz_stream *file);
/*
fz_open_zip_archive: Open a zip archive file.
/**
Open a zip archive file.
An exception is throw if the file is not a zip archive as
An exception is thrown if the file is not a zip archive as
indicated by the presence of a zip signature.
filename: a path to a zip archive file as it would be given to
@@ -168,23 +302,143 @@ int fz_is_zip_archive(fz_context *ctx, fz_stream *file);
*/
fz_archive *fz_open_zip_archive(fz_context *ctx, const char *path);
/*
fz_open_zip_archive: Open a zip archive stream.
/**
Open a zip archive stream.
Open an archive using a seekable stream object rather than
opening a file or directory on disk.
An exception is throw if the stream is not a zip archive as
An exception is thrown if the stream is not a zip archive as
indicated by the presence of a zip signature.
*/
fz_archive *fz_open_zip_archive_with_stream(fz_context *ctx, fz_stream *file);
typedef struct fz_zip_writer_s fz_zip_writer;
/**
fz_zip_writer offers methods for creating and writing zip files.
It can be seen as the reverse of the fz_archive zip
implementation.
*/
typedef struct fz_zip_writer fz_zip_writer;
/**
Create a new zip writer that writes to a given file.
Open an archive using a seekable stream object rather than
opening a file or directory on disk.
*/
fz_zip_writer *fz_new_zip_writer(fz_context *ctx, const char *filename);
/**
Create a new zip writer that writes to a given output stream.
Ownership of out passes in immediately upon calling this function.
The caller should never drop the fz_output, even if this function throws
an exception.
*/
fz_zip_writer *fz_new_zip_writer_with_output(fz_context *ctx, fz_output *out);
/**
Given a buffer of data, (optionally) compress it, and add it to
the zip file with the given name.
*/
void fz_write_zip_entry(fz_context *ctx, fz_zip_writer *zip, const char *name, fz_buffer *buf, int compress);
/**
Close the zip file for writing.
This flushes any pending data to the file. This can throw
exceptions.
*/
void fz_close_zip_writer(fz_context *ctx, fz_zip_writer *zip);
/**
Drop the reference to the zipfile.
In common with other 'drop' methods, this will never throw an
exception.
*/
void fz_drop_zip_writer(fz_context *ctx, fz_zip_writer *zip);
/**
Create an archive that holds named buffers.
tree can either be a preformed tree with fz_buffers as values,
or it can be NULL for an empty tree.
*/
fz_archive *fz_new_tree_archive(fz_context *ctx, fz_tree *tree);
/**
Add a named buffer to an existing tree archive.
The tree will take a new reference to the buffer. Ownership
is not transferred.
*/
void fz_tree_archive_add_buffer(fz_context *ctx, fz_archive *arch_, const char *name, fz_buffer *buf);
/**
Add a named block of data to an existing tree archive.
The data will be copied into a buffer, and so the caller
may free it as soon as this returns.
*/
void fz_tree_archive_add_data(fz_context *ctx, fz_archive *arch_, const char *name, const void *data, size_t size);
/**
Create a new multi archive (initially empty).
*/
fz_archive *fz_new_multi_archive(fz_context *ctx);
/**
Add an archive to the set of archives handled by a multi
archive.
If path is NULL, then the archive contents will appear at the
top level, otherwise, the archives contents will appear prefixed
by path.
*/
void fz_mount_multi_archive(fz_context *ctx, fz_archive *arch_, fz_archive *sub, const char *path);
typedef int (fz_recognize_archive_fn)(fz_context *, fz_stream *);
typedef fz_archive *(fz_open_archive_fn)(fz_context *, fz_stream *);
typedef struct
{
fz_recognize_archive_fn *recognize;
fz_open_archive_fn *open;
}
fz_archive_handler;
FZ_DATA extern const fz_archive_handler fz_libarchive_archive_handler;
void fz_register_archive_handler(fz_context *ctx, const fz_archive_handler *handler);
/**
Implementation details: Subject to change.
*/
struct fz_archive
{
int refs;
fz_stream *file;
const char *format;
void (*drop_archive)(fz_context *ctx, fz_archive *arch);
int (*count_entries)(fz_context *ctx, fz_archive *arch);
const char *(*list_entry)(fz_context *ctx, fz_archive *arch, int idx);
int (*has_entry)(fz_context *ctx, fz_archive *arch, const char *name);
fz_buffer *(*read_entry)(fz_context *ctx, fz_archive *arch, const char *name);
fz_stream *(*open_entry)(fz_context *ctx, fz_archive *arch, const char *name);
};
fz_archive *fz_new_archive_of_size(fz_context *ctx, fz_stream *file, int size);
#define fz_new_derived_archive(C,F,M) \
((M*)Memento_label(fz_new_archive_of_size(C, F, sizeof(M)), #M))
#endif

123
include/mupdf/fitz/band-writer.h
View File

@@ -1,23 +1,99 @@
// Copyright (C) 2004-2021 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_BAND_WRITER_H
#define MUPDF_FITZ_BAND_WRITER_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/color.h"
#include "mupdf/fitz/separation.h"
/*
/**
fz_band_writer
*/
typedef struct fz_band_writer_s fz_band_writer;
typedef struct fz_band_writer fz_band_writer;
typedef void (fz_write_header_fn)(fz_context *ctx, fz_band_writer *writer, const fz_colorspace *cs);
/**
Cause a band writer to write the header for
a banded image with the given properties/dimensions etc. This
also configures the bandwriter for the format of the data to be
passed in future calls.
w, h: Width and Height of the entire page.
n: Number of components (including spots and alphas).
alpha: Number of alpha components.
xres, yres: X and Y resolutions in dpi.
cs: Colorspace (NULL for bitmaps)
seps: Separation details (or NULL).
*/
void fz_write_header(fz_context *ctx, fz_band_writer *writer, int w, int h, int n, int alpha, int xres, int yres, int pagenum, fz_colorspace *cs, fz_separations *seps);
/**
Cause a band writer to write the next band
of data for an image.
stride: The byte offset from the first byte of the data
for a pixel to the first byte of the data for the same pixel
on the row below.
band_height: The number of lines in this band.
samples: Pointer to first byte of the data.
*/
void fz_write_band(fz_context *ctx, fz_band_writer *writer, int stride, int band_height, const unsigned char *samples);
/**
Finishes up the output and closes the band writer. After this
call no more headers or bands may be written.
*/
void fz_close_band_writer(fz_context *ctx, fz_band_writer *writer);
/**
Drop the reference to the band writer, causing it to be
destroyed.
Never throws an exception.
*/
void fz_drop_band_writer(fz_context *ctx, fz_band_writer *writer);
/* Implementation details: subject to change. */
typedef void (fz_write_header_fn)(fz_context *ctx, fz_band_writer *writer, fz_colorspace *cs);
typedef void (fz_write_band_fn)(fz_context *ctx, fz_band_writer *writer, int stride, int band_start, int band_height, const unsigned char *samples);
typedef void (fz_write_trailer_fn)(fz_context *ctx, fz_band_writer *writer);
typedef void (fz_close_band_writer_fn)(fz_context *ctx, fz_band_writer *writer);
typedef void (fz_drop_band_writer_fn)(fz_context *ctx, fz_band_writer *writer);
struct fz_band_writer_s
struct fz_band_writer
{
fz_drop_band_writer_fn *drop;
fz_close_band_writer_fn *close;
fz_write_header_fn *header;
fz_write_band_fn *band;
fz_write_trailer_fn *trailer;
@@ -37,44 +113,5 @@ struct fz_band_writer_s
fz_band_writer *fz_new_band_writer_of_size(fz_context *ctx, size_t size, fz_output *out);
#define fz_new_band_writer(C,M,O) ((M *)Memento_label(fz_new_band_writer_of_size(ctx, sizeof(M), O), #M))
/*
fz_write_header: Cause a band writer to write the header for
a banded image with the given properties/dimensions etc. This
also configures the bandwriter for the format of the data to be
passed in future calls.
w, h: Width and Height of the entire page.
n: Number of components (including spots and alphas).
alpha: Number of alpha components.
xres, yres: X and Y resolutions in dpi.
pagenum: Page number
cs: Colorspace (NULL for bitmaps)
seps: Separation details (or NULL).
Throws exception if incompatible data format.
*/
void fz_write_header(fz_context *ctx, fz_band_writer *writer, int w, int h, int n, int alpha, int xres, int yres, int pagenum, const fz_colorspace *cs, fz_separations *seps);
/*
fz_write_band: Cause a band writer to write the next band
of data for an image.
stride: The byte offset from the first byte of the data
for a pixel to the first byte of the data for the same pixel
on the row below.
band_height: The number of lines in this band.
samples: Pointer to first byte of the data.
*/
void fz_write_band(fz_context *ctx, fz_band_writer *writer, int stride, int band_height, const unsigned char *samples);
void fz_drop_band_writer(fz_context *ctx, fz_band_writer *writer);
#endif

13
include/mupdf/fitz/bidi.h
View File

@@ -1,4 +1,4 @@
/*
/**
Bidirectional text processing.
Derived from the SmartOffice code, which is itself derived
@@ -21,8 +21,11 @@
#define FITZ_BIDI_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
typedef enum fz_bidi_direction_e
/* Implementation details: subject to change. */
typedef enum
{
FZ_BIDI_LTR = 0,
FZ_BIDI_RTL = 1,
@@ -30,14 +33,14 @@ typedef enum fz_bidi_direction_e
}
fz_bidi_direction;
typedef enum fz_bidi_flags_e
typedef enum
{
FZ_BIDI_CLASSIFY_WHITE_SPACE = 1,
FZ_BIDI_REPLACE_TAB = 2
}
fz_bidi_flags;
/*
/**
Prototype for callback function supplied to fz_bidi_fragment_text.
@param fragment first character in fragment
@@ -56,7 +59,7 @@ typedef void (fz_bidi_fragment_fn)(const uint32_t *fragment,
int script,
void *arg);
/*
/**
Partitions the given Unicode sequence into one or more
unidirectional fragments and invokes the given callback
function for each fragment.

141
include/mupdf/fitz/bitmap.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_BITMAP_H
#define MUPDF_FITZ_BITMAP_H
@@ -5,44 +27,60 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/pixmap.h"
/*
Bitmaps have 1 bit per component. Only used for creating halftoned
versions of contone buffers, and saving out. Samples are stored msb
first, akin to pbms.
/**
Bitmaps have 1 bit per component. Only used for creating
halftoned versions of contone buffers, and saving out. Samples
are stored msb first, akin to pbms.
The internals of this struct are considered implementation
details and subject to change. Where possible, accessor
functions should be used in preference.
*/
typedef struct fz_bitmap_s fz_bitmap;
typedef struct
{
int refs;
int w, h, stride, n;
int xres, yres;
unsigned char *samples;
} fz_bitmap;
/*
fz_keep_bitmap: Take a reference to a bitmap.
/**
Take an additional reference to the bitmap. The same pointer
is returned.
bit: The bitmap to increment the reference for.
Returns bit.
Never throws exceptions.
*/
fz_bitmap *fz_keep_bitmap(fz_context *ctx, fz_bitmap *bit);
/*
fz_drop_bitmap: Drop a reference and free a bitmap.
/**
Drop a reference to the bitmap. When the reference count reaches
zero, the bitmap will be destroyed.
Decrement the reference count for the bitmap. When no
references remain the pixmap will be freed.
Never throws exceptions.
*/
void fz_drop_bitmap(fz_context *ctx, fz_bitmap *bit);
/*
A halftone is a set of threshold tiles, one per component. Each
threshold tile is a pixmap, possibly of varying sizes and phases.
Currently, we only provide one 'default' halftone tile for operating
on 1 component plus alpha pixmaps (where the alpha is ignored). This
is signified by a fz_halftone pointer to NULL.
/**
Invert bitmap.
Never throws exceptions.
*/
typedef struct fz_halftone_s fz_halftone;
void fz_invert_bitmap(fz_context *ctx, fz_bitmap *bmp);
/*
fz_new_bitmap_from_pixmap: Make a bitmap from a pixmap and a halftone.
/**
A halftone is a set of threshold tiles, one per component. Each
threshold tile is a pixmap, possibly of varying sizes and
phases. Currently, we only provide one 'default' halftone tile
for operating on 1 component plus alpha pixmaps (where the alpha
is ignored). This is signified by a fz_halftone pointer to NULL.
*/
typedef struct fz_halftone fz_halftone;
pix: The pixmap to generate from. Currently must be a single color
component with no alpha.
/**
Make a bitmap from a pixmap and a halftone.
pix: The pixmap to generate from. Currently must be a single
color component with no alpha.
ht: The halftone to use. NULL implies the default halftone.
@@ -51,13 +89,13 @@ typedef struct fz_halftone_s fz_halftone;
*/
fz_bitmap *fz_new_bitmap_from_pixmap(fz_context *ctx, fz_pixmap *pix, fz_halftone *ht);
/*
fz_new_bitmap_from_pixmap_band: Make a bitmap from a pixmap and a
/**
Make a bitmap from a pixmap and a
halftone, allowing for the position of the pixmap within an
overall banded rendering.
pix: The pixmap to generate from. Currently must be a single color
component with no alpha.
pix: The pixmap to generate from. Currently must be a single
color component with no alpha.
ht: The halftone to use. NULL implies the default halftone.
@@ -69,16 +107,8 @@ fz_bitmap *fz_new_bitmap_from_pixmap(fz_context *ctx, fz_pixmap *pix, fz_halfton
*/
fz_bitmap *fz_new_bitmap_from_pixmap_band(fz_context *ctx, fz_pixmap *pix, fz_halftone *ht, int band_start);
struct fz_bitmap_s
{
int refs;
int w, h, stride, n;
int xres, yres;
unsigned char *samples;
};
/*
fz_new_bitmap: Create a new bitmap.
/**
Create a new bitmap.
w, h: Width and Height for the bitmap
@@ -91,8 +121,8 @@ struct fz_bitmap_s
*/
fz_bitmap *fz_new_bitmap(fz_context *ctx, int w, int h, int n, int xres, int yres);
/*
fz_bitmap_details: Retrieve details of a given bitmap.
/**
Retrieve details of a given bitmap.
bitmap: The bitmap to query.
@@ -100,21 +130,22 @@ fz_bitmap *fz_new_bitmap(fz_context *ctx, int w, int h, int n, int xres, int yre
h: Pointer to storage to retrieve height (or NULL).
n: Pointer to storage to retrieve number of color components (or NULL).
n: Pointer to storage to retrieve number of color components (or
NULL).
stride: Pointer to storage to retrieve bitmap stride (or NULL).
*/
void fz_bitmap_details(fz_bitmap *bitmap, int *w, int *h, int *n, int *stride);
/*
fz_clear_bitmap: Clear a previously created bitmap.
/**
Set the entire bitmap to 0.
bit: The bitmap to clear.
Never throws exceptions.
*/
void fz_clear_bitmap(fz_context *ctx, fz_bitmap *bit);
/*
fz_default_halftone: Create a 'default' halftone structure
/**
Create a 'default' halftone structure
for the given number of components.
num_comps: The number of components to use.
@@ -125,15 +156,19 @@ void fz_clear_bitmap(fz_context *ctx, fz_bitmap *bit);
*/
fz_halftone *fz_default_halftone(fz_context *ctx, int num_comps);
/*
fz_keep_halftone: Take an additional reference to a
halftone.
/**
Take an additional reference to the halftone. The same pointer
is returned.
Never throws exceptions.
*/
fz_halftone *fz_keep_halftone(fz_context *ctx, fz_halftone *half);
/*
fz_drop_halftone: Drop a reference to a halftone. If the
reference count reaches zero, ht will be destroyed.
/**
Drop a reference to the halftone. When the reference count
reaches zero, the halftone is destroyed.
Never throws exceptions.
*/
void fz_drop_halftone(fz_context *ctx, fz_halftone *ht);

205
include/mupdf/fitz/buffer.h
View File

@@ -1,31 +1,69 @@
// Copyright (C) 2004-2023 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_BUFFER_H
#define MUPDF_FITZ_BUFFER_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
/*
fz_buffer is a wrapper around a dynamically allocated array of bytes.
/**
fz_buffer is a wrapper around a dynamically allocated array of
bytes.
Buffers have a capacity (the number of bytes storage immediately
available) and a current size.
The contents of the structure are considered implementation
details and are subject to change. Users should use the accessor
functions in preference.
*/
typedef struct fz_buffer_s fz_buffer;
typedef struct
{
int refs;
unsigned char *data;
size_t cap, len;
int unused_bits;
int shared;
} fz_buffer;
/*
fz_keep_buffer: Increment the reference count for a buffer.
/**
Take an additional reference to the buffer. The same pointer
is returned.
Returns a pointer to the buffer.
Never throws exceptions.
*/
fz_buffer *fz_keep_buffer(fz_context *ctx, fz_buffer *buf);
/*
fz_drop_buffer: Decrement the reference count for a buffer.
/**
Drop a reference to the buffer. When the reference count reaches
zero, the buffer is destroyed.
Never throws exceptions.
*/
void fz_drop_buffer(fz_context *ctx, fz_buffer *buf);
/*
fz_buffer_storage: Retrieve internal memory of buffer.
/**
Retrieve internal memory of buffer.
datap: Output parameter that will be pointed to the data.
@@ -33,81 +71,110 @@ void fz_drop_buffer(fz_context *ctx, fz_buffer *buf);
*/
size_t fz_buffer_storage(fz_context *ctx, fz_buffer *buf, unsigned char **datap);
/*
fz_string_from_buffer: Ensure that a buffer's data ends in a
/**
Ensure that a buffer's data ends in a
0 byte, and return a pointer to it.
*/
const char *fz_string_from_buffer(fz_context *ctx, fz_buffer *buf);
/*
fz_new_buffer: Create a new buffer.
capacity: Initial capacity.
Returns pointer to new buffer.
*/
fz_buffer *fz_new_buffer(fz_context *ctx, size_t capacity);
/*
fz_new_buffer_from_data: Create a new buffer with existing data.
/**
Create a new buffer with existing data.
data: Pointer to existing data.
size: Size of existing data.
Takes ownership of data. Does not make a copy. Calls fz_free on the
data when the buffer is deallocated. Do not use 'data' after passing
to this function.
Takes ownership of data. Does not make a copy. Calls fz_free on
the data when the buffer is deallocated. Do not use 'data' after
passing to this function.
Returns pointer to new buffer. Throws exception on allocation
failure.
*/
fz_buffer *fz_new_buffer_from_data(fz_context *ctx, unsigned char *data, size_t size);
/*
fz_new_buffer_from_shared_data: Like fz_new_buffer, but does not take ownership.
/**
Like fz_new_buffer, but does not take ownership.
*/
fz_buffer *fz_new_buffer_from_shared_data(fz_context *ctx, const unsigned char *data, size_t size);
/*
fz_new_buffer_from_copied_data: Create a new buffer containing a copy of the passed data.
/**
Create a new buffer containing a copy of the passed data.
*/
fz_buffer *
fz_new_buffer_from_copied_data(fz_context *ctx, const unsigned char *data, size_t size);
fz_buffer *fz_new_buffer_from_copied_data(fz_context *ctx, const unsigned char *data, size_t size);
/*
fz_new_buffer_from_base64: Create a new buffer with data decoded from a base64 input string.
/**
Make a new buffer, containing a copy of the data used in
the original.
*/
fz_buffer *fz_clone_buffer(fz_context *ctx, fz_buffer *buf);
/**
Create a new buffer with data decoded from a base64 input string.
*/
fz_buffer *fz_new_buffer_from_base64(fz_context *ctx, const char *data, size_t size);
/*
fz_resize_buffer: Ensure that a buffer has a given capacity,
/**
Ensure that a buffer has a given capacity,
truncating data if required.
capacity: The desired capacity for the buffer. If the current size
of the buffer contents is smaller than capacity, it is truncated.
capacity: The desired capacity for the buffer. If the current
size of the buffer contents is smaller than capacity, it is
truncated.
*/
void fz_resize_buffer(fz_context *ctx, fz_buffer *buf, size_t capacity);
/*
fz_grow_buffer: Make some space within a buffer (i.e. ensure that
/**
Make some space within a buffer (i.e. ensure that
capacity > size).
*/
void fz_grow_buffer(fz_context *ctx, fz_buffer *buf);
/*
fz_trim_buffer: Trim wasted capacity from a buffer by resizing internal memory.
/**
Trim wasted capacity from a buffer by resizing internal memory.
*/
void fz_trim_buffer(fz_context *ctx, fz_buffer *buf);
/*
fz_append_buffer: Append the contents of source buffer to destination buffer.
/**
Empties the buffer. Storage is not freed, but is held ready
to be reused as the buffer is refilled.
Never throws exceptions.
*/
void fz_clear_buffer(fz_context *ctx, fz_buffer *buf);
/**
Create a new buffer with a (subset of) the data from the buffer.
start: if >= 0, offset from start of buffer, if < 0 offset from end of buffer.
end: if >= 0, offset from start of buffer, if < 0 offset from end of buffer.
*/
fz_buffer *fz_slice_buffer(fz_context *ctx, fz_buffer *buf, int64_t start, int64_t end);
/**
Append the contents of the source buffer onto the end of the
destination buffer, extending automatically as required.
Ownership of buffers does not change.
*/
void fz_append_buffer(fz_context *ctx, fz_buffer *destination, fz_buffer *source);
/*
/**
Write a base64 encoded data block, optionally with periodic newlines.
*/
void fz_append_base64(fz_context *ctx, fz_buffer *out, const unsigned char *data, size_t size, int newline);
/**
Append a base64 encoded fz_buffer, optionally with periodic newlines.
*/
void fz_append_base64_buffer(fz_context *ctx, fz_buffer *out, fz_buffer *data, int newline);
/**
fz_append_*: Append data to a buffer.
fz_append_printf: Format and append data to buffer using printf-like formatting (see fz_vsnprintf).
fz_append_pdf_string: Append a string with PDF syntax quotes and escapes.
The buffer will automatically grow as required.
*/
void fz_append_data(fz_context *ctx, fz_buffer *buf, const void *data, size_t len);
@@ -120,25 +187,53 @@ void fz_append_int32_be(fz_context *ctx, fz_buffer *buf, int x);
void fz_append_int16_be(fz_context *ctx, fz_buffer *buf, int x);
void fz_append_bits(fz_context *ctx, fz_buffer *buf, int value, int count);
void fz_append_bits_pad(fz_context *ctx, fz_buffer *buf);
void fz_append_printf(fz_context *ctx, fz_buffer *buffer, const char *fmt, ...);
void fz_append_vprintf(fz_context *ctx, fz_buffer *buffer, const char *fmt, va_list args);
/**
fz_append_pdf_string: Append a string with PDF syntax quotes and
escapes.
The buffer will automatically grow as required.
*/
void fz_append_pdf_string(fz_context *ctx, fz_buffer *buffer, const char *text);
/*
fz_terminate_buffer: Zero-terminate buffer in order to use as a C string.
/**
fz_append_printf: Format and append data to buffer using
printf-like formatting (see fz_vsnprintf).
This byte is invisible and does not affect the length of the buffer as returned by fz_buffer_storage.
The zero byte is written *after* the data, and subsequent writes will overwrite the terminating byte.
The buffer will automatically grow as required.
*/
void fz_append_printf(fz_context *ctx, fz_buffer *buffer, const char *fmt, ...);
/**
fz_append_vprintf: Format and append data to buffer using
printf-like formatting with varargs (see fz_vsnprintf).
*/
void fz_append_vprintf(fz_context *ctx, fz_buffer *buffer, const char *fmt, va_list args);
/**
Zero-terminate buffer in order to use as a C string.
This byte is invisible and does not affect the length of the
buffer as returned by fz_buffer_storage. The zero byte is
written *after* the data, and subsequent writes will overwrite
the terminating byte.
Subsequent changes to the size of the buffer (such as by
fz_buffer_trim, fz_buffer_grow, fz_resize_buffer, etc) may
invalidate this.
*/
void fz_terminate_buffer(fz_context *ctx, fz_buffer *buf);
/*
fz_md5_buffer: Create MD5 digest of buffer contents.
/**
Create an MD5 digest from buffer contents.
Never throws exceptions.
*/
void fz_md5_buffer(fz_context *ctx, fz_buffer *buffer, unsigned char digest[16]);
/*
fz_buffer_extract: Take ownership of buffer contents.
/**
Take ownership of buffer contents.
Performs the same task as fz_buffer_storage, but ownership of
the data buffer returns with this call. The buffer is left
empty.

115
include/mupdf/fitz/color-management.h
View File

@@ -1,115 +0,0 @@
#ifndef MUPDF_FITZ_COLOR_MANAGEMENT_H
#define MUPDF_FITZ_COLOR_MANAGEMENT_H
#include "mupdf/fitz/colorspace.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/pixmap.h"
/*
MuPDF can either run with or without color management. By default
MuPDF runs without color management. To enable color management,
a color management engine must be given to the context.
The context will then create one 'instance' of this engine per
cloned context. Every instance is tied to the particular context
in which it is created.
Profiles and links can be shared between instances.
*/
/*
fz_cmm_new_instance_fn: Create a new instance of the color
management engine, tied to the given context.
*/
typedef fz_cmm_instance *(fz_cmm_new_instance_fn)(fz_context *ctx);
/*
fz_cmm_drop_instance_fn: Drop a given instance of the color
management engine. No further calls will be made to this
instance.
*/
typedef void (fz_cmm_drop_instance_fn)(fz_cmm_instance *instance);
/*
fz_cmm_transform_pixmap_fn: Transform a pixmap according
to a link.
*/
typedef void (fz_cmm_transform_pixmap_fn)(fz_cmm_instance *ctx, fz_icclink *link, fz_pixmap *dst, fz_pixmap *src);
/*
fz_cmm_transform_color_fn: Transform some color values according
to a link.
*/
typedef void (fz_cmm_transform_color_fn)(fz_cmm_instance *ctx, fz_icclink *link, unsigned short *dst, const unsigned short *src);
/*
fz_cmm_init_link_fn: Create a new link between icc profiles.
*/
typedef void (fz_cmm_init_link_fn)(fz_cmm_instance *ctx, fz_icclink *link, const fz_iccprofile *dst, int dst_extras, const fz_iccprofile *src, int src_extras, const fz_iccprofile *prf, const fz_color_params *rend, int cmm_flags, int num_bytes, int copy_spots);
/*
fz_cmm_fin_link_fn: Drop a link.
*/
typedef void (fz_cmm_fin_link_fn)(fz_cmm_instance *ctx, fz_icclink *link);
/*
fz_cmm_init_profile_fn: Create the cmm specific data for the given
profile. The cmm handle is stored to profile->cmm_handle.
*/
typedef void (fz_cmm_init_profile_fn)(fz_cmm_instance *ctx, fz_iccprofile *profile);
/*
fz_cmm_fin_profile_fn: Drop the cmm specific data for the given
profile.
*/
typedef void (fz_cmm_fin_profile_fn)(fz_cmm_instance *ctx, fz_iccprofile *profile);
/*
Encapsulate details for a given color management engine into a single
structure.
*/
struct fz_cmm_engine_s {
fz_cmm_new_instance_fn *new_instance;
fz_cmm_drop_instance_fn *drop_instance;
fz_cmm_transform_pixmap_fn *transform_pixmap;
fz_cmm_transform_color_fn *transform_color;
fz_cmm_init_link_fn *init_link;
fz_cmm_fin_link_fn *fin_link;
fz_cmm_init_profile_fn *init_profile;
fz_cmm_fin_profile_fn *fin_profile;
int avoid_white_fix_flag;
};
/*
fz_get_cmm_engine: Read details of the current color
management engine. If NULL, we are working without
color management.
*/
const fz_cmm_engine *fz_get_cmm_engine(fz_context *ctx);
/*
fz_set_cmm_engine: Set the color management engine to
be used. This should only ever be called on the "base"
context before cloning it, and before opening any files.
Attempting to change the engine in use once a file has
been opened, or to use different color management engine
for the same file in different threads will lead to
undefined behaviour, including crashing.
Using different ICC engines for different files using
different sets of fz_contexts should theoretically be
possible.
*/
void fz_set_cmm_engine(fz_context *ctx, const fz_cmm_engine *engine);
/*
Currently we only provide a single color management
engine, based on a (modified) LCMS2.
An unmodified LCMS2 should work too, but only when restricted
to a single thread.
*/
extern fz_cmm_engine fz_cmm_engine_lcms;
#endif

427
include/mupdf/fitz/color.h Normal file
View File

@@ -0,0 +1,427 @@
// Copyright (C) 2004-2021 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
/**
Opaque type for an ICC Profile.
*/
typedef struct fz_icc_profile fz_icc_profile;
#endif
/**
Describes a given colorspace.
*/
typedef struct fz_colorspace fz_colorspace;
/**
Pixmaps represent a set of pixels for a 2 dimensional region of
a plane. Each pixel has n components per pixel. The components
are in the order process-components, spot-colors, alpha, where
there can be 0 of any of those types. The data is in
premultiplied alpha when rendering, but non-premultiplied for
colorspace conversions and rescaling.
*/
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,
};
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;
/**
Map from (case sensitive) rendering intent string to enumeration
value.
*/
int fz_lookup_rendering_intent(const char *name);
/**
Map from enumerated rendering intent to string.
The returned string is static and therefore must not be freed.
*/
const char *fz_rendering_intent_name(int ri);
/**
The maximum number of colorants available in any given
color/colorspace (not including alpha).
Changing this value will alter the amount of memory being used
(both stack and heap space), but not hugely. Speed should
(largely) be determined by the number of colors actually used.
*/
enum { FZ_MAX_COLORS = 32 };
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,
};
/**
Creates a new colorspace instance and returns a reference.
No internal checking is done that the colorspace type (e.g.
CMYK) matches with the flags (e.g. FZ_COLORSPACE_HAS_CMYK) or
colorant count (n) or name.
The reference should be dropped when it is finished with.
Colorspaces are immutable once created (with the exception of
setting up colorant names for separation spaces).
*/
fz_colorspace *fz_new_colorspace(fz_context *ctx, enum fz_colorspace_type type, int flags, int n, const char *name);
/**
Increment the reference count for the colorspace.
Returns the same pointer. Never throws an exception.
*/
fz_colorspace *fz_keep_colorspace(fz_context *ctx, fz_colorspace *colorspace);
/**
Drops a reference to the colorspace.
When the reference count reaches zero, the colorspace is
destroyed.
*/
void fz_drop_colorspace(fz_context *ctx, fz_colorspace *colorspace);
/**
Create an indexed colorspace.
The supplied lookup table is high palette entries long. Each
entry is n bytes long, where n is given by the number of
colorants in the base colorspace, one byte per colorant.
Ownership of lookup is passed it; it will be freed on
destruction, so must be heap allocated.
The colorspace will keep an additional reference to the base
colorspace that will be dropped on destruction.
The returned reference should be dropped when it is finished
with.
Colorspaces are immutable once created.
*/
fz_colorspace *fz_new_indexed_colorspace(fz_context *ctx, fz_colorspace *base, int high, unsigned char *lookup);
/**
Create a colorspace from an ICC profile supplied in buf.
Limited checking is done to ensure that the colorspace type is
appropriate for the supplied ICC profile.
An additional reference is taken to buf, which will be dropped
on destruction. Ownership is NOT passed in.
The returned reference should be dropped when it is finished
with.
Colorspaces are immutable once created.
*/
fz_colorspace *fz_new_icc_colorspace(fz_context *ctx, enum fz_colorspace_type type, int flags, const char *name, fz_buffer *buf);
/**
Create a calibrated gray colorspace.
The returned reference should be dropped when it is finished
with.
Colorspaces are immutable once created.
*/
fz_colorspace *fz_new_cal_gray_colorspace(fz_context *ctx, float wp[3], float bp[3], float gamma);
/**
Create a calibrated rgb colorspace.
The returned reference should be dropped when it is finished
with.
Colorspaces are immutable once created.
*/
fz_colorspace *fz_new_cal_rgb_colorspace(fz_context *ctx, float wp[3], float bp[3], float gamma[3], float matrix[9]);
/**
Query the type of colorspace.
*/
enum fz_colorspace_type fz_colorspace_type(fz_context *ctx, fz_colorspace *cs);
/**
Query the name of a colorspace.
The returned string has the same lifespan as the colorspace
does. Caller should not free it.
*/
const char *fz_colorspace_name(fz_context *ctx, fz_colorspace *cs);
/**
Query the number of colorants in a colorspace.
*/
int fz_colorspace_n(fz_context *ctx, fz_colorspace *cs);
/**
True for CMYK, Separation and DeviceN colorspaces.
*/
int fz_colorspace_is_subtractive(fz_context *ctx, fz_colorspace *cs);
/**
True if DeviceN color space has only colorants from the CMYK set.
*/
int fz_colorspace_device_n_has_only_cmyk(fz_context *ctx, fz_colorspace *cs);
/**
True if DeviceN color space has cyan magenta yellow or black as
one of its colorants.
*/
int fz_colorspace_device_n_has_cmyk(fz_context *ctx, fz_colorspace *cs);
/**
Tests for particular types of colorspaces
*/
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_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);
/**
Check to see that a colorspace is appropriate to be used as
a blending space (i.e. only grey, rgb or cmyk).
*/
int fz_is_valid_blend_colorspace(fz_context *ctx, fz_colorspace *cs);
/**
Get the 'base' colorspace for a colorspace.
For indexed colorspaces, this is the colorspace the index
decodes into. For all other colorspaces, it is the colorspace
itself.
The returned colorspace is 'borrowed' (i.e. no additional
references are taken or dropped).
*/
fz_colorspace *fz_base_colorspace(fz_context *ctx, fz_colorspace *cs);
/**
Retrieve global default colorspaces.
These return borrowed references that should not be dropped,
unless they are kept first.
*/
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);
/**
Assign a name for a given colorant in a colorspace.
Used while initially setting up a colorspace. The string is
copied into local storage, so need not be retained by the
caller.
*/
void fz_colorspace_name_colorant(fz_context *ctx, fz_colorspace *cs, int n, const char *name);
/**
Retrieve a the name for a colorant.
Returns a pointer with the same lifespan as the colorspace.
*/
const char *fz_colorspace_colorant(fz_context *ctx, fz_colorspace *cs, int n);
/* Color conversion */
/**
Clamp the samples in a color to the correct ranges for a
given colorspace.
*/
void fz_clamp_color(fz_context *ctx, fz_colorspace *cs, const float *in, float *out);
/**
Convert color values sv from colorspace ss into colorvalues dv
for colorspace ds, via an optional intervening space is,
respecting the given color_params.
*/
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 */
/**
Structure to hold default colorspaces.
*/
typedef struct
{
int refs;
fz_colorspace *gray;
fz_colorspace *rgb;
fz_colorspace *cmyk;
fz_colorspace *oi;
} fz_default_colorspaces;
/**
Create a new default colorspace structure with values inherited
from the context, and return a reference to it.
These can be overridden using fz_set_default_xxxx.
These should not be overridden while more than one caller has
the reference for fear of race conditions.
The caller should drop this reference once finished with it.
*/
fz_default_colorspaces *fz_new_default_colorspaces(fz_context *ctx);
/**
Keep an additional reference to the default colorspaces
structure.
Never throws exceptions.
*/
fz_default_colorspaces* fz_keep_default_colorspaces(fz_context *ctx, fz_default_colorspaces *default_cs);
/**
Drop a reference to the default colorspaces structure. When the
reference count reaches 0, the references it holds internally
to the underlying colorspaces will be dropped, and the structure
will be destroyed.
Never throws exceptions.
*/
void fz_drop_default_colorspaces(fz_context *ctx, fz_default_colorspaces *default_cs);
/**
Returns a reference to a newly cloned default colorspaces
structure.
The new clone may safely be altered without fear of race
conditions as the caller is the only reference holder.
*/
fz_default_colorspaces *fz_clone_default_colorspaces(fz_context *ctx, fz_default_colorspaces *base);
/**
Retrieve default colorspaces (typically page local).
If default_cs is non NULL, the default is retrieved from there,
otherwise the global default is retrieved.
These return borrowed references that should not be dropped,
unless they are kept first.
*/
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);
/**
Set new defaults within the default colorspace structure.
New references are taken to the new default, and references to
the old defaults dropped.
Never throws exceptions.
*/
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

237
include/mupdf/fitz/colorspace.h
View File

@@ -1,237 +0,0 @@
#ifndef MUPDF_FITZ_COLORSPACE_H
#define MUPDF_FITZ_COLORSPACE_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/store.h"
enum { FZ_MAX_COLORS = 32 };
enum
{
/* Same order as needed by lcms */
FZ_RI_PERCEPTUAL,
FZ_RI_RELATIVE_COLORIMETRIC,
FZ_RI_SATURATION,
FZ_RI_ABSOLUTE_COLORIMETRIC,
};
enum
{
FZ_COLORSPACE_IS_DEVICE = 1,
FZ_COLORSPACE_IS_ICC = 2,
FZ_COLORSPACE_IS_CAL = 4,
FZ_COLORSPACE_LAST_PUBLIC_FLAG = 8,
};
typedef struct fz_color_params_s fz_color_params;
struct fz_color_params_s
{
uint8_t ri;
uint8_t bp;
uint8_t op;
uint8_t opm;
};
int fz_lookup_rendering_intent(const char *name);
char *fz_rendering_intent_name(int ri);
/*
A fz_colorspace object represents an abstract colorspace. While
this should be treated as a black box by callers of the library at
this stage, know that it encapsulates knowledge of how to convert
colors to and from the colorspace, any lookup tables generated, the
number of components in the colorspace etc.
*/
typedef struct fz_colorspace_s fz_colorspace;
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_type fz_colorspace_type(fz_context *ctx, fz_colorspace *cs);
/*
A fz_iccprofile object encapsulates details about the icc profile. It
also includes the profile handle provided by the cmm and as such is used
in the creation of links between color spaces.
*/
typedef struct fz_iccprofile_s fz_iccprofile;
/*
A fz_icclink object encapsulates details about the link between profiles.
*/
typedef struct fz_icclink_s fz_icclink;
/*
Used to communicate any document internal page specific default color spaces.
*/
typedef struct fz_default_colorspaces_s fz_default_colorspaces;
/*
fz_colorspace_is_subtractive: Return true if a colorspace is subtractive.
True for CMYK, Separation and DeviceN colorspaces.
*/
int fz_colorspace_is_subtractive(fz_context *ctx, const fz_colorspace *cs);
/*
fz_colorspace_device_n_has_only_cmyk: Return true if devicen color space
has only colorants from the cmyk set.
*/
int fz_colorspace_device_n_has_only_cmyk(fz_context *ctx, const fz_colorspace *cs);
/*
fz_colorspace_device_n_has_cmyk: Return true if devicen color space has cyan
magenta yellow or black as one of its colorants.
*/
int fz_colorspace_device_n_has_cmyk(fz_context *ctx, const fz_colorspace *cs);
/*
Colorspace feature test functions.
*/
int fz_colorspace_is_gray(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_rgb(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_bgr(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_cmyk(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_lab(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_indexed(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_device_n(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_device(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_icc(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_cal(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_device_gray(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_device_cmyk(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_is_lab_icc(fz_context *ctx, const fz_colorspace *cs);
/*
fz_device_gray: Get colorspace representing device specific gray.
*/
fz_colorspace *fz_device_gray(fz_context *ctx);
/*
fz_device_rgb: Get colorspace representing device specific rgb.
*/
fz_colorspace *fz_device_rgb(fz_context *ctx);
/*
fz_device_bgr: Get colorspace representing device specific bgr.
*/
fz_colorspace *fz_device_bgr(fz_context *ctx);
/*
fz_device_cmyk: Get colorspace representing device specific CMYK.
*/
fz_colorspace *fz_device_cmyk(fz_context *ctx);
/*
fz_device_lab: Get colorspace representing device specific LAB.
*/
fz_colorspace *fz_device_lab(fz_context *ctx);
/*
fz_default_color_params: Get default color params for general color conversion.
*/
const fz_color_params *fz_default_color_params(fz_context *ctx);
typedef void (fz_colorspace_convert_fn)(fz_context *ctx, const fz_colorspace *cs, const float *src, float *dst);
typedef void (fz_colorspace_destruct_fn)(fz_context *ctx, fz_colorspace *cs);
typedef fz_colorspace *(fz_colorspace_base_fn)(const fz_colorspace *cs);
typedef void (fz_colorspace_clamp_fn)(const fz_colorspace *cs, const float *src, float *dst);
fz_colorspace *fz_new_colorspace(fz_context *ctx, const char *name, enum fz_colorspace_type type, int flags, int n, fz_colorspace_convert_fn *to_ccs, fz_colorspace_convert_fn *from_ccs, fz_colorspace_base_fn *base, fz_colorspace_clamp_fn *clamp, fz_colorspace_destruct_fn *destruct, void *data, size_t size);
void fz_colorspace_name_colorant(fz_context *ctx, fz_colorspace *cs, int n, const char *name);
const char *fz_colorspace_colorant(fz_context *ctx, const fz_colorspace *cs, int n);
fz_colorspace *fz_new_indexed_colorspace(fz_context *ctx, fz_colorspace *base, int high, unsigned char *lookup);
fz_colorspace *fz_keep_colorspace(fz_context *ctx, fz_colorspace *colorspace);
fz_colorspace *fz_keep_colorspace_store_key(fz_context *ctx, fz_colorspace *colorspace);
void fz_drop_colorspace_store_key(fz_context *ctx, fz_colorspace *colorspace);
void fz_drop_colorspace(fz_context *ctx, fz_colorspace *colorspace);
void fz_drop_colorspace_imp(fz_context *ctx, fz_storable *colorspace);
fz_colorspace *fz_colorspace_base(fz_context *ctx, const fz_colorspace *cs);
void fz_set_icc_bgr(fz_context *ctx, fz_colorspace *cs);
int fz_colorspace_n(fz_context *ctx, const fz_colorspace *cs);
int fz_colorspace_devicen_n(fz_context *ctx, const fz_colorspace *cs);
const char *fz_colorspace_name(fz_context *ctx, const fz_colorspace *cs);
void fz_clamp_color(fz_context *ctx, const fz_colorspace *cs, const float *in, float *out);
void fz_convert_color(fz_context *ctx, const fz_color_params *params, const fz_colorspace *intcs, const fz_colorspace *dscs, float *dstv, const fz_colorspace *srcs, const float *srcv);
typedef struct fz_color_converter_s fz_color_converter;
/* This structure is public because it allows us to avoid dynamic allocations.
* Callers should only rely on the convert entry - the rest of the structure
* is subject to change without notice.
*/
struct fz_color_converter_s
{
void (*convert)(fz_context *, fz_color_converter *, float *, const float *);
const fz_colorspace *ds;
const fz_colorspace *ss;
const fz_colorspace *is;
void *opaque;
void *link;
int n;
};
void fz_find_color_converter(fz_context *ctx, fz_color_converter *cc, const fz_colorspace *is, const fz_colorspace *ds, const fz_colorspace *ss, const fz_color_params *params);
void fz_drop_color_converter(fz_context *ctx, fz_color_converter *cc);
void fz_init_cached_color_converter(fz_context *ctx, fz_color_converter *cc, fz_colorspace *is, fz_colorspace *ds, fz_colorspace *ss, const fz_color_params *params);
void fz_fin_cached_color_converter(fz_context *ctx, fz_color_converter *cc);
/* Public to allow use in icc creation */
typedef struct fz_cal_colorspace_s fz_cal_colorspace;
struct fz_cal_colorspace_s {
float wp[3];
float bp[3];
float gamma[3];
float matrix[9];
int n;
fz_iccprofile *profile;
};
/*
icc methods
*/
fz_colorspace *fz_new_icc_colorspace(fz_context *ctx, const char *name, int num, fz_buffer *buf);
fz_colorspace *fz_new_icc_colorspace_from_file(fz_context *ctx, const char *name, const char *path);
fz_colorspace *fz_new_icc_colorspace_from_stream(fz_context *ctx, const char *name, fz_stream *in);
fz_colorspace *fz_new_cal_colorspace(fz_context *ctx, const char *name, float *wp, float *bp, float *gamma, float *matrix);
fz_buffer *fz_new_icc_data_from_cal_colorspace(fz_context *ctx, fz_cal_colorspace *cal);
fz_buffer *fz_icc_data_from_icc_colorspace(fz_context *ctx, const fz_colorspace *cs);
/* Default cs */
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);
/* Do we want to make fz_default_colorspaces public and get rid of these? */
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);
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);
#endif

66
include/mupdf/fitz/compress.h
View File

@@ -1,7 +1,31 @@
// Copyright (C) 2004-2021 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_COMPRESS_H
#define MUPDF_FITZ_COMPRESS_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/pixmap.h"
typedef enum
{
@@ -11,22 +35,22 @@ typedef enum
FZ_DEFLATE_DEFAULT = -1
} fz_deflate_level;
/*
fz_deflate_bound: Returns the upper bound on the
/**
Returns the upper bound on the
size of flated data of length size.
*/
size_t fz_deflate_bound(fz_context *ctx, size_t size);
/*
fz_deflate: Compress source_length bytes of data starting
/**
Compress source_length bytes of data starting
at source, into a buffer of length *destLen, starting at dest.
*compressed_length will be updated on exit to contain the size
actually used.
*/
void fz_deflate(fz_context *ctx, unsigned char *dest, size_t *compressed_length, const unsigned char *source, size_t source_length, fz_deflate_level level);
/*
fz_new_deflated_data: Compress source_length bytes of data starting
/**
Compress source_length bytes of data starting
at source, into a new memory block malloced for that purpose.
*compressed_length is updated on exit to contain the size used.
Ownership of the block is returned from this function, and the
@@ -36,15 +60,29 @@ void fz_deflate(fz_context *ctx, unsigned char *dest, size_t *compressed_length,
*/
unsigned char *fz_new_deflated_data(fz_context *ctx, size_t *compressed_length, const unsigned char *source, size_t source_length, fz_deflate_level level);
/*
fz_new_deflated_data_from_buffer: Compress the contents of a fz_buffer into a
new block malloced for that purpose. *compressed_length is updated
on exit to contain the size used. Ownership of the block is
returned from this function, and the caller is therefore responsible
for freeing it. The block may be considerably larger than is
actually required. The caller is free to fz_realloc it down if it
wants to.
/**
Compress the contents of a fz_buffer into a
new block malloced for that purpose. *compressed_length is
updated on exit to contain the size used. Ownership of the block
is returned from this function, and the caller is therefore
responsible for freeing it. The block may be considerably larger
than is actually required. The caller is free to fz_realloc it
down if it wants to.
*/
unsigned char *fz_new_deflated_data_from_buffer(fz_context *ctx, size_t *compressed_length, fz_buffer *buffer, fz_deflate_level level);
/**
Compress bitmap data as CCITT Group 3 1D fax image.
Creates a stream assuming the default PDF parameters,
except the number of columns.
*/
fz_buffer *fz_compress_ccitt_fax_g3(fz_context *ctx, const unsigned char *data, int columns, int rows, ptrdiff_t stride);
/**
Compress bitmap data as CCITT Group 4 2D fax image.
Creates a stream assuming the default PDF parameters, except
K=-1 and the number of columns.
*/
fz_buffer *fz_compress_ccitt_fax_g4(fz_context *ctx, const unsigned char *data, int columns, int rows, ptrdiff_t stride);
#endif

170
include/mupdf/fitz/compressed-buffer.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2023 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_COMPRESSED_BUFFER_H
#define MUPDF_FITZ_COMPRESSED_BUFFER_H
@@ -5,52 +27,27 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/stream.h"
#include "mupdf/fitz/filter.h"
typedef struct fz_compression_params_s fz_compression_params;
typedef struct fz_compressed_buffer_s fz_compressed_buffer;
size_t fz_compressed_buffer_size(fz_compressed_buffer *buffer);
fz_stream *fz_open_compressed_buffer(fz_context *ctx, fz_compressed_buffer *);
fz_stream *fz_open_image_decomp_stream_from_buffer(fz_context *ctx, fz_compressed_buffer *, int *l2factor);
fz_stream *fz_open_image_decomp_stream(fz_context *ctx, fz_stream *, fz_compression_params *, int *l2factor);
int fz_recognize_image_format(fz_context *ctx, unsigned char p[8]);
enum
{
FZ_IMAGE_UNKNOWN = 0,
/* Uncompressed samples */
FZ_IMAGE_RAW,
/* Compressed samples */
FZ_IMAGE_FAX,
FZ_IMAGE_FLATE,
FZ_IMAGE_LZW,
FZ_IMAGE_RLD,
/* Full image formats */
FZ_IMAGE_BMP,
FZ_IMAGE_GIF,
FZ_IMAGE_JPEG,
FZ_IMAGE_JPX,
FZ_IMAGE_JXR,
FZ_IMAGE_PNG,
FZ_IMAGE_PNM,
FZ_IMAGE_TIFF,
};
struct fz_compression_params_s
/**
Compression parameters used for buffers of compressed data;
typically for the source data for images.
*/
typedef struct
{
int type;
union {
struct {
int color_transform; /* Use -1 for unset */
int invert_cmyk; /* Use 1 for standalone JPEG files */
} jpeg;
struct {
int smask_in_data;
} jpx;
struct {
fz_jbig2_globals *globals;
int embedded;
} jbig2;
struct {
int columns;
int rows;
@@ -78,14 +75,111 @@ struct fz_compression_params_s
int early_change;
} lzw;
} u;
};
} fz_compression_params;
struct fz_compressed_buffer_s
/**
Buffers of compressed data; typically for the source data
for images.
*/
typedef struct
{
int refs;
fz_compression_params params;
fz_buffer *buffer;
} fz_compressed_buffer;
/**
Take a reference to an fz_compressed_buffer.
*/
fz_compressed_buffer *fz_keep_compressed_buffer(fz_context *ctx, fz_compressed_buffer *cbuf);
/**
Return the storage size used for a buffer and its data.
Used in implementing store handling.
Never throws exceptions.
*/
size_t fz_compressed_buffer_size(fz_compressed_buffer *buffer);
/**
Open a stream to read the decompressed version of a buffer.
*/
fz_stream *fz_open_compressed_buffer(fz_context *ctx, fz_compressed_buffer *);
/**
Open a stream to read the decompressed version of a buffer,
with optional log2 subsampling.
l2factor = NULL for no subsampling, or a pointer to an integer
containing the maximum log2 subsample factor acceptable (0 =
none, 1 = halve dimensions, 2 = quarter dimensions etc). If
non-NULL, then *l2factor will be updated on exit with the actual
log2 subsample factor achieved.
*/
fz_stream *fz_open_image_decomp_stream_from_buffer(fz_context *ctx, fz_compressed_buffer *, int *l2factor);
/**
Open a stream to read the decompressed version of another stream
with optional log2 subsampling.
*/
fz_stream *fz_open_image_decomp_stream(fz_context *ctx, fz_stream *, fz_compression_params *, int *l2factor);
/**
Recognise image format strings in the first 8 bytes from image
data.
*/
int fz_recognize_image_format(fz_context *ctx, unsigned char p[8]);
/**
Map from FZ_IMAGE_* value to string.
The returned string is static and therefore must not be freed.
*/
const char *fz_image_type_name(int type);
/**
Map from (case sensitive) image type string to FZ_IMAGE_*
type value.
*/
int fz_lookup_image_type(const char *type);
enum
{
FZ_IMAGE_UNKNOWN = 0,
/* Uncompressed samples */
FZ_IMAGE_RAW,
/* Compressed samples */
FZ_IMAGE_FAX,
FZ_IMAGE_FLATE,
FZ_IMAGE_LZW,
FZ_IMAGE_RLD,
/* Full image formats */
FZ_IMAGE_BMP,
FZ_IMAGE_GIF,
FZ_IMAGE_JBIG2,
FZ_IMAGE_JPEG,
FZ_IMAGE_JPX,
FZ_IMAGE_JXR,
FZ_IMAGE_PNG,
FZ_IMAGE_PNM,
FZ_IMAGE_TIFF,
FZ_IMAGE_PSD,
};
/**
Drop a reference to a compressed buffer. Destroys the buffer
and frees any storage/other references held by it.
Never throws exceptions.
*/
void fz_drop_compressed_buffer(fz_context *ctx, fz_compressed_buffer *buf);
/**
Create a new, UNKNOWN format, compressed_buffer.
*/
fz_compressed_buffer *fz_new_compressed_buffer(fz_context *ctx);
#endif

105
include/mupdf/fitz/config.h
View File

@@ -1,14 +1,36 @@
// Copyright (C) 2004-2021 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 FZ_CONFIG_H
#define FZ_CONFIG_H
/*
/**
Enable the following for spot (and hence overprint/overprint
simulation) capable rendering. This forces FZ_PLOTTERS_N on.
*/
#define FZ_ENABLE_SPOT_RENDERING
/* #define FZ_ENABLE_SPOT_RENDERING 1 */
/*
/**
Choose which plotters we need.
By default we build all the plotters in. To avoid building
plotters in that aren't needed, define the unwanted
@@ -19,9 +41,9 @@
/* #define FZ_PLOTTERS_CMYK 1 */
/* #define FZ_PLOTTERS_N 1 */
/*
/**
Choose which document agents to include.
By default all but GPRF are enabled. To avoid building unwanted
By default all are enabled. To avoid building unwanted
ones, define FZ_ENABLE_... to 0.
*/
/* #define FZ_ENABLE_PDF 1 */
@@ -29,12 +51,24 @@
/* #define FZ_ENABLE_SVG 1 */
/* #define FZ_ENABLE_CBZ 1 */
/* #define FZ_ENABLE_IMG 1 */
/* #define FZ_ENABLE_TIFF 1 */
/* #define FZ_ENABLE_HTML 1 */
/* #define FZ_ENABLE_EPUB 1 */
/* #define FZ_ENABLE_GPRF 1 */
/*
/**
Choose which document writers to include.
By default all are enabled. To avoid building unwanted
ones, define FZ_ENABLE_..._OUTPUT to 0.
*/
/* #define FZ_ENABLE_OCR_OUTPUT 1 */
/* #define FZ_ENABLE_DOCX_OUTPUT 1 */
/* #define FZ_ENABLE_ODT_OUTPUT 1 */
/**
Choose whether to enable ICC color profiles.
*/
/* #define FZ_ENABLE_ICC 1 */
/**
Choose whether to enable JPEG2000 decoding.
By default, it is enabled, but due to frequent security
issues with the third party libraries we support disabling
@@ -42,13 +76,14 @@
*/
/* #define FZ_ENABLE_JPX 1 */
/*
/**
Choose whether to enable JavaScript.
By default JavaScript is enabled both for mutool and PDF interactivity.
By default JavaScript is enabled both for mutool and PDF
interactivity.
*/
/* #define FZ_ENABLE_JS 1 */
/*
/**
Choose which fonts to include.
By default we include the base 14 PDF fonts,
DroidSansFallback from Android for CJK, and
@@ -57,12 +92,14 @@
unwanted fonts.
*/
/* To avoid all noto fonts except CJK, enable: */
/* #define TOFU */
#define TOFU
/* To skip the CJK font, enable: (this implicitly enables TOFU_CJK_EXT and TOFU_CJK_LANG) */
/* #define TOFU_CJK */
/* To skip the CJK font, enable: (this implicitly enables TOFU_CJK_EXT
* and TOFU_CJK_LANG) */
#define TOFU_CJK
/* To skip CJK Extension A, enable: (this implicitly enables TOFU_CJK_LANG) */
/* To skip CJK Extension A, enable: (this implicitly enables
* TOFU_CJK_LANG) */
/* #define TOFU_CJK_EXT */
/* To skip CJK language specific fonts, enable: */
@@ -80,16 +117,18 @@
/* To skip the SIL fonts, enable: */
/* #define TOFU_SIL */
/* To skip the ICC profiles, enable: */
/* #define NO_ICC */
/* To skip the Base14 fonts, enable: */
/* #define TOFU_BASE14 */
/* (You probably really don't want to do that except for measurement purposes!) */
/* (You probably really don't want to do that except for measurement
* purposes!) */
/* ---------- DO NOT EDIT ANYTHING UNDER THIS LINE ---------- */
#ifndef FZ_ENABLE_SPOT_RENDERING
#define FZ_ENABLE_SPOT_RENDERING 1
#endif
#if FZ_ENABLE_SPOT_RENDERING
#undef FZ_PLOTTERS_N
#define FZ_PLOTTERS_N 1
#endif /* FZ_ENABLE_SPOT_RENDERING */
@@ -136,10 +175,6 @@
#define FZ_ENABLE_IMG 1
#endif /* FZ_ENABLE_IMG */
#ifndef FZ_ENABLE_TIFF
#define FZ_ENABLE_TIFF 1
#endif /* FZ_ENABLE_TIFF */
#ifndef FZ_ENABLE_HTML
#define FZ_ENABLE_HTML 1
#endif /* FZ_ENABLE_HTML */
@@ -148,9 +183,17 @@
#define FZ_ENABLE_EPUB 1
#endif /* FZ_ENABLE_EPUB */
#ifndef FZ_ENABLE_GPRF
#define FZ_ENABLE_GPRF 0
#endif /* FZ_ENABLE_GPRF */
#ifndef FZ_ENABLE_OCR_OUTPUT
#define FZ_ENABLE_OCR_OUTPUT 1
#endif /* FZ_ENABLE_OCR_OUTPUT */
#ifndef FZ_ENABLE_ODT_OUTPUT
#define FZ_ENABLE_ODT_OUTPUT 1
#endif /* FZ_ENABLE_ODT_OUTPUT */
#ifndef FZ_ENABLE_DOCX_OUTPUT
#define FZ_ENABLE_DOCX_OUTPUT 1
#endif /* FZ_ENABLE_DOCX_OUTPUT */
#ifndef FZ_ENABLE_JPX
#define FZ_ENABLE_JPX 1
@@ -160,10 +203,20 @@
#define FZ_ENABLE_JS 1
#endif /* FZ_ENABLE_JS */
#ifndef FZ_ENABLE_ICC
#define FZ_ENABLE_ICC 1
#endif /* FZ_ENABLE_ICC */
/* If Epub and HTML are both disabled, disable SIL fonts */
#if FZ_ENABLE_HTML == 0 && FZ_ENABLE_EPUB == 0
#undef TOFU_SIL
#define TOFU_SIL
#endif
#if !defined(HAVE_LEPTONICA) || !defined(HAVE_TESSERACT)
#ifndef OCR_DISABLED
#define OCR_DISABLED
#endif
#endif
#endif /* FZ_CONFIG_H */

1038
include/mupdf/fitz/context.h
View File

File diff suppressed because it is too large Load Diff

230
include/mupdf/fitz/crypt.h
View File

@@ -1,42 +1,83 @@
// Copyright (C) 2004-2021 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_CRYPT_H
#define MUPDF_FITZ_CRYPT_H
#include "mupdf/fitz/system.h"
/*
* Basic crypto functions.
* Independent of the rest of fitz.
* For further encapsulation in filters, or not.
*/
/* md5 digests */
typedef struct fz_md5_s fz_md5;
/*
/**
Structure definition is public to enable stack
based allocation. Do not access the members directly.
*/
struct fz_md5_s
typedef struct
{
unsigned int state[4];
unsigned int count[2];
uint32_t lo, hi;
uint32_t a, b, c, d;
unsigned char buffer[64];
};
} fz_md5;
/**
MD5 initialization. Begins an MD5 operation, writing a new
context.
Never throws an exception.
*/
void fz_md5_init(fz_md5 *state);
/**
MD5 block update operation. Continues an MD5 message-digest
operation, processing another message block, and updating the
context.
Never throws an exception.
*/
void fz_md5_update(fz_md5 *state, const unsigned char *input, size_t inlen);
/**
MD5 block update operation. Continues an MD5 message-digest
operation, processing an int64, and updating the context.
Never throws an exception.
*/
void fz_md5_update_int64(fz_md5 *state, int64_t i);
/**
MD5 finalization. Ends an MD5 message-digest operation, writing
the message digest and zeroizing the context.
Never throws an exception.
*/
void fz_md5_final(fz_md5 *state, unsigned char digest[16]);
/* sha-256 digests */
typedef struct fz_sha256_s fz_sha256;
/*
/**
Structure definition is public to enable stack
based allocation. Do not access the members directly.
*/
struct fz_sha256_s
typedef struct
{
unsigned int state[8];
unsigned int count[2];
@@ -44,21 +85,40 @@ struct fz_sha256_s
unsigned char u8[64];
unsigned int u32[16];
} buffer;
};
} fz_sha256;
/**
SHA256 initialization. Begins an SHA256 operation, initialising
the supplied context.
Never throws an exception.
*/
void fz_sha256_init(fz_sha256 *state);
/**
SHA256 block update operation. Continues an SHA256 message-
digest operation, processing another message block, and updating
the context.
Never throws an exception.
*/
void fz_sha256_update(fz_sha256 *state, const unsigned char *input, size_t inlen);
/**
MD5 finalization. Ends an MD5 message-digest operation, writing
the message digest and zeroizing the context.
Never throws an exception.
*/
void fz_sha256_final(fz_sha256 *state, unsigned char digest[32]);
/* sha-512 digests */
typedef struct fz_sha512_s fz_sha512;
/*
/**
Structure definition is public to enable stack
based allocation. Do not access the members directly.
*/
struct fz_sha512_s
typedef struct
{
uint64_t state[8];
unsigned int count[2];
@@ -66,59 +126,143 @@ struct fz_sha512_s
unsigned char u8[128];
uint64_t u64[16];
} buffer;
};
} fz_sha512;
/**
SHA512 initialization. Begins an SHA512 operation, initialising
the supplied context.
Never throws an exception.
*/
void fz_sha512_init(fz_sha512 *state);
/**
SHA512 block update operation. Continues an SHA512 message-
digest operation, processing another message block, and updating
the context.
Never throws an exception.
*/
void fz_sha512_update(fz_sha512 *state, const unsigned char *input, size_t inlen);
/**
SHA512 finalization. Ends an SHA512 message-digest operation,
writing the message digest and zeroizing the context.
Never throws an exception.
*/
void fz_sha512_final(fz_sha512 *state, unsigned char digest[64]);
/* sha-384 digests */
typedef struct fz_sha512_s fz_sha384;
typedef fz_sha512 fz_sha384;
/**
SHA384 initialization. Begins an SHA384 operation, initialising
the supplied context.
Never throws an exception.
*/
void fz_sha384_init(fz_sha384 *state);
/**
SHA384 block update operation. Continues an SHA384 message-
digest operation, processing another message block, and updating
the context.
Never throws an exception.
*/
void fz_sha384_update(fz_sha384 *state, const unsigned char *input, size_t inlen);
/**
SHA384 finalization. Ends an SHA384 message-digest operation,
writing the message digest and zeroizing the context.
Never throws an exception.
*/
void fz_sha384_final(fz_sha384 *state, unsigned char digest[64]);
/* arc4 crypto */
typedef struct fz_arc4_s fz_arc4;
/*
/**
Structure definition is public to enable stack
based allocation. Do not access the members directly.
*/
struct fz_arc4_s
typedef struct
{
unsigned x;
unsigned y;
unsigned char state[256];
};
} fz_arc4;
/**
RC4 initialization. Begins an RC4 operation, writing a new
context.
Never throws an exception.
*/
void fz_arc4_init(fz_arc4 *state, const unsigned char *key, size_t len);
/**
RC4 block encrypt operation; encrypt src into dst (both of
length len) updating the RC4 state as we go.
Never throws an exception.
*/
void fz_arc4_encrypt(fz_arc4 *state, unsigned char *dest, const unsigned char *src, size_t len);
/**
RC4 finalization. Zero the context.
Never throws an exception.
*/
void fz_arc4_final(fz_arc4 *state);
/* AES block cipher implementation from XYSSL */
typedef struct fz_aes_s fz_aes;
/**
Structure definitions are public to enable stack
based allocation. Do not access the members directly.
*/
typedef struct
{
int nr; /* number of rounds */
uint32_t *rk; /* AES round keys */
uint32_t buf[68]; /* unaligned data */
} fz_aes;
#define FZ_AES_DECRYPT 0
#define FZ_AES_ENCRYPT 1
/*
Structure definition is public to enable stack
based allocation. Do not access the members directly.
*/
struct fz_aes_s
{
int nr; /* number of rounds */
unsigned long *rk; /* AES round keys */
unsigned long buf[68]; /* unaligned data */
};
/**
AES encryption intialisation. Fills in the supplied context
and prepares for encryption using the given key.
int fz_aes_setkey_enc( fz_aes *ctx, const unsigned char *key, int keysize );
int fz_aes_setkey_dec( fz_aes *ctx, const unsigned char *key, int keysize );
void fz_aes_crypt_cbc( fz_aes *ctx, int mode, size_t length,
Returns non-zero for error (key size other than 128/192/256).
Never throws an exception.
*/
int fz_aes_setkey_enc(fz_aes *ctx, const unsigned char *key, int keysize);
/**
AES decryption intialisation. Fills in the supplied context
and prepares for decryption using the given key.
Returns non-zero for error (key size other than 128/192/256).
Never throws an exception.
*/
int fz_aes_setkey_dec(fz_aes *ctx, const unsigned char *key, int keysize);
/**
AES block processing. Encrypts or Decrypts (according to mode,
which must match what was initially set up) length bytes (which
must be a multiple of 16), using (and modifying) the insertion
vector iv, reading from input, and writing to output.
Never throws an exception.
*/
void fz_aes_crypt_cbc(fz_aes *ctx, int mode, size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output );

479
include/mupdf/fitz/device.h
View File

@@ -1,19 +1,40 @@
// Copyright (C) 2004-2023 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_DEVICE_H
#define MUPDF_FITZ_DEVICE_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/colorspace.h"
#include "mupdf/fitz/image.h"
#include "mupdf/fitz/shade.h"
#include "mupdf/fitz/path.h"
#include "mupdf/fitz/text.h"
/*
The different format handlers (pdf, xps etc) interpret pages to a
device. These devices can then process the stream of calls they
receive in various ways:
/**
The different format handlers (pdf, xps etc) interpret pages to
a device. These devices can then process the stream of calls
they receive in various ways:
The trace device outputs debugging information for the calls.
The draw device will render them.
The list device stores them in a list to play back later.
@@ -21,7 +42,7 @@
The bbox device calculates the bounding box for the page.
Other devices can (and will) be written in the future.
*/
typedef struct fz_device_s fz_device;
typedef struct fz_device fz_device;
enum
{
@@ -37,9 +58,10 @@ enum
FZ_DEVFLAG_LINEJOIN_UNDEFINED = 256,
FZ_DEVFLAG_MITERLIMIT_UNDEFINED = 512,
FZ_DEVFLAG_LINEWIDTH_UNDEFINED = 1024,
/* Arguably we should have a bit for the dash pattern itself being
* undefined, but that causes problems; do we assume that it should
* always be set to non-dashing at the start of every glyph? */
/* Arguably we should have a bit for the dash pattern itself
* being undefined, but that causes problems; do we assume that
* it should always be set to non-dashing at the start of every
* glyph? */
FZ_DEVFLAG_BBOX_DEFINED = 2048,
FZ_DEVFLAG_GRIDFIT_AS_TILED = 4096,
};
@@ -72,12 +94,201 @@ enum
FZ_BLEND_KNOCKOUT = 32
};
/**
Map from (case sensitive) blend mode string to enumeration.
*/
int fz_lookup_blendmode(const char *name);
char *fz_blendmode_name(int blendmode);
typedef struct fz_device_container_stack_s fz_device_container_stack;
/**
Map from enumeration to blend mode string.
struct fz_device_s
The string is static, with arbitrary lifespan.
*/
const char *fz_blendmode_name(int blendmode);
/*
Generic function type.
Different function implementations will derive from this.
*/
typedef struct fz_function fz_function;
typedef void (fz_function_eval_fn)(fz_context *, fz_function *, const float *, float *);
enum
{
FZ_FUNCTION_MAX_N = FZ_MAX_COLORS,
FZ_FUNCTION_MAX_M = FZ_MAX_COLORS
};
struct fz_function
{
fz_storable storable;
size_t size;
int m; /* number of input values */
int n; /* number of output values */
fz_function_eval_fn *eval;
};
fz_function *fz_new_function_of_size(fz_context *ctx, int size, size_t size2, int m, int n, fz_function_eval_fn *eval, fz_store_drop_fn *drop);
#define fz_new_derived_function(CTX,TYPE,SIZE,M,N,EVAL,DROP) \
((TYPE*)Memento_label(fz_new_function_of_size(CTX,sizeof(TYPE),SIZE,M,N,EVAL,DROP), #TYPE))
/*
Evaluate a function.
Input vector = (in[0], ..., in[inlen-1])
Output vector = (out[0], ..., out[outlen-1])
If inlen or outlen do not match that expected by the function, this
routine will truncate or extend the input/output (with 0's) as
required.
*/
void fz_eval_function(fz_context *ctx, fz_function *func, const float *in, int inlen, float *out, int outlen);
/*
Keep a function reference.
*/
fz_function *fz_keep_function(fz_context *ctx, fz_function *func);
/*
Drop a function reference.
*/
void fz_drop_function(fz_context *ctx, fz_function *func);
/*
Function size
*/
size_t fz_function_size(fz_context *ctx, fz_function *func);
/**
The device structure is public to allow devices to be
implemented outside of fitz.
Device methods should always be called using e.g.
fz_fill_path(ctx, dev, ...) rather than
dev->fill_path(ctx, dev, ...)
*/
/**
Devices can keep track of containers (clips/masks/groups/tiles)
as they go to save callers having to do it.
*/
typedef struct
{
fz_rect scissor;
int type;
int user;
} fz_device_container_stack;
enum
{
fz_device_container_stack_is_clip,
fz_device_container_stack_is_mask,
fz_device_container_stack_is_group,
fz_device_container_stack_is_tile,
};
/* Structure types */
typedef enum
{
FZ_STRUCTURE_INVALID = -1,
/* Grouping elements (PDF 1.7 - Table 10.20) */
FZ_STRUCTURE_DOCUMENT,
FZ_STRUCTURE_PART,
FZ_STRUCTURE_ART,
FZ_STRUCTURE_SECT,
FZ_STRUCTURE_DIV,
FZ_STRUCTURE_BLOCKQUOTE,
FZ_STRUCTURE_CAPTION,
FZ_STRUCTURE_TOC,
FZ_STRUCTURE_TOCI,
FZ_STRUCTURE_INDEX,
FZ_STRUCTURE_NONSTRUCT,
FZ_STRUCTURE_PRIVATE,
/* Grouping elements (PDF 2.0 - Table 364) */
FZ_STRUCTURE_DOCUMENTFRAGMENT,
/* Grouping elements (PDF 2.0 - Table 365) */
FZ_STRUCTURE_ASIDE,
/* Grouping elements (PDF 2.0 - Table 366) */
FZ_STRUCTURE_TITLE,
FZ_STRUCTURE_FENOTE,
/* Grouping elements (PDF 2.0 - Table 367) */
FZ_STRUCTURE_SUB,
/* Paragraphlike elements (PDF 1.7 - Table 10.21) */
FZ_STRUCTURE_P,
FZ_STRUCTURE_H,
FZ_STRUCTURE_H1,
FZ_STRUCTURE_H2,
FZ_STRUCTURE_H3,
FZ_STRUCTURE_H4,
FZ_STRUCTURE_H5,
FZ_STRUCTURE_H6,
/* List elements (PDF 1.7 - Table 10.23) */
FZ_STRUCTURE_LIST,
FZ_STRUCTURE_LISTITEM,
FZ_STRUCTURE_LABEL,
FZ_STRUCTURE_LISTBODY,
/* Table elements (PDF 1.7 - Table 10.24) */
FZ_STRUCTURE_TABLE,
FZ_STRUCTURE_TR,
FZ_STRUCTURE_TH,
FZ_STRUCTURE_TD,
FZ_STRUCTURE_THEAD,
FZ_STRUCTURE_TBODY,
FZ_STRUCTURE_TFOOT,
/* Inline elements (PDF 1.7 - Table 10.25) */
FZ_STRUCTURE_SPAN,
FZ_STRUCTURE_QUOTE,
FZ_STRUCTURE_NOTE,
FZ_STRUCTURE_REFERENCE,
FZ_STRUCTURE_BIBENTRY,
FZ_STRUCTURE_CODE,
FZ_STRUCTURE_LINK,
FZ_STRUCTURE_ANNOT,
/* Inline elements (PDF 2.0 - Table 368) */
FZ_STRUCTURE_EM,
FZ_STRUCTURE_STRONG,
/* Ruby inline element (PDF 1.7 - Table 10.26) */
FZ_STRUCTURE_RUBY,
FZ_STRUCTURE_RB,
FZ_STRUCTURE_RT,
FZ_STRUCTURE_RP,
/* Warichu inline element (PDF 1.7 - Table 10.26) */
FZ_STRUCTURE_WARICHU,
FZ_STRUCTURE_WT,
FZ_STRUCTURE_WP,
/* Illustration elements (PDF 1.7 - Table 10.27) */
FZ_STRUCTURE_FIGURE,
FZ_STRUCTURE_FORMULA,
FZ_STRUCTURE_FORM,
/* Artifact structure type (PDF 2.0 - Table 375) */
FZ_STRUCTURE_ARTIFACT
} fz_structure;
const char *fz_structure_to_string(fz_structure type);
fz_structure fz_structure_from_string(const char *str);
typedef enum
{
FZ_METATEXT_ACTUALTEXT,
FZ_METATEXT_ALT,
FZ_METATEXT_ABBREVIATION,
FZ_METATEXT_TITLE
} fz_metatext;
struct fz_device
{
int refs;
int hints;
@@ -86,30 +297,30 @@ struct fz_device_s
void (*close_device)(fz_context *, fz_device *);
void (*drop_device)(fz_context *, fz_device *);
void (*fill_path)(fz_context *, fz_device *, const fz_path *, int even_odd, const fz_matrix *, fz_colorspace *, const float *color, float alpha, const fz_color_params *);
void (*stroke_path)(fz_context *, fz_device *, const fz_path *, const fz_stroke_state *, const fz_matrix *, fz_colorspace *, const float *color, float alpha, const fz_color_params *);
void (*clip_path)(fz_context *, fz_device *, const fz_path *, int even_odd, const fz_matrix *, const fz_rect *scissor);
void (*clip_stroke_path)(fz_context *, fz_device *, const fz_path *, const fz_stroke_state *, const fz_matrix *, const fz_rect *scissor);
void (*fill_path)(fz_context *, fz_device *, const fz_path *, int even_odd, fz_matrix, fz_colorspace *, const float *color, float alpha, fz_color_params );
void (*stroke_path)(fz_context *, fz_device *, const fz_path *, const fz_stroke_state *, fz_matrix, fz_colorspace *, const float *color, float alpha, fz_color_params );
void (*clip_path)(fz_context *, fz_device *, const fz_path *, int even_odd, fz_matrix, fz_rect scissor);
void (*clip_stroke_path)(fz_context *, fz_device *, const fz_path *, const fz_stroke_state *, fz_matrix, fz_rect scissor);
void (*fill_text)(fz_context *, fz_device *, const fz_text *, const fz_matrix *, fz_colorspace *, const float *color, float alpha, const fz_color_params *);
void (*stroke_text)(fz_context *, fz_device *, const fz_text *, const fz_stroke_state *, const fz_matrix *, fz_colorspace *, const float *color, float alpha, const fz_color_params *);
void (*clip_text)(fz_context *, fz_device *, const fz_text *, const fz_matrix *, const fz_rect *scissor);
void (*clip_stroke_text)(fz_context *, fz_device *, const fz_text *, const fz_stroke_state *, const fz_matrix *, const fz_rect *scissor);
void (*ignore_text)(fz_context *, fz_device *, const fz_text *, const fz_matrix *);
void (*fill_text)(fz_context *, fz_device *, const fz_text *, fz_matrix, fz_colorspace *, const float *color, float alpha, fz_color_params );
void (*stroke_text)(fz_context *, fz_device *, const fz_text *, const fz_stroke_state *, fz_matrix, fz_colorspace *, const float *color, float alpha, fz_color_params );
void (*clip_text)(fz_context *, fz_device *, const fz_text *, fz_matrix, fz_rect scissor);
void (*clip_stroke_text)(fz_context *, fz_device *, const fz_text *, const fz_stroke_state *, fz_matrix, fz_rect scissor);
void (*ignore_text)(fz_context *, fz_device *, const fz_text *, fz_matrix );
void (*fill_shade)(fz_context *, fz_device *, fz_shade *shd, const fz_matrix *ctm, float alpha, const fz_color_params *color_params);
void (*fill_image)(fz_context *, fz_device *, fz_image *img, const fz_matrix *ctm, float alpha, const fz_color_params *color_params);
void (*fill_image_mask)(fz_context *, fz_device *, fz_image *img, const fz_matrix *ctm, fz_colorspace *, const float *color, float alpha, const fz_color_params *color_params);
void (*clip_image_mask)(fz_context *, fz_device *, fz_image *img, const fz_matrix *ctm, const fz_rect *scissor);
void (*fill_shade)(fz_context *, fz_device *, fz_shade *shd, fz_matrix ctm, float alpha, fz_color_params color_params);
void (*fill_image)(fz_context *, fz_device *, fz_image *img, fz_matrix ctm, float alpha, fz_color_params color_params);
void (*fill_image_mask)(fz_context *, fz_device *, fz_image *img, fz_matrix ctm, fz_colorspace *, const float *color, float alpha, fz_color_params color_params);
void (*clip_image_mask)(fz_context *, fz_device *, fz_image *img, fz_matrix ctm, fz_rect scissor);
void (*pop_clip)(fz_context *, fz_device *);
void (*begin_mask)(fz_context *, fz_device *, const fz_rect *, int luminosity, fz_colorspace *, const float *bc, const fz_color_params *);
void (*end_mask)(fz_context *, fz_device *);
void (*begin_group)(fz_context *, fz_device *, const fz_rect *, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha);
void (*begin_mask)(fz_context *, fz_device *, fz_rect area, int luminosity, fz_colorspace *, const float *bc, fz_color_params );
void (*end_mask)(fz_context *, fz_device *, fz_function *fn);
void (*begin_group)(fz_context *, fz_device *, fz_rect area, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha);
void (*end_group)(fz_context *, fz_device *);
int (*begin_tile)(fz_context *, fz_device *, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id);
int (*begin_tile)(fz_context *, fz_device *, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id);
void (*end_tile)(fz_context *, fz_device *);
void (*render_flags)(fz_context *, fz_device *, int set, int clear);
@@ -118,95 +329,117 @@ struct fz_device_s
void (*begin_layer)(fz_context *, fz_device *, const char *layer_name);
void (*end_layer)(fz_context *, fz_device *);
fz_rect d1_rect;
void (*begin_structure)(fz_context *, fz_device *, fz_structure standard, const char *raw, int idx);
void (*end_structure)(fz_context *, fz_device *);
int error_depth;
char errmess[256];
void (*begin_metatext)(fz_context *, fz_device *, fz_metatext meta, const char *text);
void (*end_metatext)(fz_context *, fz_device *);
fz_rect d1_rect;
int container_len;
int container_cap;
fz_device_container_stack *container;
};
void fz_fill_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, const float *color, float alpha, const fz_color_params *color_params);
void fz_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, const float *color, float alpha, const fz_color_params *color_params);
void fz_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, const fz_matrix *ctm, const fz_rect *scissor);
void fz_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, const fz_rect *scissor);
void fz_fill_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, const float *color, float alpha, const fz_color_params *color_params);
void fz_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, const float *color, float alpha, const fz_color_params *color_params);
void fz_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_matrix *ctm, const fz_rect *scissor);
void fz_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, const fz_matrix *ctm, const fz_rect *scissor);
void fz_ignore_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_matrix *ctm);
/**
Device calls; graphics primitives and containers.
*/
void fz_fill_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params);
void fz_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params);
void fz_clip_path(fz_context *ctx, fz_device *dev, const fz_path *path, int even_odd, fz_matrix ctm, fz_rect scissor);
void fz_clip_stroke_path(fz_context *ctx, fz_device *dev, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor);
void fz_fill_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params);
void fz_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params);
void fz_clip_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm, fz_rect scissor);
void fz_clip_stroke_text(fz_context *ctx, fz_device *dev, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm, fz_rect scissor);
void fz_ignore_text(fz_context *ctx, fz_device *dev, const fz_text *text, fz_matrix ctm);
void fz_pop_clip(fz_context *ctx, fz_device *dev);
void fz_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha, const fz_color_params *color_params);
void fz_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha, const fz_color_params *color_params);
void fz_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, const float *color, float alpha, const fz_color_params *color_params);
void fz_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, const fz_rect *scissor);
void fz_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *area, int luminosity, fz_colorspace *colorspace, const float *bc, const fz_color_params *color_params);
void fz_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha, fz_color_params color_params);
void fz_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, float alpha, fz_color_params color_params);
void fz_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_colorspace *colorspace, const float *color, float alpha, fz_color_params color_params);
void fz_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, fz_matrix ctm, fz_rect scissor);
void fz_begin_mask(fz_context *ctx, fz_device *dev, fz_rect area, int luminosity, fz_colorspace *colorspace, const float *bc, fz_color_params color_params);
void fz_end_mask(fz_context *ctx, fz_device *dev);
void fz_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *area, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha);
void fz_end_mask_tr(fz_context *ctx, fz_device *dev, fz_function *fn);
void fz_begin_group(fz_context *ctx, fz_device *dev, fz_rect area, fz_colorspace *cs, int isolated, int knockout, int blendmode, float alpha);
void fz_end_group(fz_context *ctx, fz_device *dev);
void fz_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm);
int fz_begin_tile_id(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id);
void fz_begin_tile(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm);
int fz_begin_tile_id(fz_context *ctx, fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm, int id);
void fz_end_tile(fz_context *ctx, fz_device *dev);
void fz_render_flags(fz_context *ctx, fz_device *dev, int set, int clear);
void fz_set_default_colorspaces(fz_context *ctx, fz_device *dev, fz_default_colorspaces *default_cs);
void fz_begin_layer(fz_context *ctx, fz_device *dev, const char *layer_name);
void fz_end_layer(fz_context *ctx, fz_device *dev);
fz_device *fz_new_device_of_size(fz_context *ctx, int size);
void fz_begin_structure(fz_context *ctx, fz_device *dev, fz_structure standard, const char *raw, int idx);
void fz_end_structure(fz_context *ctx, fz_device *dev);
void fz_begin_metatext(fz_context *ctx, fz_device *dev, fz_metatext meta, const char *text);
void fz_end_metatext(fz_context *ctx, fz_device *dev);
/**
Devices are created by calls to device implementations, for
instance: foo_new_device(). These will be implemented by calling
fz_new_derived_device(ctx, foo_device) where foo_device is a
structure "derived from" fz_device, for instance
typedef struct { fz_device base; ...extras...} foo_device;
*/
fz_device *fz_new_device_of_size(fz_context *ctx, int size);
#define fz_new_derived_device(CTX, TYPE) \
((TYPE *)Memento_label(fz_new_device_of_size(ctx,sizeof(TYPE)),#TYPE))
/*
fz_close_device: Signal the end of input, and flush any buffered output.
This is NOT called implicitly on fz_drop_device.
/**
Signal the end of input, and flush any buffered output.
This is NOT called implicitly on fz_drop_device. This
may throw exceptions.
*/
void fz_close_device(fz_context *ctx, fz_device *dev);
/*
fz_drop_device: Free a device of any type and its resources.
/**
Reduce the reference count on a device. When the reference count
reaches zero, the device and its resources will be freed.
Don't forget to call fz_close_device before dropping the device,
or you may get incomplete output!
Never throws exceptions.
*/
void fz_drop_device(fz_context *ctx, fz_device *dev);
/**
Increment the reference count for a device. Returns the same
pointer.
Never throws exceptions.
*/
fz_device *fz_keep_device(fz_context *ctx, fz_device *dev);
/*
fz_enable_device_hints : Enable hints in a device.
hints: mask of hints to enable.
/**
Enable (set) hint bits within the hint bitfield for a device.
*/
void fz_enable_device_hints(fz_context *ctx, fz_device *dev, int hints);
/*
fz_disable_device_hints : Disable hints in a device.
hints: mask of hints to disable.
/**
Disable (clear) hint bits within the hint bitfield for a device.
*/
void fz_disable_device_hints(fz_context *ctx, fz_device *dev, int hints);
/*
/**
Find current scissor region as tracked by the device.
*/
const fz_rect *fz_device_current_scissor(fz_context *ctx, fz_device *dev);
fz_rect fz_device_current_scissor(fz_context *ctx, fz_device *dev);
enum
{
/* Hints */
FZ_DONT_INTERPOLATE_IMAGES = 1,
FZ_MAINTAIN_CONTAINER_STACK = 2,
FZ_NO_CACHE = 4,
FZ_NO_CACHE = 2,
FZ_DONT_DECODE_IMAGES = 4
};
/*
/**
Cookie support - simple communication channel between app/library.
*/
typedef struct fz_cookie_s fz_cookie;
/*
/**
Provide two-way communication between application and library.
Intended for multi-threaded applications where one thread is
rendering pages and another thread wants to read progress
@@ -242,33 +475,30 @@ typedef struct fz_cookie_s fz_cookie;
errors: count of errors during current rendering.
incomplete_ok: If this is set to 1 by the caller, then TRYLATER
errors are swallowed as they occur, setting the 'incomplete' flag.
Rendering continues as much as possible ignoring errors. The caller
is expected to check the 'incomplete' flag at the end to see if the
rendering may be considered final or not.
incomplete: Initially should be set to 0. Will be set to non-zero
if a TRYLATER error is thrown during rendering and the incomplete_ok
flag is set.
incomplete: Initially should be set to 0. Will be set to
non-zero if a TRYLATER error is thrown during rendering.
*/
struct fz_cookie_s
typedef struct
{
int abort;
int progress;
int progress_max; /* -1 for unknown */
size_t progress_max; /* (size_t)-1 for unknown */
int errors;
int incomplete_ok;
int incomplete;
};
} fz_cookie;
/*
fz_new_trace_device: Create a device to print a debug trace of all device calls.
/**
Create a device to print a debug trace of all device calls.
*/
fz_device *fz_new_trace_device(fz_context *ctx, fz_output *out);
/*
fz_new_bbox_device: Create a device to compute the bounding
/**
Create a device to output raw information.
*/
fz_device *fz_new_xmltext_device(fz_context *ctx, fz_output *out);
/**
Create a device to compute the bounding
box of all marks on a page.
The returned bounding box will be the union of all bounding
@@ -276,8 +506,8 @@ fz_device *fz_new_trace_device(fz_context *ctx, fz_output *out);
*/
fz_device *fz_new_bbox_device(fz_context *ctx, fz_rect *rectp);
/*
fz_new_test_device: Create a device to test for features.
/**
Create a device to test for features.
Currently only tests for the presence of non-grayscale colors.
@@ -315,8 +545,8 @@ enum
FZ_TEST_OPT_SHADINGS = 2
};
/*
fz_new_draw_device: Create a device to draw on a pixmap.
/**
Create a device to draw on a pixmap.
dest: Target pixmap for the draw device. See fz_new_pixmap*
for how to obtain a pixmap. The pixmap is not cleared by the
@@ -324,12 +554,13 @@ enum
calling fz_new_draw_device. Free the device by calling
fz_drop_device.
transform: Transform from user space in points to device space in pixels.
transform: Transform from user space in points to device space
in pixels.
*/
fz_device *fz_new_draw_device(fz_context *ctx, const fz_matrix *transform, fz_pixmap *dest);
fz_device *fz_new_draw_device(fz_context *ctx, fz_matrix transform, fz_pixmap *dest);
/*
fz_new_draw_device_with_bbox: Create a device to draw on a pixmap.
/**
Create a device to draw on a pixmap.
dest: Target pixmap for the draw device. See fz_new_pixmap*
for how to obtain a pixmap. The pixmap is not cleared by the
@@ -337,15 +568,16 @@ fz_device *fz_new_draw_device(fz_context *ctx, const fz_matrix *transform, fz_pi
calling fz_new_draw_device. Free the device by calling
fz_drop_device.
transform: Transform from user space in points to device space in pixels.
transform: Transform from user space in points to device space
in pixels.
clip: Bounding box to restrict any marking operations of the
draw device.
*/
fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, const fz_matrix *transform, fz_pixmap *dest, const fz_irect *clip);
fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, fz_matrix transform, fz_pixmap *dest, const fz_irect *clip);
/*
fz_new_draw_device_with_proof: Create a device to draw on a pixmap.
/**
Create a device to draw on a pixmap.
dest: Target pixmap for the draw device. See fz_new_pixmap*
for how to obtain a pixmap. The pixmap is not cleared by the
@@ -353,15 +585,16 @@ fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, const fz_matrix *transf
calling fz_new_draw_device. Free the device by calling
fz_drop_device.
transform: Transform from user space in points to device space in pixels.
transform: Transform from user space in points to device space
in pixels.
proof_cs: Intermediate color space to map though when mapping to
color space defined by pixmap.
*/
fz_device *fz_new_draw_device_with_proof(fz_context *ctx, const fz_matrix *transform, fz_pixmap *dest, fz_colorspace *proof_cs);
fz_device *fz_new_draw_device_with_proof(fz_context *ctx, fz_matrix transform, fz_pixmap *dest, fz_colorspace *proof_cs);
/*
fz_new_draw_device_with_bbox_proof: Create a device to draw on a pixmap.
/**
Create a device to draw on a pixmap.
dest: Target pixmap for the draw device. See fz_new_pixmap*
for how to obtain a pixmap. The pixmap is not cleared by the
@@ -369,23 +602,24 @@ fz_device *fz_new_draw_device_with_proof(fz_context *ctx, const fz_matrix *trans
calling fz_new_draw_device. Free the device by calling
fz_drop_device.
transform: Transform from user space in points to device space in pixels.
transform: Transform from user space in points to device space
in pixels.
clip: Bounding box to restrict any marking operations of the
draw device.
proof_cs: Color space to render to prior to mapping to color space defined by pixmap.
proof_cs: Color space to render to prior to mapping to color
space defined by pixmap.
*/
fz_device *fz_new_draw_device_with_bbox_proof(fz_context *ctx, const fz_matrix *transform, fz_pixmap *dest, const fz_irect *clip, fz_colorspace *cs);
fz_device *fz_new_draw_device_with_bbox_proof(fz_context *ctx, fz_matrix transform, fz_pixmap *dest, const fz_irect *clip, fz_colorspace *cs);
fz_device *fz_new_draw_device_type3(fz_context *ctx, const fz_matrix *transform, fz_pixmap *dest);
fz_device *fz_new_draw_device_type3(fz_context *ctx, fz_matrix transform, fz_pixmap *dest);
/*
struct fz_draw_options: Options for creating a pixmap and draw device.
/**
struct fz_draw_options: Options for creating a pixmap and draw
device.
*/
typedef struct fz_draw_options_s fz_draw_options;
struct fz_draw_options_s
typedef struct
{
int rotate;
int x_resolution;
@@ -396,22 +630,25 @@ struct fz_draw_options_s
int alpha;
int graphics;
int text;
};
} fz_draw_options;
extern const char *fz_draw_options_usage;
FZ_DATA extern const char *fz_draw_options_usage;
/*
fz_parse_draw_options: Parse draw device options from a comma separated key-value string.
/**
Parse draw device options from a comma separated key-value string.
*/
fz_draw_options *fz_parse_draw_options(fz_context *ctx, fz_draw_options *options, const char *string);
/*
fz_new_draw_device_with_options: Create a new pixmap and draw device, using the specified options.
/**
Create a new pixmap and draw device, using the specified options.
options: Options to configure the draw device, and choose the
resolution and colorspace.
options: Options to configure the draw device, and choose the resolution and colorspace.
mediabox: The bounds of the page in points.
pixmap: An out parameter containing the newly created pixmap.
*/
fz_device *fz_new_draw_device_with_options(fz_context *ctx, const fz_draw_options *options, const fz_rect *mediabox, fz_pixmap **pixmap);
fz_device *fz_new_draw_device_with_options(fz_context *ctx, const fz_draw_options *options, fz_rect mediabox, fz_pixmap **pixmap);
#endif

79
include/mupdf/fitz/display-list.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_DISPLAY_LIST_H
#define MUPDF_FITZ_DISPLAY_LIST_H
@@ -6,11 +28,11 @@
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/device.h"
/*
/**
Display list device -- record and play back device commands.
*/
/*
/**
fz_display_list is a list containing drawing commands (text,
images, etc.). The intent is two-fold: as a caching-mechanism
to reduce parsing of a page, and to be used as a data
@@ -22,20 +44,21 @@
list (once or many times) by calling fz_run_display_list. When
the list is no longer needed drop it with fz_drop_display_list.
*/
typedef struct fz_display_list_s fz_display_list;
typedef struct fz_display_list fz_display_list;
/*
fz_new_display_list: Create an empty display list.
/**
Create an empty display list.
A display list contains drawing commands (text, images, etc.).
Use fz_new_list_device for populating the list.
mediabox: Bounds of the page (in points) represented by the display list.
mediabox: Bounds of the page (in points) represented by the
display list.
*/
fz_display_list *fz_new_display_list(fz_context *ctx, const fz_rect *mediabox);
fz_display_list *fz_new_display_list(fz_context *ctx, fz_rect mediabox);
/*
fz_new_list_device: Create a rendering device for a display list.
/**
Create a rendering device for a display list.
When the device is rendering a page it will populate the
display list with drawing commands (text, images, etc.). The
@@ -44,24 +67,22 @@ fz_display_list *fz_new_display_list(fz_context *ctx, const fz_rect *mediabox);
for each rendering. Once the device is no longer needed, free
it with fz_drop_device.
list: A display list that the list device takes ownership of.
list: A display list that the list device takes a reference to.
*/
fz_device *fz_new_list_device(fz_context *ctx, fz_display_list *list);
/*
fz_run_display_list: (Re)-run a display list through a device.
/**
(Re)-run a display list through a device.
list: A display list, created by fz_new_display_list and
populated with objects from a page by running fz_run_page on a
device obtained from fz_new_list_device.
dev: Device obtained from fz_new_*_device.
ctm: Transform to apply to display list contents. May include
for example scaling and rotation, see fz_scale, fz_rotate and
fz_concat. Set to fz_identity if no transformation is desired.
area: Only the part of the contents of the display list
scissor: Only the part of the contents of the display list
visible within this area will be considered when the list is
run through the device. This does not imply for tile objects
contained in the display list.
@@ -73,25 +94,31 @@ fz_device *fz_new_list_device(fz_context *ctx, fz_display_list *list);
progress information back to the caller. The fields inside
cookie are continually updated while the page is being run.
*/
void fz_run_display_list(fz_context *ctx, fz_display_list *list, fz_device *dev, const fz_matrix *ctm, const fz_rect *area, fz_cookie *cookie);
void fz_run_display_list(fz_context *ctx, fz_display_list *list, fz_device *dev, fz_matrix ctm, fz_rect scissor, fz_cookie *cookie);
/*
fz_keep_display_list: Keep a reference to a display list.
/**
Increment the reference count for a display list. Returns the
same pointer.
Never throws exceptions.
*/
fz_display_list *fz_keep_display_list(fz_context *ctx, fz_display_list *list);
/*
fz_drop_display_list: Drop a reference to a display list, freeing it
if the reference count reaches zero.
/**
Decrement the reference count for a display list. When the
reference count reaches zero, all the references in the display
list itself are dropped, and the display list is freed.
Never throws exceptions.
*/
void fz_drop_display_list(fz_context *ctx, fz_display_list *list);
/*
fz_bound_display_list: Return the bounding box of the page recorded in a display list.
/**
Return the bounding box of the page recorded in a display list.
*/
fz_rect *fz_bound_display_list(fz_context *ctx, fz_display_list *list, fz_rect *bounds);
fz_rect fz_bound_display_list(fz_context *ctx, fz_display_list *list);
/*
/**
Create a new image from a display list.
w, h: The conceptual width/height of the image.
@@ -103,7 +130,7 @@ fz_rect *fz_bound_display_list(fz_context *ctx, fz_display_list *list, fz_rect *
*/
fz_image *fz_new_image_from_display_list(fz_context *ctx, float w, float h, fz_display_list *list);
/*
/**
Check for a display list being empty
list: The list to check.

1042
include/mupdf/fitz/document.h
View File

File diff suppressed because it is too large Load Diff

52
include/mupdf/fitz/export.h Normal file
View File

@@ -0,0 +1,52 @@
// Copyright (C) 2004-2021 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_EXPORT_H
#define MUPDF_FITZ_EXPORT_H
/*
* Support for building/using MuPDF DLL on Windows.
*
* When compiling code that uses MuPDF DLL, FZ_DLL_CLIENT should be defined.
*
* When compiling MuPDF DLL itself, FZ_DLL should be defined.
*/
#if defined(_WIN32) || defined(_WIN64)
#if defined(FZ_DLL)
/* Building DLL. */
#define FZ_FUNCTION __declspec(dllexport)
#define FZ_DATA __declspec(dllexport)
#elif defined(FZ_DLL_CLIENT)
/* Building DLL client code. */
#define FZ_FUNCTION __declspec(dllexport)
#define FZ_DATA __declspec(dllimport)
#else
#define FZ_FUNCTION
#define FZ_DATA
#endif
#else
#define FZ_FUNCTION
#define FZ_DATA
#endif
#endif

239
include/mupdf/fitz/filter.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2023 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_FILTER_H
#define MUPDF_FITZ_FILTER_H
@@ -7,40 +29,235 @@
#include "mupdf/fitz/store.h"
#include "mupdf/fitz/stream.h"
typedef struct fz_jbig2_globals_s fz_jbig2_globals;
typedef struct fz_jbig2_globals fz_jbig2_globals;
typedef struct
{
int64_t offset;
int len;
uint64_t length;
} fz_range;
fz_stream *fz_open_copy(fz_context *ctx, fz_stream *chain);
fz_stream *fz_open_null_n(fz_context *ctx, fz_stream *chain, fz_range *ranges, int nranges);
fz_stream *fz_open_null(fz_context *ctx, fz_stream *chain, int len, int64_t offset);
/**
The null filter reads a specified amount of data from the
substream.
*/
fz_stream *fz_open_null_filter(fz_context *ctx, fz_stream *chain, uint64_t len, int64_t offset);
/**
The range filter copies data from specified ranges of the
chained stream.
*/
fz_stream *fz_open_range_filter(fz_context *ctx, fz_stream *chain, fz_range *ranges, int nranges);
/**
The endstream filter reads a PDF substream, and starts to look
for an 'endstream' token after the specified length.
*/
fz_stream *fz_open_endstream_filter(fz_context *ctx, fz_stream *chain, uint64_t len, int64_t offset);
/**
Concat filter concatenates several streams into one.
*/
fz_stream *fz_open_concat(fz_context *ctx, int max, int pad);
void fz_concat_push_drop(fz_context *ctx, fz_stream *concat, fz_stream *chain); /* Ownership of chain is passed in */
/**
Add a chained stream to the end of the concatenate filter.
Ownership of chain is passed in.
*/
void fz_concat_push_drop(fz_context *ctx, fz_stream *concat, fz_stream *chain);
/**
arc4 filter performs RC4 decoding of data read from the chained
filter using the supplied key.
*/
fz_stream *fz_open_arc4(fz_context *ctx, fz_stream *chain, unsigned char *key, unsigned keylen);
/**
aesd filter performs AES decoding of data read from the chained
filter using the supplied key.
*/
fz_stream *fz_open_aesd(fz_context *ctx, fz_stream *chain, unsigned char *key, unsigned keylen);
/**
a85d filter performs ASCII 85 Decoding of data read
from the chained filter.
*/
fz_stream *fz_open_a85d(fz_context *ctx, fz_stream *chain);
/**
ahxd filter performs ASCII Hex decoding of data read
from the chained filter.
*/
fz_stream *fz_open_ahxd(fz_context *ctx, fz_stream *chain);
/**
rld filter performs Run Length Decoding of data read
from the chained filter.
*/
fz_stream *fz_open_rld(fz_context *ctx, fz_stream *chain);
fz_stream *fz_open_dctd(fz_context *ctx, fz_stream *chain, int color_transform, int l2factor, fz_stream *jpegtables);
/**
dctd filter performs DCT (JPEG) decoding of data read
from the chained filter.
color_transform implements the PDF color_transform option
use -1 for default behavior
use 0 to disable YUV-RGB / YCCK-CMYK transforms
use 1 to enable YUV-RGB / YCCK-CMYK transforms
invert_cmyk implements the necessary inversion for Photoshop CMYK images
use 0 if embedded in PDF
use 1 if not embedded in PDF
For subsampling on decode, set l2factor to the log2 of the
reduction required (therefore 0 = full size decode).
jpegtables is an optional stream from which the JPEG tables
can be read. Use NULL if not required.
*/
fz_stream *fz_open_dctd(fz_context *ctx, fz_stream *chain, int color_transform, int invert_cmyk, int l2factor, fz_stream *jpegtables);
/**
faxd filter performs FAX decoding of data read from
the chained filter.
k: see fax specification (fax default is 0).
end_of_line: whether we expect end of line markers (fax default
is 0).
encoded_byte_align: whether we align to bytes after each line
(fax default is 0).
columns: how many columns in the image (fax default is 1728).
rows: 0 for unspecified or the number of rows of data to expect.
end_of_block: whether we expect end of block markers (fax
default is 1).
black_is_1: determines the polarity of the image (fax default is
0).
*/
fz_stream *fz_open_faxd(fz_context *ctx, fz_stream *chain,
int k, int end_of_line, int encoded_byte_align,
int columns, int rows, int end_of_block, int black_is_1);
fz_stream *fz_open_flated(fz_context *ctx, fz_stream *chain, int window_bits);
fz_stream *fz_open_lzwd(fz_context *ctx, fz_stream *chain, int early_change, int min_bits, int reverse_bits, int old_tiff);
fz_stream *fz_open_predict(fz_context *ctx, fz_stream *chain, int predictor, int columns, int colors, int bpc);
fz_stream *fz_open_jbig2d(fz_context *ctx, fz_stream *chain, fz_jbig2_globals *globals);
/**
flated filter performs LZ77 decoding (inflating) of data read
from the chained filter.
window_bits: How large a decompression window to use. Typically
15. A negative number, -n, means to use n bits, but to expect
raw data with no header.
*/
fz_stream *fz_open_flated(fz_context *ctx, fz_stream *chain, int window_bits);
/**
libarchived filter performs generic compressed decoding of data
in any format understood by libarchive from the chained filter.
This will throw an exception if libarchive is not built in, or
if the compression format is not recognised.
*/
fz_stream *fz_open_libarchived(fz_context *ctx, fz_stream *chain);
/**
lzwd filter performs LZW decoding of data read from the chained
filter.
early_change: (Default 1) specifies whether to change codes 1
bit early.
min_bits: (Default 9) specifies the minimum number of bits to
use.
reverse_bits: (Default 0) allows for compatibility with gif and
old style tiffs (1).
old_tiff: (Default 0) allows for different handling of the clear
code, as found in old style tiffs.
*/
fz_stream *fz_open_lzwd(fz_context *ctx, fz_stream *chain, int early_change, int min_bits, int reverse_bits, int old_tiff);
/**
predict filter performs pixel prediction on data read from
the chained filter.
predictor: 1 = copy, 2 = tiff, other = inline PNG predictor
columns: width of image in pixels
colors: number of components.
bpc: bits per component (typically 8)
*/
fz_stream *fz_open_predict(fz_context *ctx, fz_stream *chain, int predictor, int columns, int colors, int bpc);
/**
Open a filter that performs jbig2 decompression on the chained
stream, using the optional globals record.
*/
fz_stream *fz_open_jbig2d(fz_context *ctx, fz_stream *chain, fz_jbig2_globals *globals, int embedded);
/**
Create a jbig2 globals record from a buffer.
Immutable once created.
*/
fz_jbig2_globals *fz_load_jbig2_globals(fz_context *ctx, fz_buffer *buf);
/**
Increment the reference count for a jbig2 globals record.
Never throws an exception.
*/
fz_jbig2_globals *fz_keep_jbig2_globals(fz_context *ctx, fz_jbig2_globals *globals);
/**
Decrement the reference count for a jbig2 globals record.
When the reference count hits zero, the record is freed.
Never throws an exception.
*/
void fz_drop_jbig2_globals(fz_context *ctx, fz_jbig2_globals *globals);
/**
Special jbig2 globals drop function for use in implementing
store support.
*/
void fz_drop_jbig2_globals_imp(fz_context *ctx, fz_storable *globals);
/**
Return buffer containing jbig2 globals data stream.
*/
fz_buffer * fz_jbig2_globals_data(fz_context *ctx, fz_jbig2_globals *globals);
/* Extra filters for tiff */
/**
SGI Log 16bit (greyscale) decode from the chained filter.
Decodes lines of w pixels to 8bpp greyscale.
*/
fz_stream *fz_open_sgilog16(fz_context *ctx, fz_stream *chain, int w);
/**
SGI Log 24bit (LUV) decode from the chained filter.
Decodes lines of w pixels to 8bpc rgb.
*/
fz_stream *fz_open_sgilog24(fz_context *ctx, fz_stream *chain, int w);
/**
SGI Log 32bit (LUV) decode from the chained filter.
Decodes lines of w pixels to 8bpc rgb.
*/
fz_stream *fz_open_sgilog32(fz_context *ctx, fz_stream *chain, int w);
/**
4bit greyscale Thunderscan decoding from the chained filter.
Decodes lines of w pixels to 8bpp greyscale.
*/
fz_stream *fz_open_thunder(fz_context *ctx, fz_stream *chain, int w);
#endif

588
include/mupdf/fitz/font.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_FONT_H
#define MUPDF_FITZ_FONT_H
@@ -5,23 +27,92 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/color.h"
/* forward declaration for circular dependency */
struct fz_device_s;
struct fz_device;
/*
/* Various font encoding tables and lookup functions */
FZ_DATA extern const char *fz_glyph_name_from_adobe_standard[256];
FZ_DATA extern const char *fz_glyph_name_from_iso8859_7[256];
FZ_DATA extern const char *fz_glyph_name_from_koi8u[256];
FZ_DATA extern const char *fz_glyph_name_from_mac_expert[256];
FZ_DATA extern const char *fz_glyph_name_from_mac_roman[256];
FZ_DATA extern const char *fz_glyph_name_from_win_ansi[256];
FZ_DATA extern const char *fz_glyph_name_from_windows_1252[256];
FZ_DATA extern const unsigned short fz_unicode_from_iso8859_1[256];
FZ_DATA extern const unsigned short fz_unicode_from_iso8859_7[256];
FZ_DATA extern const unsigned short fz_unicode_from_koi8u[256];
FZ_DATA extern const unsigned short fz_unicode_from_pdf_doc_encoding[256];
FZ_DATA extern const unsigned short fz_unicode_from_windows_1250[256];
FZ_DATA extern const unsigned short fz_unicode_from_windows_1251[256];
FZ_DATA extern const unsigned short fz_unicode_from_windows_1252[256];
int fz_iso8859_1_from_unicode(int u);
int fz_iso8859_7_from_unicode(int u);
int fz_koi8u_from_unicode(int u);
int fz_windows_1250_from_unicode(int u);
int fz_windows_1251_from_unicode(int u);
int fz_windows_1252_from_unicode(int u);
int fz_unicode_from_glyph_name(const char *name);
int fz_unicode_from_glyph_name_strict(const char *name);
const char **fz_duplicate_glyph_names_from_unicode(int unicode);
const char *fz_glyph_name_from_unicode_sc(int unicode);
/**
* A text decoder (to read arbitrary encodings and convert to unicode).
*/
typedef struct fz_text_decoder fz_text_decoder;
struct fz_text_decoder {
// get maximum size estimate of converted text (fast)
int (*decode_bound)(fz_text_decoder *dec, unsigned char *input, int n);
// get exact size of converted text (slow)
int (*decode_size)(fz_text_decoder *dec, unsigned char *input, int n);
// convert text into output buffer
void (*decode)(fz_text_decoder *dec, char *output, unsigned char *input, int n);
// for internal use only; do not touch!
void *table1;
void *table2;
};
/* Initialize a text decoder using an IANA encoding name.
* See source/fitz/text-decoder.c for the exact list of supported encodings.
* Will throw an exception if the requested encoding is not available.
*
* The following is a subset of the supported encodings (see source/fitz/text-decoder.c for the full list):
* iso-8859-1
* iso-8859-7
* koi8-r
* euc-jp
* shift_jis
* euc-kr
* euc-cn
* gb18030
* euc-tw
* big5
*/
void fz_init_text_decoder(fz_context *ctx, fz_text_decoder *dec, const char *encoding);
/**
An abstract font handle.
*/
typedef struct fz_font_s fz_font;
typedef struct fz_font fz_font;
/*
* Fonts come in two variants:
* Regular fonts are handled by FreeType.
* Type 3 fonts have callbacks to the interpreter.
*/
/**
Fonts come in two variants:
Regular fonts are handled by FreeType.
Type 3 fonts have callbacks to the interpreter.
*/
/*
fz_font_ft_face: Retrieve the FT_Face handle
/**
Retrieve the FT_Face handle
for the font.
font: The font to query
@@ -32,8 +123,8 @@ typedef struct fz_font_s fz_font;
*/
void *fz_font_ft_face(fz_context *ctx, fz_font *font);
/*
fz_font_t3_procs: Retrieve the Type3 procs
/**
Retrieve the Type3 procs
for a font.
font: The font to query
@@ -43,22 +134,11 @@ void *fz_font_ft_face(fz_context *ctx, fz_font *font);
*/
fz_buffer **fz_font_t3_procs(fz_context *ctx, fz_font *font);
/*
ft_error_string: map an FT error number to a
static string.
err: The error number to lookup.
Returns a pointer to a static textual representation
of a freetype error.
*/
const char *ft_error_string(int err);
/* common CJK font collections */
enum { FZ_ADOBE_CNS_1, FZ_ADOBE_GB_1, FZ_ADOBE_JAPAN_1, FZ_ADOBE_KOREA_1 };
enum { FZ_ADOBE_CNS, FZ_ADOBE_GB, FZ_ADOBE_JAPAN, FZ_ADOBE_KOREA };
/*
fz_font_flags_t: Every fz_font carries a set of flags
/**
Every fz_font carries a set of flags
within it, in a fz_font_flags_t structure.
*/
typedef struct
@@ -74,10 +154,16 @@ typedef struct
unsigned int fake_italic : 1; /* synthesize italic */
unsigned int has_opentype : 1; /* has opentype shaping tables */
unsigned int invalid_bbox : 1;
unsigned int cjk : 1;
unsigned int cjk_lang : 2; /* CNS, GB, JAPAN, or KOREA */
unsigned int embed : 1;
unsigned int never_embed : 1;
} fz_font_flags_t;
/*
fz_font_flags: Retrieve a pointer to the font flags
/**
Retrieve a pointer to the font flags
for a given font. These can then be updated as required.
font: The font to query
@@ -87,8 +173,8 @@ typedef struct
*/
fz_font_flags_t *fz_font_flags(fz_font *font);
/*
fz_shaper_data_t: In order to shape a given font, we need to
/**
In order to shape a given font, we need to
declare it to a shaper library (harfbuzz, by default, but others
are possible). To avoid redeclaring it every time we need to
shape, we hold a shaper handle and the destructor for it within
@@ -102,8 +188,8 @@ typedef struct
void (*destroy)(fz_context *ctx, void *); /* Destructor for shape_handle */
} fz_shaper_data_t;
/*
fz_shaper_data_t: Retrieve a pointer to the shaper data
/**
Retrieve a pointer to the shaper data
structure for the given font.
font: The font to query.
@@ -113,8 +199,8 @@ typedef struct
*/
fz_shaper_data_t *fz_font_shaper_data(fz_context *ctx, fz_font *font);
/*
fz_font_name: Retrieve a pointer to the name of the font.
/**
Retrieve a pointer to the name of the font.
font: The font to query.
@@ -123,74 +209,83 @@ fz_shaper_data_t *fz_font_shaper_data(fz_context *ctx, fz_font *font);
*/
const char *fz_font_name(fz_context *ctx, fz_font *font);
/*
fz_font_is_bold: Returns true if the font is bold.
/**
Query whether the font flags say that this font is bold.
*/
int fz_font_is_bold(fz_context *ctx, fz_font *font);
/*
fz_font_is_italic: Returns true if the font is italic.
/**
Query whether the font flags say that this font is italic.
*/
int fz_font_is_italic(fz_context *ctx, fz_font *font);
/*
fz_font_is_serif: Returns true if the font is serif.
/**
Query whether the font flags say that this font is serif.
*/
int fz_font_is_serif(fz_context *ctx, fz_font *font);
/*
fz_font_is_monospaced: Returns true if the font is monospaced.
/**
Query whether the font flags say that this font is monospaced.
*/
int fz_font_is_monospaced(fz_context *ctx, fz_font *font);
/*
fz_font_bbox: Retrieve a pointer to the font bbox.
/**
Retrieve the font bbox.
font: The font to query.
Returns a pointer to the font bbox (or NULL if the
font is NULL).
Returns the font bbox by value; it is valid only if
fz_font_flags(font)->invalid_bbox is zero.
*/
fz_rect *fz_font_bbox(fz_context *ctx, fz_font *font);
fz_rect fz_font_bbox(fz_context *ctx, fz_font *font);
/*
fz_load_system_font_fn: Type for user supplied system font loading hook.
/**
Type for user supplied system font loading hook.
name: The name of the font to load.
bold: 1 if a bold font desired, 0 otherwise.
italic: 1 if an italic font desired, 0 otherwise.
needs_exact_metrics: 1 if an exact metric match is required for the font requested.
needs_exact_metrics: 1 if an exact metric match is required for
the font requested.
Returns a new font handle, or NULL if no font found (or on error).
*/
typedef fz_font *(fz_load_system_font_fn)(fz_context *ctx, const char *name, int bold, int italic, int needs_exact_metrics);
/*
fz_load_system_cjk_font_fn: Type for user supplied cjk font loading hook.
/**
Type for user supplied cjk font loading hook.
name: The name of the font to load.
ros: The registry from which to load the font (e.g. FZ_ADOBE_KOREA_1)
ordering: The ordering for which to load the font (e.g.
FZ_ADOBE_KOREA)
serif: 1 if a serif font is desired, 0 otherwise.
Returns a new font handle, or NULL if no font found (or on error).
*/
typedef fz_font *(fz_load_system_cjk_font_fn)(fz_context *ctx, const char *name, int ros, int serif);
typedef fz_font *(fz_load_system_cjk_font_fn)(fz_context *ctx, const char *name, int ordering, int serif);
/*
fz_load_system_fallback_font_fn: Type for user supplied fallback font loading hook.
/**
Type for user supplied fallback font loading hook.
name: The name of the font to load.
script: UCDN script enum.
language: FZ_LANG enum.
serif, bold, italic: boolean style flags.
Returns a new font handle, or NULL if no font found (or on error).
*/
typedef fz_font *(fz_load_system_fallback_font_fn)(fz_context *ctx, int script, int language, int serif, int bold, int italic);
/*
fz_install_load_system_font_fn: Install functions to allow
MuPDF to request fonts from the system.
/**
Install functions to allow MuPDF to request fonts from the
system.
Only one set of hooks can be in use at a time.
*/
@@ -199,10 +294,8 @@ void fz_install_load_system_font_funcs(fz_context *ctx,
fz_load_system_cjk_font_fn *f_cjk,
fz_load_system_fallback_font_fn *f_fallback);
/* fz_load_*_font returns NULL if no font could be loaded (also on error) */
/*
fz_load_system_font: Attempt to load a given font from the
system.
/**
Attempt to load a given font from the system.
name: The name of the desired font.
@@ -218,23 +311,23 @@ void fz_install_load_system_font_funcs(fz_context *ctx,
*/
fz_font *fz_load_system_font(fz_context *ctx, const char *name, int bold, int italic, int needs_exact_metrics);
/*
fz_load_system_cjk_font: Attempt to load a given font from
/**
Attempt to load a given font from
the system.
name: The name of the desired font.
ros: The registry to load the font from (e.g. FZ_ADOBE_KOREA_1)
ordering: The ordering to load the font from (e.g. FZ_ADOBE_KOREA)
serif: 1 if serif desired, 0 otherwise.
Returns a new font handle, or NULL if no matching font was found
(or on error).
*/
fz_font *fz_load_system_cjk_font(fz_context *ctx, const char *name, int ros, int serif);
fz_font *fz_load_system_cjk_font(fz_context *ctx, const char *name, int ordering, int serif);
/*
fz_lookup_builtin_font: Search the builtin fonts for a match.
/**
Search the builtin fonts for a match.
Whether a given font is present or not will depend on the
configuration in which MuPDF is built.
@@ -251,8 +344,8 @@ fz_font *fz_load_system_cjk_font(fz_context *ctx, const char *name, int ros, int
*/
const unsigned char *fz_lookup_builtin_font(fz_context *ctx, const char *name, int bold, int italic, int *len);
/*
fz_lookup_base14_font: Search the builtin base14 fonts for a match.
/**
Search the builtin base14 fonts for a match.
Whether a given font is present or not will depend on the
configuration in which MuPDF is built.
@@ -265,42 +358,46 @@ const unsigned char *fz_lookup_builtin_font(fz_context *ctx, const char *name, i
*/
const unsigned char *fz_lookup_base14_font(fz_context *ctx, const char *name, int *len);
/* ToDo: Share fz_lookup_builtin_font and fz_lookup_icc? Check with Tor */
/*
fz_lookup_icc: Search for icc profile.
name: The name of the profile desired (gray-icc, rgb-icc, cmyk-icc or lab-icc).
len: Pointer to a place to receive the length of the discovered.
Returns a pointer to the icc file data, or NULL if not present.
*/
const unsigned char *fz_lookup_icc(fz_context *ctx, const char *name, size_t *len);
/*
fz_lookup_cjk_font: Search the builtin cjk fonts for a match.
/**
Search the builtin cjk fonts for a match.
Whether a font is present or not will depend on the
configuration in which MuPDF is built.
registry: The desired registry to lookup in (e.g.
FZ_ADOBE_KOREA_1).
serif: 1 if serif desired, 0 otherwise.
wmode: 1 for vertical mode, 0 for horizontal.
ordering: The desired ordering of the font (e.g. FZ_ADOBE_KOREA).
len: Pointer to a place to receive the length of the discovered
font buffer.
index: Pointer to a place to store the index of the discovered
font.
Returns a pointer to the font file data, or NULL if not present.
*/
const unsigned char *fz_lookup_cjk_font(fz_context *ctx, int ordering, int *len, int *index);
/**
Search the builtin cjk fonts for a match for a given language.
Whether a font is present or not will depend on the
configuration in which MuPDF is built.
lang: Pointer to a (case sensitive) language string (e.g.
"ja", "ko", "zh-Hant" etc).
len: Pointer to a place to receive the length of the discovered
font buffer.
subfont: Pointer to a place to store the subfont index of the
discovered font.
Returns a pointer to the font file data, or NULL if not present.
*/
const unsigned char *fz_lookup_cjk_font(fz_context *ctx, int registry, int serif, int wmode, int *len, int *index);
const unsigned char *fz_lookup_cjk_font_by_language(fz_context *ctx, const char *lang, int *len, int *subfont);
/*
fz_lookup_noto_font: Search the builtin noto fonts for a match.
/**
Return the matching FZ_ADOBE_* ordering
for the given language tag, such as "zh-Hant", "zh-Hans", "ja", or "ko".
*/
int fz_lookup_cjk_ordering_by_language(const char *name);
/**
Search the builtin noto fonts for a match.
Whether a font is present or not will depend on the
configuration in which MuPDF is built.
@@ -308,41 +405,27 @@ const unsigned char *fz_lookup_cjk_font(fz_context *ctx, int registry, int serif
lang: The language desired (e.g. FZ_LANG_ja).
serif: 1 if serif desired, 0 otherwise.
len: Pointer to a place to receive the length of the discovered
font buffer.
Returns a pointer to the font file data, or NULL if not present.
*/
const unsigned char *fz_lookup_noto_font(fz_context *ctx, int script, int lang, int serif, int *len);
const unsigned char *fz_lookup_noto_font(fz_context *ctx, int script, int lang, int *len, int *subfont);
/*
fz_lookup_noto_symbol_font: Search the builtin noto fonts
for a symbol font. Whether a font is present or not will
depend on the configuration in which MuPDF is built.
len: Pointer to a place to receive the length of the discovered
font buffer.
Returns a pointer to the font file data, or NULL if not present.
*/
const unsigned char *fz_lookup_noto_symbol_font(fz_context *ctx, int *len);
/*
fz_lookup_noto_emoji_font: Search the builtin noto fonts
for an emoji font. Whether a font is present or not will
depend on the configuration in which MuPDF is built.
len: Pointer to a place to receive the length of the discovered
font buffer.
Returns a pointer to the font file data, or NULL if not present.
/**
Search the builtin noto fonts specific symbol fonts.
Whether a font is present or not will depend on the
configuration in which MuPDF is built.
*/
const unsigned char *fz_lookup_noto_math_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_music_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_symbol1_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_symbol2_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_emoji_font(fz_context *ctx, int *len);
const unsigned char *fz_lookup_noto_boxes_font(fz_context *ctx, int *len);
/*
fz_load_fallback_font: Try to load a fallback font for the
/**
Try to load a fallback font for the
given combination of font attributes. Whether a font is
present or not will depend on the configuration in which
MuPDF is built.
@@ -361,26 +444,8 @@ const unsigned char *fz_lookup_noto_emoji_font(fz_context *ctx, int *len);
*/
fz_font *fz_load_fallback_font(fz_context *ctx, int script, int language, int serif, int bold, int italic);
/*
fz_load_fallback_symbol_font: Try to load a fallback
symbol font. Whether a font is present or not will
depend on the configuration in which MuPDF is built.
Returns a new font handle, or NULL if not available.
*/
fz_font *fz_load_fallback_symbol_font(fz_context *ctx);
/*
fz_load_fallback_emoji_font: Try to load a fallback
emoji font. Whether a font is present or not will
depend on the configuration in which MuPDF is built.
Returns a new font handle, or NULL if not available.
*/
fz_font *fz_load_fallback_emoji_font(fz_context *ctx);
/*
fz_new_type3_font: Create a new (empty) type3 font.
/**
Create a new (empty) type3 font.
name: Name of font (or NULL).
@@ -389,11 +454,12 @@ fz_font *fz_load_fallback_emoji_font(fz_context *ctx);
Returns a new font handle, or throws exception on
allocation failure.
*/
fz_font *fz_new_type3_font(fz_context *ctx, const char *name, const fz_matrix *matrix);
fz_font *fz_new_type3_font(fz_context *ctx, const char *name, fz_matrix matrix);
/*
fz_new_font_from_memory: Create a new font from a font
file in memory.
/**
Create a new font from a font file in memory.
Fonts created in this way, will be eligible for embedding by default.
name: Name of font (leave NULL to use name from font).
@@ -409,9 +475,10 @@ fz_font *fz_new_type3_font(fz_context *ctx, const char *name, const fz_matrix *m
*/
fz_font *fz_new_font_from_memory(fz_context *ctx, const char *name, const unsigned char *data, int len, int index, int use_glyph_bbox);
/*
fz_new_font_from_buffer: Create a new font from a font
file in a fz_buffer.
/**
Create a new font from a font file in a fz_buffer.
Fonts created in this way, will be eligible for embedding by default.
name: Name of font (leave NULL to use name from font).
@@ -425,9 +492,10 @@ fz_font *fz_new_font_from_memory(fz_context *ctx, const char *name, const unsign
*/
fz_font *fz_new_font_from_buffer(fz_context *ctx, const char *name, fz_buffer *buffer, int index, int use_glyph_bbox);
/*
fz_new_font_from_file: Create a new font from a font
file.
/**
Create a new font from a font file.
Fonts created in this way, will be eligible for embedding by default.
name: Name of font (leave NULL to use name from font).
@@ -441,12 +509,19 @@ fz_font *fz_new_font_from_buffer(fz_context *ctx, const char *name, fz_buffer *b
*/
fz_font *fz_new_font_from_file(fz_context *ctx, const char *name, const char *path, int index, int use_glyph_bbox);
/* Create a new font from one of the built-in fonts. */
/**
Create a new font from one of the built-in fonts.
*/
fz_font *fz_new_base14_font(fz_context *ctx, const char *name);
fz_font *fz_new_cjk_font(fz_context *ctx, int registry, int serif, int wmode);
fz_font *fz_new_cjk_font(fz_context *ctx, int ordering);
fz_font *fz_new_builtin_font(fz_context *ctx, const char *name, int is_bold, int is_italic);
/*
/**
Control whether a given font should be embedded or not when writing.
*/
void fz_set_font_embedding(fz_context *ctx, fz_font *font, int embed);
/**
Add a reference to an existing fz_font.
font: The font to add a reference to.
@@ -455,7 +530,7 @@ fz_font *fz_new_builtin_font(fz_context *ctx, const char *name, int is_bold, int
*/
fz_font *fz_keep_font(fz_context *ctx, fz_font *font);
/*
/**
Drop a reference to a fz_font, destroying the
font when the last reference is dropped.
@@ -463,8 +538,8 @@ fz_font *fz_keep_font(fz_context *ctx, fz_font *font);
*/
void fz_drop_font(fz_context *ctx, fz_font *font);
/*
fz_set_font_bbox: Set the font bbox.
/**
Set the font bbox.
font: The font to set the bbox for.
@@ -472,8 +547,8 @@ void fz_drop_font(fz_context *ctx, fz_font *font);
*/
void fz_set_font_bbox(fz_context *ctx, fz_font *font, float xmin, float ymin, float xmax, float ymax);
/*
fz_bound_glyph: Return a bbox for a given glyph in a font.
/**
Return a bbox for a given glyph in a font.
font: The font to look for the glyph in.
@@ -481,14 +556,13 @@ void fz_set_font_bbox(fz_context *ctx, fz_font *font, float xmin, float ymin, fl
trm: The matrix to apply to the glyph before bounding.
r: Pointer to a fz_rect to use for storage.
Returns r, after filling it in with the bounds of the given glyph.
Returns rectangle by value containing the bounds of the given
glyph.
*/
fz_rect *fz_bound_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, fz_rect *r);
fz_rect fz_bound_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm);
/*
fz_glyph_cacheable: Determine if a given glyph in a font
/**
Determine if a given glyph in a font
is cacheable. Certain glyphs in a type 3 font cannot safely
be cached, as their appearance depends on the enclosing
graphic state.
@@ -501,8 +575,8 @@ fz_rect *fz_bound_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix
*/
int fz_glyph_cacheable(fz_context *ctx, fz_font *font, int gid);
/*
fz_run_t3_glyph: Run a glyph from a Type3 font to
/**
Run a glyph from a Type3 font to
a given device.
font: The font to find the glyph in.
@@ -513,28 +587,10 @@ int fz_glyph_cacheable(fz_context *ctx, fz_font *font, int gid);
dev: The device to render onto.
*/
void fz_run_t3_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, struct fz_device_s *dev);
void fz_run_t3_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix trm, struct fz_device *dev);
/*
fz_decouple_type3_font: Internal function to remove the
references to a document held by a Type3 font. This is
called during document destruction to ensure that Type3
fonts clean up properly.
Without this call being made, Type3 fonts can be left
holding pdf_obj references for the sake of interpretation
operations that will never come. These references
cannot be freed after the document, hence this function
forces them to be freed earlier in the process.
font: The font to decouple.
t3doc: The document to which the font may refer.
*/
void fz_decouple_type3_font(fz_context *ctx, fz_font *font, void *t3doc);
/*
fz_advance_glyph: Return the advance for a given glyph.
/**
Return the advance for a given glyph.
font: The font to look for the glyph in.
@@ -546,8 +602,8 @@ void fz_decouple_type3_font(fz_context *ctx, fz_font *font, void *t3doc);
*/
float fz_advance_glyph(fz_context *ctx, fz_font *font, int glyph, int wmode);
/*
fz_encode_character: Find the glyph id for a given unicode
/**
Find the glyph id for a given unicode
character within a font.
font: The font to look for the unicode character in.
@@ -559,8 +615,31 @@ float fz_advance_glyph(fz_context *ctx, fz_font *font, int glyph, int wmode);
*/
int fz_encode_character(fz_context *ctx, fz_font *font, int unicode);
/*
fz_encode_character_with_fallback: Find the glyph id for
/**
Encode character, preferring small-caps variant if available.
font: The font to look for the unicode character in.
unicode: The unicode character to encode.
Returns the glyph id for the given unicode value, or 0 if
unknown.
*/
int fz_encode_character_sc(fz_context *ctx, fz_font *font, int unicode);
/**
Encode character.
Either by direct lookup of glyphname within a font, or, failing
that, by mapping glyphname to unicode and thence to the glyph
index within the given font.
Returns zero for type3 fonts.
*/
int fz_encode_character_by_glyph_name(fz_context *ctx, fz_font *font, const char *glyphname);
/**
Find the glyph id for
a given unicode character within a font, falling back to
an alternative if not found.
@@ -586,8 +665,8 @@ int fz_encode_character(fz_context *ctx, fz_font *font, int unicode);
*/
int fz_encode_character_with_fallback(fz_context *ctx, fz_font *font, int unicode, int script, int language, fz_font **out_font);
/*
fz_get_glyph_name: Find the name of a glyph
/**
Find the name of a glyph
font: The font to look for the glyph in.
@@ -604,28 +683,133 @@ int fz_encode_character_with_fallback(fz_context *ctx, fz_font *font, int unicod
*/
void fz_get_glyph_name(fz_context *ctx, fz_font *font, int glyph, char *buf, int size);
/*
Get font ascender and descender values.
/**
Retrieve font ascender in ems.
*/
float fz_font_ascender(fz_context *ctx, fz_font *font);
/**
Retrieve font descender in ems.
*/
float fz_font_descender(fz_context *ctx, fz_font *font);
/*
/**
Retrieve the MD5 digest for the font's data.
*/
void fz_font_digest(fz_context *ctx, fz_font *font, unsigned char digest[16]);
/* Implementation details: subject to change. */
void fz_decouple_type3_font(fz_context *ctx, fz_font *font, void *t3doc);
/**
map an FT error number to a
static string.
err: The error number to lookup.
Returns a pointer to a static textual representation
of a freetype error.
*/
const char *ft_error_string(int err);
int ft_char_index(void *face, int cid);
int ft_name_index(void *face, const char *name);
/**
Internal functions for our Harfbuzz integration
to work around the lack of thread safety.
*/
/*
fz_hb_lock: Lock against Harfbuzz being called
/**
Lock against Harfbuzz being called
simultaneously in several threads. This reuses
FZ_LOCK_FREETYPE.
*/
void fz_hb_lock(fz_context *ctx);
/*
fz_hb_unlock: Unlock after a Harfbuzz call. This reuses
/**
Unlock after a Harfbuzz call. This reuses
FZ_LOCK_FREETYPE.
*/
void fz_hb_unlock(fz_context *ctx);
struct fz_font
{
int refs;
char name[32];
fz_buffer *buffer;
fz_font_flags_t flags;
void *ft_face; /* has an FT_Face if used */
fz_shaper_data_t shaper_data;
fz_matrix t3matrix;
void *t3resources;
fz_buffer **t3procs; /* has 256 entries if used */
struct fz_display_list **t3lists; /* has 256 entries if used */
float *t3widths; /* has 256 entries if used */
unsigned short *t3flags; /* has 256 entries if used */
void *t3doc; /* a pdf_document for the callback */
void (*t3run)(fz_context *ctx, void *doc, void *resources, fz_buffer *contents, struct fz_device *dev, fz_matrix ctm, void *gstate, fz_default_colorspaces *default_cs);
void (*t3freeres)(fz_context *ctx, void *doc, void *resources);
fz_rect bbox; /* font bbox is used only for t3 fonts */
int glyph_count;
/* per glyph bounding box cache. */
fz_rect **bbox_table;
int use_glyph_bbox;
/* substitute metrics */
int width_count;
short width_default; /* in 1000 units */
short *width_table; /* in 1000 units */
/* cached glyph metrics */
float **advance_cache;
/* cached encoding lookup */
uint16_t *encoding_cache[256];
/* cached md5sum for caching */
int has_digest;
unsigned char digest[16];
/* Which font to use in a collection. */
int subfont;
};
void fz_ft_lock(fz_context *ctx);
void fz_ft_unlock(fz_context *ctx);
/* Internal function. Must be called with FT_ALLOC_LOCK
* held. Returns 1 if this thread (context!) already holds
* the freeetype lock. */
int fz_ft_lock_held(fz_context *ctx);
/* Internal function: Extract a ttf from the ttc that underlies
* a given fz_font. Caller takes ownership of the returned
* buffer.
*/
fz_buffer *fz_extract_ttf_from_ttc(fz_context *ctx, fz_font *font);
/* Internal function: Given a ttf in a buffer, create a subset
* ttf in a new buffer that only provides the required gids.
* Caller takes ownership of the returned buffer.
*
* EXPERIMENTAL AND VERY SUBJECT TO CHANGE.
*/
fz_buffer *fz_subset_ttf_for_gids(fz_context *ctx, fz_buffer *orig, int *gids, int num_gids, int symbolic, int cidfont);
/* Internal function: Given a cff in a buffer, create a subset
* cff in a new buffer that only provides the required gids.
* Caller takes ownership of the returned buffer.
*
* EXPERIMENTAL AND VERY SUBJECT TO CHANGE.
*/
fz_buffer *fz_subset_cff_for_gids(fz_context *ctx, fz_buffer *orig, int *gids, int num_gids, int symbolic, int cidfont);
#endif

580
include/mupdf/fitz/geometry.h
View File

@@ -1,9 +1,33 @@
// Copyright (C) 2004-2022 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_MATH_H
#define MUPDF_FITZ_MATH_H
#include "mupdf/fitz/system.h"
/*
#include <assert.h>
/**
Multiply scaled two integers in the 0..255 range
*/
static inline int fz_mul255(int a, int b)
@@ -14,45 +38,57 @@ static inline int fz_mul255(int a, int b)
return x >> 8;
}
/*
/**
Undo alpha premultiplication.
*/
static inline int fz_div255(int c, int a)
{
return a ? c * (255 * 256 / a) >> 8 : 0;
}
/**
Expand a value A from the 0...255 range to the 0..256 range
*/
#define FZ_EXPAND(A) ((A)+((A)>>7))
/*
/**
Combine values A (in any range) and B (in the 0..256 range),
to give a single value in the same range as A was.
*/
#define FZ_COMBINE(A,B) (((A)*(B))>>8)
/*
/**
Combine values A and C (in the same (any) range) and B and D (in
the 0..256 range), to give a single value in the same range as A
and C were.
*/
#define FZ_COMBINE2(A,B,C,D) (((A) * (B) + (C) * (D))>>8)
/*
/**
Blend SRC and DST (in the same range) together according to
AMOUNT (in the 0...256 range).
*/
#define FZ_BLEND(SRC, DST, AMOUNT) ((((SRC)-(DST))*(AMOUNT) + ((DST)<<8))>>8)
/*
/**
Range checking atof
*/
float fz_atof(const char *s);
/*
/**
atoi that copes with NULL
*/
int fz_atoi(const char *s);
/**
64bit atoi that copes with NULL
*/
int64_t fz_atoi64(const char *s);
/*
/**
Some standard math functions, done as static inlines for speed.
People with compilers that do not adequately implement inlines may
like to reimplement these using macros.
People with compilers that do not adequately implement inline
may like to reimplement these using macros.
*/
static inline float fz_abs(float f)
{
@@ -79,6 +115,11 @@ static inline size_t fz_minz(size_t a, size_t b)
return (a < b ? a : b);
}
static inline int64_t fz_mini64(int64_t a, int64_t b)
{
return (a < b ? a : b);
}
static inline float fz_max(float a, float b)
{
return (a > b ? a : b);
@@ -89,41 +130,50 @@ static inline int fz_maxi(int a, int b)
return (a > b ? a : b);
}
static inline size_t fz_maxz(size_t a, size_t b)
{
return (a > b ? a : b);
}
static inline int64_t fz_maxi64(int64_t a, int64_t b)
{
return (a > b ? a : b);
}
static inline float fz_clamp(float f, float min, float max)
static inline float fz_clamp(float x, float min, float max)
{
return (f > min ? (f < max ? f : max) : min);
return x < min ? min : x > max ? max : x;
}
static inline int fz_clampi(int i, int min, int max)
static inline int fz_clampi(int x, int min, int max)
{
return (i > min ? (i < max ? i : max) : min);
return x < min ? min : x > max ? max : x;
}
static inline double fz_clampd(double d, double min, double max)
static inline int64_t fz_clamp64(int64_t x, int64_t min, int64_t max)
{
return (d > min ? (d < max ? d : max) : min);
return x < min ? min : x > max ? max : x;
}
static inline void *fz_clampp(void *p, void *min, void *max)
static inline double fz_clampd(double x, double min, double max)
{
return (p > min ? (p < max ? p : max) : min);
return x < min ? min : x > max ? max : x;
}
static inline void *fz_clampp(void *x, void *min, void *max)
{
return x < min ? min : x > max ? max : x;
}
#define DIV_BY_ZERO(a, b, min, max) (((a) < 0) ^ ((b) < 0) ? (min) : (max))
/*
/**
fz_point is a point in a two-dimensional space.
*/
typedef struct fz_point_s fz_point;
struct fz_point_s
typedef struct
{
float x, y;
};
} fz_point;
static inline fz_point fz_make_point(float x, float y)
{
@@ -131,30 +181,44 @@ static inline fz_point fz_make_point(float x, float y)
return p;
}
/*
/**
fz_rect is a rectangle represented by two diagonally opposite
corners at arbitrary coordinates.
Rectangles are always axis-aligned with the X- and Y- axes.
The relationship between the coordinates are that x0 <= x1 and
y0 <= y1 in all cases except for infinite rectangles. The area
of a rectangle is defined as (x1 - x0) * (y1 - y0). If either
x0 > x1 or y0 > y1 is true for a given rectangle then it is
defined to be infinite.
Rectangles are always axis-aligned with the X- and Y- axes. We
wish to distinguish rectangles in 3 categories; infinite, finite,
and invalid. Zero area rectangles are a sub-category of finite
ones.
For all valid rectangles, x0 <= x1 and y0 <= y1 in all cases.
Infinite rectangles have x0 = y0 = FZ_MIN_INF_RECT,
x1 = y1 = FZ_MAX_INF_RECT. For any non infinite valid rectangle,
the area is defined as (x1 - x0) * (y1 - y0).
To check for empty or infinite rectangles use fz_is_empty_rect
and fz_is_infinite_rect.
and fz_is_infinite_rect. To check for valid rectangles use
fz_is_valid_rect.
We choose this representation, so that we can easily distinguish
the difference between intersecting 2 valid rectangles and
getting an invalid one, as opposed to getting a zero area one
(which nonetheless has valid bounds within the plane).
x0, y0: The top left corner.
x1, y1: The bottom right corner.
We choose FZ_{MIN,MAX}_INF_RECT to be the largest 32bit signed
integer values that survive roundtripping to floats.
*/
typedef struct fz_rect_s fz_rect;
struct fz_rect_s
#define FZ_MIN_INF_RECT ((int)0x80000000)
#define FZ_MAX_INF_RECT ((int)0x7fffff80)
typedef struct
{
float x0, y0;
float x1, y1;
};
} fz_rect;
static inline fz_rect fz_make_rect(float x0, float y0, float x1, float y1)
{
@@ -162,33 +226,16 @@ static inline fz_rect fz_make_rect(float x0, float y0, float x1, float y1)
return r;
}
/*
fz_rect_min: get the minimum point from a rectangle as a fz_point.
*/
static inline fz_point *fz_rect_min(fz_rect *f)
{
return (fz_point *)&f->x0;
}
/*
fz_rect_max: get the maximum point from a rectangle as a fz_point.
*/
static inline fz_point *fz_rect_max(fz_rect *f)
{
return (fz_point *)&f->x1;
}
/*
/**
fz_irect is a rectangle using integers instead of floats.
It's used in the draw device and for pixmap dimensions.
*/
typedef struct fz_irect_s fz_irect;
struct fz_irect_s
typedef struct
{
int x0, y0;
int x1, y1;
};
} fz_irect;
static inline fz_irect fz_make_irect(int x0, int y0, int x1, int y1)
{
@@ -196,74 +243,116 @@ static inline fz_irect fz_make_irect(int x0, int y0, int x1, int y1)
return r;
}
/*
/**
A rectangle with sides of length one.
The bottom left corner is at (0, 0) and the top right corner
is at (1, 1).
*/
extern const fz_rect fz_unit_rect;
FZ_DATA extern const fz_rect fz_unit_rect;
/*
/**
An empty rectangle with an area equal to zero.
Both the top left and bottom right corner are at (0, 0).
*/
extern const fz_rect fz_empty_rect;
extern const fz_irect fz_empty_irect;
FZ_DATA extern const fz_rect fz_empty_rect;
FZ_DATA extern const fz_irect fz_empty_irect;
/*
An infinite rectangle with negative area.
The corner (x0, y0) is at (1, 1) while the corner (x1, y1) is
at (-1, -1).
/**
An infinite rectangle.
*/
extern const fz_rect fz_infinite_rect;
extern const fz_irect fz_infinite_irect;
FZ_DATA extern const fz_rect fz_infinite_rect;
FZ_DATA extern const fz_irect fz_infinite_irect;
/*
fz_is_empty_rect: Check if rectangle is empty.
/**
Check if rectangle is empty.
An empty rectangle is defined as one whose area is zero.
All invalid rectangles are empty.
*/
static inline int
fz_is_empty_rect(const fz_rect *r)
static inline int fz_is_empty_rect(fz_rect r)
{
return ((r)->x0 == (r)->x1 || (r)->y0 == (r)->y1);
return (r.x0 >= r.x1 || r.y0 >= r.y1);
}
static inline int
fz_is_empty_irect(const fz_irect *r)
static inline int fz_is_empty_irect(fz_irect r)
{
return ((r)->x0 == (r)->x1 || (r)->y0 == (r)->y1);
return (r.x0 >= r.x1 || r.y0 >= r.y1);
}
/*
fz_is_infinite_rect: Check if rectangle is infinite.
An infinite rectangle is defined as one where either of the
two relationships between corner coordinates are not true.
/**
Check if rectangle is infinite.
*/
static inline int
fz_is_infinite_rect(const fz_rect *r)
static inline int fz_is_infinite_rect(fz_rect r)
{
return ((r)->x0 > (r)->x1 || (r)->y0 > (r)->y1);
return (r.x0 == FZ_MIN_INF_RECT && r.x1 == FZ_MAX_INF_RECT &&
r.y0 == FZ_MIN_INF_RECT && r.y1 == FZ_MAX_INF_RECT);
}
/*
fz_is_infinite_irect: Check if an integer rectangle
/**
Check if an integer rectangle
is infinite.
An infinite rectangle is defined as one where either of the
two relationships between corner coordinates are not true.
*/
static inline int
fz_is_infinite_irect(const fz_irect *r)
static inline int fz_is_infinite_irect(fz_irect r)
{
return ((r)->x0 > (r)->x1 || (r)->y0 > (r)->y1);
return (r.x0 == FZ_MIN_INF_RECT && r.x1 == FZ_MAX_INF_RECT &&
r.y0 == FZ_MIN_INF_RECT && r.y1 == FZ_MAX_INF_RECT);
}
/*
/**
Check if rectangle is valid.
*/
static inline int fz_is_valid_rect(fz_rect r)
{
return (r.x0 <= r.x1 && r.y0 <= r.y1);
}
/**
Check if an integer rectangle is valid.
*/
static inline int fz_is_valid_irect(fz_irect r)
{
return (r.x0 <= r.x1 && r.y0 <= r.y1);
}
/**
Return the width of an irect. Invalid irects return 0.
*/
static inline unsigned int
fz_irect_width(fz_irect r)
{
unsigned int w;
if (r.x0 >= r.x1)
return 0;
/* Check for w overflowing. This should never happen, but
* if it does, it's pretty likely an indication of a severe
* problem. */
w = (unsigned int)r.x1 - r.x0;
assert((int)w >= 0);
if ((int)w < 0)
return 0;
return (int)w;
}
/**
Return the height of an irect. Invalid irects return 0.
*/
static inline int
fz_irect_height(fz_irect r)
{
unsigned int h;
if (r.y0 >= r.y1)
return 0;
/* Check for h overflowing. This should never happen, but
* if it does, it's pretty likely an indication of a severe
* problem. */
h = (unsigned int)(r.y1 - r.y0);
assert((int)h >= 0);
if ((int)h < 0)
return 0;
return (int)h;
}
/**
fz_matrix is a row-major 3x3 matrix used for representing
transformations of coordinates throughout MuPDF.
@@ -276,16 +365,15 @@ fz_is_infinite_irect(const fz_irect *r)
| c d 0 | normally represented as [ a b c d e f ].
\ e f 1 /
*/
typedef struct fz_matrix_s fz_matrix;
struct fz_matrix_s
typedef struct
{
float a, b, c, d, e, f;
};
} fz_matrix;
/*
fz_identity: Identity transform matrix.
/**
Identity transform matrix.
*/
extern const fz_matrix fz_identity;
FZ_DATA extern const fz_matrix fz_identity;
static inline fz_matrix fz_make_matrix(float a, float b, float c, float d, float e, float f)
{
@@ -293,24 +381,23 @@ static inline fz_matrix fz_make_matrix(float a, float b, float c, float d, float
return m;
}
static inline fz_matrix *fz_copy_matrix(fz_matrix *restrict m, const fz_matrix *restrict s)
static inline int fz_is_identity(fz_matrix m)
{
*m = *s;
return m;
return m.a == 1 && m.b == 0 && m.c == 0 && m.d == 1 && m.e == 0 && m.f == 0;
}
/*
fz_concat: Multiply two matrices.
/**
Multiply two matrices.
The order of the two matrices are important since matrix
multiplication is not commutative.
Returns result.
*/
fz_matrix *fz_concat(fz_matrix *result, const fz_matrix *left, const fz_matrix *right);
fz_matrix fz_concat(fz_matrix left, fz_matrix right);
/*
fz_scale: Create a scaling matrix.
/**
Create a scaling matrix.
The returned matrix is of the form [ sx 0 0 sy 0 0 ].
@@ -322,10 +409,10 @@ fz_matrix *fz_concat(fz_matrix *result, const fz_matrix *left, const fz_matrix *
Returns m.
*/
fz_matrix *fz_scale(fz_matrix *m, float sx, float sy);
fz_matrix fz_scale(float sx, float sy);
/*
fz_pre_scale: Scale a matrix by premultiplication.
/**
Scale a matrix by premultiplication.
m: Pointer to the matrix to scale
@@ -335,10 +422,10 @@ fz_matrix *fz_scale(fz_matrix *m, float sx, float sy);
Returns m (updated).
*/
fz_matrix *fz_pre_scale(fz_matrix *m, float sx, float sy);
fz_matrix fz_pre_scale(fz_matrix m, float sx, float sy);
/*
fz_post_scale: Scale a matrix by postmultiplication.
/**
Scale a matrix by postmultiplication.
m: Pointer to the matrix to scale
@@ -348,10 +435,10 @@ fz_matrix *fz_pre_scale(fz_matrix *m, float sx, float sy);
Returns m (updated).
*/
fz_matrix *fz_post_scale(fz_matrix *m, float sx, float sy);
fz_matrix fz_post_scale(fz_matrix m, float sx, float sy);
/*
fz_shear: Create a shearing matrix.
/**
Create a shearing matrix.
The returned matrix is of the form [ 1 sy sx 1 0 0 ].
@@ -362,10 +449,10 @@ fz_matrix *fz_post_scale(fz_matrix *m, float sx, float sy);
Returns m.
*/
fz_matrix *fz_shear(fz_matrix *m, float sx, float sy);
fz_matrix fz_shear(float sx, float sy);
/*
fz_pre_shear: Premultiply a matrix with a shearing matrix.
/**
Premultiply a matrix with a shearing matrix.
The shearing matrix is of the form [ 1 sy sx 1 0 0 ].
@@ -376,10 +463,10 @@ fz_matrix *fz_shear(fz_matrix *m, float sx, float sy);
Returns m (updated).
*/
fz_matrix *fz_pre_shear(fz_matrix *m, float sx, float sy);
fz_matrix fz_pre_shear(fz_matrix m, float sx, float sy);
/*
fz_rotate: Create a rotation matrix.
/**
Create a rotation matrix.
The returned matrix is of the form
[ cos(deg) sin(deg) -sin(deg) cos(deg) 0 0 ].
@@ -391,10 +478,10 @@ fz_matrix *fz_pre_shear(fz_matrix *m, float sx, float sy);
Returns m.
*/
fz_matrix *fz_rotate(fz_matrix *m, float degrees);
fz_matrix fz_rotate(float degrees);
/*
fz_pre_rotate: Rotate a transformation by premultiplying.
/**
Rotate a transformation by premultiplying.
The premultiplied matrix is of the form
[ cos(deg) sin(deg) -sin(deg) cos(deg) 0 0 ].
@@ -406,10 +493,10 @@ fz_matrix *fz_rotate(fz_matrix *m, float degrees);
Returns m (updated).
*/
fz_matrix *fz_pre_rotate(fz_matrix *m, float degrees);
fz_matrix fz_pre_rotate(fz_matrix m, float degrees);
/*
fz_translate: Create a translation matrix.
/**
Create a translation matrix.
The returned matrix is of the form [ 1 0 0 1 tx ty ].
@@ -421,10 +508,10 @@ fz_matrix *fz_pre_rotate(fz_matrix *m, float degrees);
Returns m.
*/
fz_matrix *fz_translate(fz_matrix *m, float tx, float ty);
fz_matrix fz_translate(float tx, float ty);
/*
fz_pre_translate: Translate a matrix by premultiplication.
/**
Translate a matrix by premultiplication.
m: The matrix to translate
@@ -434,10 +521,18 @@ fz_matrix *fz_translate(fz_matrix *m, float tx, float ty);
Returns m.
*/
fz_matrix *fz_pre_translate(fz_matrix *m, float tx, float ty);
fz_matrix fz_pre_translate(fz_matrix m, float tx, float ty);
/*
fz_invert_matrix: Create an inverse matrix.
/**
Create transform matrix to draw page
at a given resolution and rotation. Adjusts the scaling
factors so that the page covers whole number of
pixels and adjust the page origin to be at 0,0.
*/
fz_matrix fz_transform_page(fz_rect mediabox, float resolution, float rotate);
/**
Create an inverse matrix.
inverse: Place to store inverse matrix.
@@ -447,10 +542,10 @@ fz_matrix *fz_pre_translate(fz_matrix *m, float tx, float ty);
Returns inverse.
*/
fz_matrix *fz_invert_matrix(fz_matrix *inverse, const fz_matrix *matrix);
fz_matrix fz_invert_matrix(fz_matrix matrix);
/*
fz_try_invert_matrix: Attempt to create an inverse matrix.
/**
Attempt to create an inverse matrix.
inverse: Place to store inverse matrix.
@@ -459,25 +554,25 @@ fz_matrix *fz_invert_matrix(fz_matrix *inverse, const fz_matrix *matrix);
Returns 1 if matrix is degenerate (singular), or 0 otherwise.
*/
int fz_try_invert_matrix(fz_matrix *inverse, const fz_matrix *matrix);
int fz_try_invert_matrix(fz_matrix *inv, fz_matrix src);
/*
fz_is_rectilinear: Check if a transformation is rectilinear.
/**
Check if a transformation is rectilinear.
Rectilinear means that no shearing is present and that any
rotations present are a multiple of 90 degrees. Usually this
is used to make sure that axis-aligned rectangles before the
transformation are still axis-aligned rectangles afterwards.
*/
int fz_is_rectilinear(const fz_matrix *m);
int fz_is_rectilinear(fz_matrix m);
/*
fz_matrix_expansion: Calculate average scaling factor of matrix.
/**
Calculate average scaling factor of matrix.
*/
float fz_matrix_expansion(const fz_matrix *m); /* sumatrapdf */
float fz_matrix_expansion(fz_matrix m);
/*
fz_intersect_rect: Compute intersection of two rectangles.
/**
Compute intersection of two rectangles.
Given two rectangles, update the first to be the smallest
axis-aligned rectangle that covers the area covered by both
@@ -487,18 +582,18 @@ float fz_matrix_expansion(const fz_matrix *m); /* sumatrapdf */
Should both rectangles be infinite, then the intersection is
also infinite.
*/
fz_rect *fz_intersect_rect(fz_rect *restrict a, const fz_rect *restrict b);
fz_rect fz_intersect_rect(fz_rect a, fz_rect b);
/*
fz_intersect_irect: Compute intersection of two bounding boxes.
/**
Compute intersection of two bounding boxes.
Similar to fz_intersect_rect but operates on two bounding
boxes instead of two rectangles.
*/
fz_irect *fz_intersect_irect(fz_irect *restrict a, const fz_irect *restrict b);
fz_irect fz_intersect_irect(fz_irect a, fz_irect b);
/*
fz_union_rect: Compute union of two rectangles.
/**
Compute union of two rectangles.
Given two rectangles, update the first to be the smallest
axis-aligned rectangle that encompasses both given rectangles.
@@ -507,28 +602,21 @@ fz_irect *fz_intersect_irect(fz_irect *restrict a, const fz_irect *restrict b);
non-empty rectangle. Should both rectangles be empty, then the
union is also empty.
*/
fz_rect *fz_union_rect(fz_rect *restrict a, const fz_rect *restrict b);
fz_rect fz_union_rect(fz_rect a, fz_rect b);
/*
fz_irect_from_rect: Convert a rect into the minimal bounding box
/**
Convert a rect into the minimal bounding box
that covers the rectangle.
bbox: Place to store the returned bbox.
rect: The rectangle to convert to a bbox.
Coordinates in a bounding box are integers, so rounding of the
rects coordinates takes place. The top left corner is rounded
upwards and left while the bottom right corner is rounded
downwards and to the right.
Returns bbox (updated).
*/
fz_irect fz_irect_from_rect(fz_rect rect);
fz_irect *fz_irect_from_rect(fz_irect *restrict bbox, const fz_rect *restrict rect);
/*
fz_round_rect: Round rectangle coordinates.
/**
Round rectangle coordinates.
Coordinates in a bounding box are integers, so rounding of the
rects coordinates takes place. The top left corner is rounded
@@ -536,15 +624,15 @@ fz_irect *fz_irect_from_rect(fz_irect *restrict bbox, const fz_rect *restrict re
downwards and to the right.
This differs from fz_irect_from_rect, in that fz_irect_from_rect
slavishly follows the numbers (i.e any slight over/under calculations
can cause whole extra pixels to be added). fz_round_rect
allows for a small amount of rounding error when calculating
the bbox.
slavishly follows the numbers (i.e any slight over/under
calculations can cause whole extra pixels to be added).
fz_round_rect allows for a small amount of rounding error when
calculating the bbox.
*/
fz_irect *fz_round_rect(fz_irect *restrict bbox, const fz_rect *restrict rect);
fz_irect fz_round_rect(fz_rect rect);
/*
fz_rect_from_irect: Convert a bbox into a rect.
/**
Convert a bbox into a rect.
For our purposes, a rect can represent all the values we meet in
a bbox, so nothing can go wrong.
@@ -555,39 +643,39 @@ fz_irect *fz_round_rect(fz_irect *restrict bbox, const fz_rect *restrict rect);
Returns rect (updated).
*/
fz_rect *fz_rect_from_irect(fz_rect *restrict rect, const fz_irect *restrict bbox);
fz_rect fz_rect_from_irect(fz_irect bbox);
/*
fz_expand_rect: Expand a bbox by a given amount in all directions.
/**
Expand a bbox by a given amount in all directions.
*/
fz_rect *fz_expand_rect(fz_rect *b, float expand);
fz_irect *fz_expand_irect(fz_irect *a, int expand);
fz_rect fz_expand_rect(fz_rect b, float expand);
fz_irect fz_expand_irect(fz_irect a, int expand);
/*
fz_include_point_in_rect: Expand a bbox to include a given point.
/**
Expand a bbox to include a given point.
To create a rectangle that encompasses a sequence of points, the
rectangle must first be set to be the empty rectangle at one of
the points before including the others.
*/
fz_rect *fz_include_point_in_rect(fz_rect *r, const fz_point *p);
fz_rect fz_include_point_in_rect(fz_rect r, fz_point p);
/*
fz_translate_irect: Translate bounding box.
/**
Translate bounding box.
Translate a bbox by a given x and y offset. Allows for overflow.
*/
fz_rect *fz_translate_rect(fz_rect *a, float xoff, float yoff);
fz_irect *fz_translate_irect(fz_irect *a, int xoff, int yoff);
fz_rect fz_translate_rect(fz_rect a, float xoff, float yoff);
fz_irect fz_translate_irect(fz_irect a, int xoff, int yoff);
/*
fz_contains_rect: Test rectangle inclusion.
/**
Test rectangle inclusion.
Return true if a entirely contains b.
*/
int fz_contains_rect(const fz_rect *a, const fz_rect *b);
int fz_contains_rect(fz_rect a, fz_rect b);
/*
fz_transform_point: Apply a transformation to a point.
/**
Apply a transformation to a point.
transform: Transformation matrix to apply. See fz_concat,
fz_scale, fz_rotate and fz_translate for how to create a
@@ -597,11 +685,11 @@ int fz_contains_rect(const fz_rect *a, const fz_rect *b);
Returns transform (unchanged).
*/
fz_point *fz_transform_point(fz_point *restrict point, const fz_matrix *restrict transform);
fz_point *fz_transform_point_xy(fz_point *restrict point, const fz_matrix *restrict transform, float x, float y);
fz_point fz_transform_point(fz_point point, fz_matrix m);
fz_point fz_transform_point_xy(float x, float y, fz_matrix m);
/*
fz_transform_vector: Apply a transformation to a vector.
/**
Apply a transformation to a vector.
transform: Transformation matrix to apply. See fz_concat,
fz_scale and fz_rotate for how to create a matrix. Any
@@ -609,10 +697,10 @@ fz_point *fz_transform_point_xy(fz_point *restrict point, const fz_matrix *restr
vector: Pointer to vector to update.
*/
fz_point *fz_transform_vector(fz_point *restrict vector, const fz_matrix *restrict transform);
fz_point fz_transform_vector(fz_point vector, fz_matrix m);
/*
fz_transform_rect: Apply a transform to a rectangle.
/**
Apply a transform to a rectangle.
After the four corner points of the axis-aligned rectangle
have been transformed it may not longer be axis-aligned. So a
@@ -626,15 +714,105 @@ fz_point *fz_transform_vector(fz_point *restrict vector, const fz_matrix *restri
fz_empty_rect and fz_infinite_rect, may be used but are
returned unchanged as expected.
*/
fz_rect *fz_transform_rect(fz_rect *restrict rect, const fz_matrix *restrict transform);
fz_rect fz_transform_rect(fz_rect rect, fz_matrix m);
/*
fz_normalize_vector: Normalize a vector to length one.
/**
Normalize a vector to length one.
*/
void fz_normalize_vector(fz_point *p);
fz_point fz_normalize_vector(fz_point p);
void fz_gridfit_matrix(int as_tiled, fz_matrix *m);
/**
Grid fit a matrix.
float fz_matrix_max_expansion(const fz_matrix *m);
as_tiled = 0 => adjust the matrix so that the image of the unit
square completely covers any pixel that was touched by the
image of the unit square under the original matrix.
as_tiled = 1 => adjust the matrix so that the corners of the
image of the unit square align with the closest integer corner
of the image of the unit square under the original matrix.
*/
fz_matrix fz_gridfit_matrix(int as_tiled, fz_matrix m);
/**
Find the largest expansion performed by this matrix.
(i.e. max(abs(m.a),abs(m.b),abs(m.c),abs(m.d))
*/
float fz_matrix_max_expansion(fz_matrix m);
/**
A representation for a region defined by 4 points.
The significant difference between quads and rects is that
the edges of quads are not axis aligned.
*/
typedef struct
{
fz_point ul, ur, ll, lr;
} fz_quad;
/**
Inline convenience construction function.
*/
static inline fz_quad fz_make_quad(
float ul_x, float ul_y,
float ur_x, float ur_y,
float ll_x, float ll_y,
float lr_x, float lr_y)
{
fz_quad q = {
{ ul_x, ul_y },
{ ur_x, ur_y },
{ ll_x, ll_y },
{ lr_x, lr_y },
};
return q;
}
/**
Convert a rect to a quad (losslessly).
*/
fz_quad fz_quad_from_rect(fz_rect r);
/**
Convert a quad to the smallest rect that covers it.
*/
fz_rect fz_rect_from_quad(fz_quad q);
/**
Transform a quad by a matrix.
*/
fz_quad fz_transform_quad(fz_quad q, fz_matrix m);
/**
Inclusion test for quads.
*/
int fz_is_point_inside_quad(fz_point p, fz_quad q);
/**
Inclusion test for rects. (Rect is assumed to be open, i.e.
top right corner is not included).
*/
int fz_is_point_inside_rect(fz_point p, fz_rect r);
/**
Inclusion test for irects. (Rect is assumed to be open, i.e.
top right corner is not included).
*/
int fz_is_point_inside_irect(int x, int y, fz_irect r);
/**
Inclusion test for quad in quad.
This may break down if quads are not 'well formed'.
*/
int fz_is_quad_inside_quad(fz_quad needle, fz_quad haystack);
/**
Intersection test for quads.
This may break down if quads are not 'well formed'.
*/
int fz_is_quad_intersecting_quad(fz_quad a, fz_quad b);
#endif

130
include/mupdf/fitz/getopt.h
View File

@@ -1,20 +1,128 @@
// Copyright (C) 2004-2021 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_GETOPT_H
#define MUPDF_FITZ_GETOPT_H
/*
getopt: Simple functions/variables for use in tools.
#include "export.h"
typedef struct
{
char *option;
int *flag;
void *opaque;
} fz_getopt_long_options;
/**
Simple functions/variables for use in tools.
ostr = option string. Comprises single letter options, followed by : if there
is an argument to the option.
longopts: NULL (indicating no long options), or a pointer to an array of
longoptions, terminated by an entry with option == NULL.
In the event of matching a single char option, this function will normally
return the char. The exception to this is when the option requires an
argument and none is supplied; in this case we return ':'.
In the event of matching a long option, this function returns 0, with fz_optlong
set to point to the matching option.
A long option entry may be followed with : to indicate there is an argument to the
option. If the need for an argument is specified in this way, and no argument is
given, an error will be displayed and argument processing will stop. If an argument
is given, and the long option record contains a non-null flag pointer, then the code
will decode the argument and fill in that flag pointer. Specifically,
case-insensitive matches to 'yes', 'no', 'true' and 'false' will cause a value of 0
or 1 as appropriate to be written; failing this the arg will be interpreted as a
decimal integer using atoi.
A long option entry may be followed by an list of options (e.g. myoption=foo|bar|baz)
and the option will be passed to fz_opt_from_list. The return value of that will be
placed in fz_optitem. If the return value of that function is -1, then an error will
be displayed and argument processing will stop.
In the event of reaching the end of the arg list or '--', this function returns EOF.
In the event of failing to match anything, an error is printed, and we return '?'.
If an argument is expected for the option, then fz_optarg will be returned pointing
at the start of the argument. Examples of supported argument formats: '-r500', '-r 500',
'--resolution 500', '--resolution=500'.
*/
extern int fz_getopt_long(int nargc, char * const *nargv, const char *ostr, const fz_getopt_long_options *longopts);
/**
Identical to fz_getopt_long, but with a NULL longopts field, signifying no long
options.
*/
extern int fz_getopt(int nargc, char * const *nargv, const char *ostr);
extern int fz_optind;
extern char *fz_optarg;
/*
Windows unicode versions.
/**
fz_optind is updated to point to the current index being read from the
arguments.
*/
#ifdef _WIN32
extern int fz_getoptw(int nargc, wchar_t * const *nargv, const wchar_t *ostr);
extern int fz_optindw;
extern wchar_t *fz_optargw;
#endif
FZ_DATA extern int fz_optind;
/**
fz_optarg is a pointer to the argument data for the most recently
read option.
*/
FZ_DATA extern char *fz_optarg;
/**
fz_optlong is a pointer to the record for the most recently
read long option. (i.e. if a long option is detected, this
will be set to point to the record for that option, otherwise
it will be NULL).
*/
FZ_DATA extern const fz_getopt_long_options *fz_optlong;
/**
The item number for the most recently matched item list.
First item in the list is numbered 0. No match is -1.
*/
FZ_DATA extern int fz_optitem;
/**
Return the index of a (case-insensitive) option within an optlist.
For instance for optlist = "Foo|Bar|Baz", and opt = "bar",
this would return 1.
If the optlist ends with "|*" then that is a catch all case and
matches all options allowing the caller to process it itself.
fz_optarg will be set to point to the option, and the return
value will be the index of the '*' option within that list.
If an optlist entry ends with ':' (e.g. "Foo:") then that option
may have suboptions appended to it (for example "JPG:80") and
fz_optarg will be set to point at "80". Otherwise fz_optarg will
be set to NULL.
In the event of no-match found, prints an error and returns -1.
*/
int fz_opt_from_list(char *opt, const char *optlist);
#endif

88
include/mupdf/fitz/glyph-cache.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_GLYPH_CACHE_H
#define MUPDF_FITZ_GLYPH_CACHE_H
@@ -5,12 +27,70 @@
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/font.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/device.h"
/**
Purge all the glyphs from the cache.
*/
void fz_purge_glyph_cache(fz_context *ctx);
fz_pixmap *fz_render_glyph_pixmap(fz_context *ctx, fz_font*, int, fz_matrix *, const fz_irect *scissor, int aa);
void fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gid, const fz_matrix *trm, void *gstate, int nested_depth, fz_default_colorspaces *def_cs);
void fz_prepare_t3_glyph(fz_context *ctx, fz_font *font, int gid, int nested_depth);
void fz_dump_glyph_cache_stats(fz_context *ctx);
/**
Create a pixmap containing a rendered glyph.
Lookup gid from font, clip it with scissor, and rendering it
with aa bits of antialiasing into a new pixmap.
The caller takes ownership of the pixmap and so must free it.
Note: This function is no longer used for normal rendering
operations, and is kept around just because we use it in the
app. It should be considered "at risk" of removal from the API.
*/
fz_pixmap *fz_render_glyph_pixmap(fz_context *ctx, fz_font *font, int gid, fz_matrix *ctm, const fz_irect *scissor, int aa);
/**
Nasty PDF interpreter specific hernia, required to allow the
interpreter to replay glyphs from a type3 font directly into
the target device.
This is only used in exceptional circumstances (such as type3
glyphs that inherit current graphics state, or nested type3
glyphs).
*/
void fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gid, fz_matrix trm, void *gstate, fz_default_colorspaces *def_cs);
/**
Force a type3 font to cache the displaylist for a given glyph
id.
This caching can involve reading the underlying file, so must
happen ahead of time, so we aren't suddenly forced to read the
file while playing a displaylist back.
*/
void fz_prepare_t3_glyph(fz_context *ctx, fz_font *font, int gid);
/**
Dump debug statistics for the glyph cache.
*/
void fz_dump_glyph_cache_stats(fz_context *ctx, fz_output *out);
/**
Perform subpixel quantisation and adjustment on a glyph matrix.
ctm: On entry, the desired 'ideal' transformation for a glyph.
On exit, adjusted to a (very similar) transformation quantised
for subpixel caching.
subpix_ctm: Initialised by the routine to the transform that
should be used to render the glyph.
qe, qf: which subpixel position we quantised to.
Returns: the size of the glyph.
Note: This is currently only exposed for use in our app. It
should be considered "at risk" of removal from the API.
*/
float fz_subpixel_adjust(fz_context *ctx, fz_matrix *ctm, fz_matrix *subpix_ctm, unsigned char *qe, unsigned char *qf);
#endif

140
include/mupdf/fitz/glyph.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_GLYPH_H
#define MUPDF_FITZ_GLYPH_H
@@ -5,71 +27,33 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/store.h"
#include "mupdf/fitz/colorspace.h"
#include "mupdf/fitz/font.h"
#include "mupdf/fitz/path.h"
/*
/**
Glyphs represent a run length encoded set of pixels for a 2
dimensional region of a plane.
*/
typedef struct fz_glyph_s fz_glyph;
typedef struct fz_glyph fz_glyph;
/*
fz_glyph_bbox: Return the bounding box for a glyph.
/**
Return the bounding box of the glyph in pixels.
*/
fz_irect *fz_glyph_bbox(fz_context *ctx, fz_glyph *glyph, fz_irect *bbox);
fz_irect fz_glyph_bbox(fz_context *ctx, fz_glyph *glyph);
fz_irect fz_glyph_bbox_no_ctx(fz_glyph *src);
/*
fz_glyph_width: Return the width of the glyph in pixels.
/**
Return the width of the glyph in pixels.
*/
int fz_glyph_width(fz_context *ctx, fz_glyph *glyph);
/*
fz_glyph_height: Return the height of the glyph in pixels.
/**
Return the height of the glyph in pixels.
*/
int fz_glyph_height(fz_context *ctx, fz_glyph *glyph);
/*
fz_new_glyph_from_pixmap: Create a new glyph from a pixmap
Returns a pointer to the new glyph. Throws exception on failure to
allocate.
*/
fz_glyph *fz_new_glyph_from_pixmap(fz_context *ctx, fz_pixmap *pix);
/*
fz_new_glyph_from_8bpp_data: Create a new glyph from 8bpp data
x, y: X and Y position for the glyph
w, h: Width and Height for the glyph
sp: Source Pointer to data
span: Increment from line to line of data
Returns a pointer to the new glyph. Throws exception on failure to
allocate.
*/
fz_glyph *fz_new_glyph_from_8bpp_data(fz_context *ctx, int x, int y, int w, int h, unsigned char *sp, int span);
/*
fz_new_glyph_from_1bpp_data: Create a new glyph from 1bpp data
x, y: X and Y position for the glyph
w, h: Width and Height for the glyph
sp: Source Pointer to data
span: Increment from line to line of data
Returns a pointer to the new glyph. Throws exception on failure to
allocate.
*/
fz_glyph *fz_new_glyph_from_1bpp_data(fz_context *ctx, int x, int y, int w, int h, unsigned char *sp, int span);
/*
fz_keep_glyph: Take a reference to a glyph.
/**
Take a reference to a glyph.
pix: The glyph to increment the reference for.
@@ -77,57 +61,21 @@ fz_glyph *fz_new_glyph_from_1bpp_data(fz_context *ctx, int x, int y, int w, int
*/
fz_glyph *fz_keep_glyph(fz_context *ctx, fz_glyph *pix);
/*
fz_drop_glyph: Drop a reference and free a glyph.
/**
Drop a reference and free a glyph.
Decrement the reference count for the glyph. When no
references remain the glyph will be freed.
*/
void fz_drop_glyph(fz_context *ctx, fz_glyph *pix);
/*
Glyphs represent a set of pixels for a 2 dimensional region of a
plane.
/**
Look a glyph up from a font, and return the outline of the
glyph using the given transform.
x, y: The minimum x and y coord of the region in pixels.
w, h: The width and height of the region in pixels.
samples: The sample data. The sample data is in a compressed format
designed to give reasonable compression, and to be fast to plot from.
The first sizeof(int) * h bytes of the table, when interpreted as
ints gives the offset within the data block of that lines data. An
offset of 0 indicates that that line is completely blank.
The data for individual lines is a sequence of bytes:
00000000 = end of lines data
LLLLLL00 = extend the length given in the next run by the 6 L bits
given here.
LLLLLL01 = A run of length L+1 transparent pixels.
LLLLLE10 = A run of length L+1 solid pixels. If E then this is the
last run on this line.
LLLLLE11 = A run of length L+1 intermediate pixels followed by L+1
bytes of literal pixel data. If E then this is the last run
on this line.
The caller owns the returned path, and so is responsible for
ensuring that it eventually gets dropped.
*/
struct fz_glyph_s
{
fz_storable storable;
int x, y, w, h;
fz_pixmap *pixmap;
size_t size;
unsigned char data[1];
};
fz_irect *fz_glyph_bbox_no_ctx(fz_glyph *src, fz_irect *bbox);
static inline size_t
fz_glyph_size(fz_context *ctx, fz_glyph *glyph)
{
if (glyph == NULL)
return 0;
return sizeof(fz_glyph) + glyph->size + fz_pixmap_size(ctx, glyph->pixmap);
}
fz_path *fz_outline_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix ctm);
#endif

120
include/mupdf/fitz/hash.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_HASH_H
#define MUPDF_FITZ_HASH_H
@@ -5,28 +27,100 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
/*
* Generic hash-table with fixed-length keys.
*
* The keys and values are NOT reference counted by the hash table.
* Callers are responsible for taking care the reference counts are correct.
* Inserting a duplicate entry will NOT overwrite the old value, and will
* return the old value.
*
* The drop_val callback function is only used to release values when the hash table
* is destroyed.
*/
#define FZ_HASH_TABLE_KEY_LENGTH 48
typedef struct fz_hash_table_s fz_hash_table;
/**
Generic hash-table with fixed-length keys.
The keys and values are NOT reference counted by the hash table.
Callers are responsible for taking care the reference counts are
correct. Inserting a duplicate entry will NOT overwrite the old
value, and will return the old value.
The drop_val callback function is only used to release values
when the hash table is destroyed.
*/
typedef struct fz_hash_table fz_hash_table;
/**
Function type called when a hash table entry is dropped.
Only used when the entire hash table is dropped.
*/
typedef void (fz_hash_table_drop_fn)(fz_context *ctx, void *val);
typedef void (fz_hash_table_for_each_fn)(fz_context *ctx, void *state, void *key, int keylen, void *val);
/**
Create a new hash table.
initialsize: The initial size of the hashtable. The hashtable
may grow (double in size) if it starts to get crowded (80%
full).
keylen: byte length for each key.
lock: -1 for no lock, otherwise the FZ_LOCK to use to protect
this table.
drop_val: Function to use to destroy values on table drop.
*/
fz_hash_table *fz_new_hash_table(fz_context *ctx, int initialsize, int keylen, int lock, fz_hash_table_drop_fn *drop_val);
/**
Destroy the hash table.
Values are dropped using the drop function.
*/
void fz_drop_hash_table(fz_context *ctx, fz_hash_table *table);
/**
Search for a matching hash within the table, and return the
associated value.
*/
void *fz_hash_find(fz_context *ctx, fz_hash_table *table, const void *key);
/**
Insert a new key/value pair into the hash table.
If an existing entry with the same key is found, no change is
made to the hash table, and a pointer to the existing value is
returned.
If no existing entry with the same key is found, ownership of
val passes in, key is copied, and NULL is returned.
*/
void *fz_hash_insert(fz_context *ctx, fz_hash_table *table, const void *key, void *val);
/**
Remove the entry for a given key.
The value is NOT freed, so the caller is expected to take care
of this.
*/
void fz_hash_remove(fz_context *ctx, fz_hash_table *table, const void *key);
/**
Callback function called on each key/value pair in the hash
table, when fz_hash_for_each is run.
*/
typedef void (fz_hash_table_for_each_fn)(fz_context *ctx, void *state, void *key, int keylen, void *val);
/**
Iterate over the entries in a hash table.
*/
void fz_hash_for_each(fz_context *ctx, fz_hash_table *table, void *state, fz_hash_table_for_each_fn *callback);
/**
Callback function called on each key/value pair in the hash
table, when fz_hash_filter is run to remove entries where the
callback returns true.
*/
typedef int (fz_hash_table_filter_fn)(fz_context *ctx, void *state, void *key, int keylen, void *val);
/**
Iterate over the entries in a hash table, removing all the ones where callback returns true.
Does NOT free the value of the entry, so the caller is expected to take care of this.
*/
void fz_hash_filter(fz_context *ctx, fz_hash_table *table, void *state, fz_hash_table_filter_fn *callback);
#endif

163
include/mupdf/fitz/heap-imp.h Normal file
View File

@@ -0,0 +1,163 @@
// Copyright (C) 2004-2022 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.
/* This file has preprocessor magic in it to instantiate both
* protoypes and implementations for heap sorting structures
* of various different types. Effectively, it's templating for
* C.
*
* If you are including this file directly without intending to
* be instantiating a new set of heap sort functions, you are
* doing the wrong thing.
*/
#ifndef MUPDF_FITZ_HEAP_I_KNOW_WHAT_IM_DOING
#error Do not include heap-imp.h unless you know what youre doing
#endif
#define HEAP_XCAT(A,B) A##B
#define HEAP_CAT(A,B) HEAP_XCAT(A,B)
#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
typedef struct
{
int max;
int len;
HEAP_CONTAINER_TYPE *heap;
} HEAP_TYPE_NAME;
#endif
void HEAP_CAT(HEAP_TYPE_NAME,_insert)(fz_context *ctx, HEAP_TYPE_NAME *heap, HEAP_CONTAINER_TYPE v
#ifndef HEAP_CMP
, int (*HEAP_CMP)(HEAP_CONTAINER_TYPE *a, HEAP_CONTAINER_TYPE *b)
#endif
)
#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
;
#else
{
int i;
HEAP_CONTAINER_TYPE *h;
if (heap->max == heap->len)
{
int m = heap->max * 2;
if (m == 0)
m = 32;
heap->heap = (HEAP_CONTAINER_TYPE *)fz_realloc(ctx, heap->heap, sizeof(*heap->heap) * m);
heap->max = m;
}
h = heap->heap;
/* Insert it into the heap. Consider inserting at position i, and
* then 'heapify' back. We can delay the actual insertion to the
* end of the process. */
i = heap->len++;
while (i != 0)
{
int parent_idx = (i-1)/2;
HEAP_CONTAINER_TYPE *parent_val = &h[parent_idx];
if (HEAP_CMP(parent_val, &v) > 0)
break;
h[i] = h[parent_idx];
i = parent_idx;
}
h[i] = v;
}
#endif
void HEAP_CAT(HEAP_TYPE_NAME,_sort)(fz_context *ctx, HEAP_TYPE_NAME *heap
#ifndef HEAP_CMP
, int (*HEAP_CMP)(HEAP_CONTAINER_TYPE *a, HEAP_CONTAINER_TYPE *b)
#endif
)
#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
;
#else
{
int j;
HEAP_CONTAINER_TYPE *h = heap->heap;
/* elements j to len are always sorted. 0 to j are always a valid heap. Gradually move j to 0. */
for (j = heap->len-1; j > 0; j--)
{
int k;
HEAP_CONTAINER_TYPE val;
/* Swap max element with j. Invariant valid for next value to j. */
val = h[j];
h[j] = h[0];
/* Now reform the heap. 0 to k is a valid heap. */
k = 0;
while (1)
{
int kid = k*2+1;
if (kid >= j)
break;
if (kid+1 < j && (HEAP_CMP(&h[kid+1], &h[kid])) > 0)
kid++;
if ((HEAP_CMP(&val, &h[kid])) > 0)
break;
h[k] = h[kid];
k = kid;
}
h[k] = val;
}
}
#endif
void HEAP_CAT(HEAP_TYPE_NAME,_uniq)(fz_context *ctx, HEAP_TYPE_NAME *heap
#ifndef HEAP_CMP
, int (*HEAP_CMP)(HEAP_CONTAINER_TYPE *a, HEAP_CONTAINER_TYPE *b)
#endif
)
#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
;
#else
{
int n = heap->len;
int i, j = 0;
HEAP_CONTAINER_TYPE *h = heap->heap;
if (n == 0)
return;
j = 0;
for (i = 1; i < n; i++)
{
if (HEAP_CMP(&h[j], &h[i]) == 0)
continue;
j++;
if (i != j)
h[j] = h[i];
}
heap->len = j+1;
}
#endif
#undef HEAP_CONTAINER_TYPE
#undef HEAP_TYPE_NAME
#undef HEAP_CMP
#undef HEAP_XCAT
#undef HEAP_CAT

140
include/mupdf/fitz/heap.h Normal file
View File

@@ -0,0 +1,140 @@
// Copyright (C) 2004-2022 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.
/* This file has preprocessor magic in it to instantiate both
* protoypes and implementations for heap sorting structures
* of various different types. Effectively, it's templating for
* C.
*
* If you are including this file directly without intending to
* be instantiating a new set of heap sort functions, you are
* doing the wrong thing.
*/
/* This header file declares some useful heap functions. (Heap
* as in heap sort, not as in memory heap). It uses some
* clever (read "hacky") multiple inclusion techniques to allow
* us to generate multiple different versions of this code.
* This is kinda like 'templating' in C++, but without language
* support.
*/
/* For every instance of this code, we end up a heap structure:
*
* typedef struct
* {
* int max;
* int len;
* <TYPE> *heap;
* } fz_<TYPE>_heap;
*
* This can be created and initialised on the stack in user code using:
*
* fz_<TYPE>_heap heap = { 0 };
*
* and some functions.
*
* When <TYPE> is a simple int (or float or similar), the ordering required is
* obvious, and so the functions are simple (Form 1):
*
* First some to insert elements into the heap:
*
* void fz_<TYPE>_heap_insert(fz_context *ctx, fz_<TYPE>_heap *heap, <TYPE> v);
*
* Once all the elements have been inserted, the heap can be sorted:
*
* void fz_<TYPE>_heap_sort(fz_context *ctx, fz_<TYPE>_heap *heap);
*
* Once sorted, repeated elements can be removed:
*
* void fz_<TYPE>_heap_uniq(fz_context *ctx, fz_<TYPE>_heap *heap);
*
*
* For more complex TYPEs (such as pointers) the ordering may not be implicit within the <TYPE>,
* but rather depends upon the data found by dereferencing those pointers. For such types,
* the functions are modified with a <COMPARE> function, of the form used by qsort etc:
*
* int <COMPARE>(<TYPE>x, <TYPE>y) that returns 0 for x == y, +ve for x > y, and -ve for x < y.
*
* The functions are modified thus (Form 2):
*
* void fz_<TYPE>_heap_insert(fz_context *ctx, fz_<TYPE>_heap *heap, <TYPE> v, <COMPARE> t);
* void fz_<TYPE>_heap_sort(fz_context *ctx, fz_<TYPE>_heap *heap, <COMPARE> t);
* void fz_<TYPE>_heap_uniq(fz_context *ctx, fz_<TYPE>_heap *heap, <COMPARE> t);
*
* Currently, we define:
*
* fz_int_heap Operates on 'int' values. Form 1.
* fz_ptr_heap Operates on 'void *' values. Form 2.
* fz_int2_heap Operates on 'typedef struct { int a; int b} fz_int2' values,
* with the sort/uniq being done based on 'a' alone. Form 1.
* fz_intptr_heap Operates on 'typedef struct { int a; void *b} fz_intptr' values,
* with the sort/uniq being done based on 'a' alone. Form 1.
*/
/* Everything after this point is preprocessor magic. Ignore it, and just read the above
* unless you are wanting to instantiate a new set of functions. */
#ifndef MUPDF_FITZ_HEAP_H
#define MUPDF_FITZ_HEAP_H
#define MUPDF_FITZ_HEAP_I_KNOW_WHAT_IM_DOING
/* Instantiate fz_int_heap */
#define HEAP_TYPE_NAME fz_int_heap
#define HEAP_CONTAINER_TYPE int
#define HEAP_CMP(a,b) ((*a) - (*b))
#include "mupdf/fitz/heap-imp.h"
/* Instantiate fz_ptr_heap */
#define HEAP_TYPE_NAME fz_ptr_heap
#define HEAP_CONTAINER_TYPE void *
#include "mupdf/fitz/heap-imp.h"
/* Instantiate fz_int2_heap */
#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
typedef struct
{
int a;
int b;
} fz_int2;
#endif
#define HEAP_TYPE_NAME fz_int2_heap
#define HEAP_CMP(A,B) (((A)->a) - ((B)->a))
#define HEAP_CONTAINER_TYPE fz_int2
#include "mupdf/fitz/heap-imp.h"
/* Instantiate fz_intptr_heap */
#ifndef MUPDF_FITZ_HEAP_IMPLEMENT
typedef struct
{
int a;
int b;
} fz_intptr;
#endif
#define HEAP_TYPE_NAME fz_intptr_heap
#define HEAP_CONTAINER_TYPE fz_intptr
#define HEAP_CMP(A,B) (((A)->a) - ((B)->a))
#include "mupdf/fitz/heap-imp.h"
#endif /* MUPDF_FITZ_HEAP_H */

298
include/mupdf/fitz/image.h
View File

@@ -1,40 +1,60 @@
// Copyright (C) 2004-2023 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/colorspace.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/stream.h"
#include "mupdf/fitz/compressed-buffer.h"
/*
/**
Images are storable objects from which we can obtain fz_pixmaps.
These may be implemented as simple wrappers around a pixmap, or as
more complex things that decode at different subsample settings on
demand.
These may be implemented as simple wrappers around a pixmap, or
as more complex things that decode at different subsample
settings on demand.
*/
typedef struct fz_image_s fz_image;
typedef struct fz_compressed_image_s fz_compressed_image;
typedef struct fz_pixmap_image_s fz_pixmap_image;
typedef struct fz_image fz_image;
typedef struct fz_compressed_image fz_compressed_image;
typedef struct fz_pixmap_image fz_pixmap_image;
/*
fz_get_pixmap_from_image: Called to get a handle to a pixmap from an image.
/**
Called to get a handle to a pixmap from an image.
image: The image to retrieve a pixmap from.
color_params: The color parameters (or NULL for defaults).
subarea: The subarea of the image that we actually care about
(or NULL to indicate the whole image).
subarea: The subarea of the image that we actually care about (or NULL
to indicate the whole image).
trans: Optional, unless subarea is given. If given, then on entry this is
the transform that will be applied to the complete image. It should be
updated on exit to the transform to apply to the given subarea of the
image. This is used to calculate the desired width/height for subsampling.
ctm: Optional, unless subarea is given. If given, then on
entry this is the transform that will be applied to the complete
image. It should be updated on exit to the transform to apply to
the given subarea of the image. This is used to calculate the
desired width/height for subsampling.
w: If non-NULL, a pointer to an int to be updated on exit to the
width (in pixels) that the scaled output will cover.
@@ -42,38 +62,58 @@ typedef struct fz_pixmap_image_s fz_pixmap_image;
h: If non-NULL, a pointer to an int to be updated on exit to the
height (in pixels) that the scaled output will cover.
Returns a non NULL pixmap pointer. May throw exceptions.
Returns a non NULL kept pixmap pointer. May throw exceptions.
*/
fz_pixmap *fz_get_pixmap_from_image(fz_context *ctx, fz_image *image, const fz_irect *subarea, fz_matrix *trans, int *w, int *h);
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_drop_image: Drop a reference to an image.
image: The image to drop a reference to.
/**
Calls fz_get_pixmap_from_image() with ctm, subarea, w and h all set to NULL.
*/
void fz_drop_image(fz_context *ctx, fz_image *image);
fz_pixmap *fz_get_unscaled_pixmap_from_image(fz_context *ctx, fz_image *image);
/*
fz_keep_image: Increment the reference count of an image.
/**
Increment the (normal) reference count for an image. Returns the
same pointer.
image: The image to take a reference to.
Returns a pointer to the image.
Never throws exceptions.
*/
fz_image *fz_keep_image(fz_context *ctx, fz_image *image);
/**
Decrement the (normal) reference count for an image. When the
total (normal + key) reference count reaches zero, the image and
its resources are freed.
Never throws exceptions.
*/
void fz_drop_image(fz_context *ctx, fz_image *image);
/**
Increment the store key reference for an image. Returns the same
pointer. (This is the count of references for an image held by
keys in the image store).
Never throws exceptions.
*/
fz_image *fz_keep_image_store_key(fz_context *ctx, fz_image *image);
/**
Decrement the store key reference count for an image. When the
total (normal + key) reference count reaches zero, the image and
its resources are freed.
Never throws exceptions.
*/
void fz_drop_image_store_key(fz_context *ctx, fz_image *image);
/*
fz_drop_image_fn: Function type to destroy an images data
/**
Function type to destroy an images data
when it's reference count reaches zero.
*/
typedef void (fz_drop_image_fn)(fz_context *ctx, fz_image *image);
/*
fz_get_pixmap_fn: Function type to get a decoded pixmap
for an image.
/**
Function type to get a decoded pixmap for an image.
im: The image to decode.
@@ -92,20 +132,21 @@ typedef void (fz_drop_image_fn)(fz_context *ctx, fz_image *image);
knows what remains to be done.
Returns a reference to a decoded pixmap that satisfies the
requirements of the request.
requirements of the request. The caller owns the returned
reference.
*/
typedef fz_pixmap *(fz_image_get_pixmap_fn)(fz_context *ctx, fz_image *im, fz_irect *subarea, int w, int h, int *l2factor);
/*
fz_image_get_size_fn: Function type to get the given storage
/**
Function type to get the given storage
size for an image.
Returns the size in bytes used for a given image.
*/
typedef size_t (fz_image_get_size_fn)(fz_context *, fz_image *);
/*
fz_new_image_of_size: Internal function to make a new fz_image structure
/**
Internal function to make a new fz_image structure
for a derived class.
w,h: Width and height of the created image.
@@ -127,7 +168,7 @@ typedef size_t (fz_image_get_size_fn)(fz_context *, fz_image *);
decode array is [0 1] (repeated n times, for n color components).
colorkey: NULL, or a pointer to a colorkey array. The default
colorkey array is [0 255] (repeatd n times, for n color
colorkey array is [0 255] (repeated n times, for n color
components).
mask: NULL, or another image to use as a mask for this one.
@@ -158,10 +199,10 @@ fz_image *fz_new_image_of_size(fz_context *ctx,
int yres,
int interpolate,
int imagemask,
float *decode,
int *colorkey,
const float *decode,
const int *colorkey,
fz_image *mask,
int size,
size_t size,
fz_image_get_pixmap_fn *get_pixmap,
fz_image_get_size_fn *get_size,
fz_drop_image_fn *drop);
@@ -169,8 +210,8 @@ fz_image *fz_new_image_of_size(fz_context *ctx,
#define fz_new_derived_image(CTX,W,H,B,CS,X,Y,I,IM,D,C,M,T,G,S,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,Z),#T))
/*
fz_new_image_from_compressed_buffer: Create an image based on
/**
Create an image based on
the data in the supplied compressed buffer.
w,h: Width and height of the created image.
@@ -185,14 +226,14 @@ fz_image *fz_new_image_of_size(fz_context *ctx,
interpolate: 1 if interpolation should be used when decoding
this image, 0 otherwise.
imagemask: 1 if this is an imagemask (i.e. transparent), 0
otherwise.
imagemask: 1 if this is an imagemask (i.e. transparency bitmap
mask), 0 otherwise.
decode: NULL, or a pointer to to a decode array. The default
decode array is [0 1] (repeated n times, for n color components).
colorkey: NULL, or a pointer to a colorkey array. The default
colorkey array is [0 255] (repeatd n times, for n color
colorkey array is [0 255] (repeated n times, for n color
components).
buffer: Buffer of compressed data and compression parameters.
@@ -202,10 +243,10 @@ fz_image *fz_new_image_of_size(fz_context *ctx,
A new reference is taken to this image. Supplying a masked
image as a mask to another image is illegal!
*/
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, float *decode, int *colorkey, fz_compressed_buffer *buffer, fz_image *mask);
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_new_image_from_pixmap: Create an image from the given
/**
Create an image from the given
pixmap.
pixmap: The pixmap to base the image upon. A new reference
@@ -217,32 +258,76 @@ fz_image *fz_new_image_from_compressed_buffer(fz_context *ctx, int w, int h, int
*/
fz_image *fz_new_image_from_pixmap(fz_context *ctx, fz_pixmap *pixmap, fz_image *mask);
/*
fz_new_image_from_buffer: Create a new image from a
/**
Create a new image from a
buffer of data, inferring its type from the format
of the data.
*/
fz_image *fz_new_image_from_buffer(fz_context *ctx, fz_buffer *buffer);
/*
fz_image_from_file: Create a new image from the contents
/**
Create a new image from the contents
of a file, inferring its type from the format of the
data.
*/
fz_image *fz_new_image_from_file(fz_context *ctx, const char *path);
/**
Internal destructor exposed for fz_store integration.
*/
void fz_drop_image_imp(fz_context *ctx, fz_storable *image);
/**
Internal destructor for the base image class members.
Exposed to allow derived image classes to be written.
*/
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);
unsigned char *fz_indexed_colorspace_palette(fz_context *ctx, fz_colorspace *cs, int *high);
fz_pixmap *fz_expand_indexed_pixmap(fz_context *ctx, const fz_pixmap *src, int alpha);
/**
Decode a subarea of a compressed image. l2factor is the amount
of subsampling inbuilt to the stream (i.e. performed by the
decoder). If non NULL, l2extra is the extra amount of
subsampling that should be performed by this routine. This will
be updated on exit to the amount of subsampling that is still
required to be done.
Returns a kept reference.
*/
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);
/**
Convert pixmap from indexed to base colorspace.
This creates a new bitmap containing the converted pixmap data.
*/
fz_pixmap *fz_convert_indexed_pixmap_to_base(fz_context *ctx, const fz_pixmap *src);
/**
Convert pixmap from DeviceN/Separation to base colorspace.
This creates a new bitmap containing the converted pixmap data.
*/
fz_pixmap *fz_convert_separation_pixmap_to_base(fz_context *ctx, const fz_pixmap *src);
/**
Return the size of the storage used by an image.
*/
size_t fz_image_size(fz_context *ctx, fz_image *im);
/*
/**
Return the type of a compressed image.
Any non-compressed image will have the type returned as UNKNOWN.
*/
int fz_compressed_image_type(fz_context *ctx, fz_image *image);
/**
Structure is public to allow other structures to
be derived from it. Do not access members directly.
*/
struct fz_image_s
struct fz_image
{
fz_key_storable key_storable;
int w, h;
@@ -252,9 +337,9 @@ struct fz_image_s
unsigned int interpolate:1;
unsigned int use_colorkey:1;
unsigned int use_decode:1;
unsigned int invert_cmyk_jpeg:1;
unsigned int decoded:1;
unsigned int scalable: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 */
@@ -266,29 +351,8 @@ struct fz_image_s
float decode[FZ_MAX_COLORS * 2];
};
fz_pixmap *fz_load_jpeg(fz_context *ctx, const unsigned char *data, size_t size);
fz_pixmap *fz_load_jpx(fz_context *ctx, const unsigned char *data, size_t size, fz_colorspace *cs);
fz_pixmap *fz_load_png(fz_context *ctx, const unsigned char *data, size_t size);
fz_pixmap *fz_load_tiff(fz_context *ctx, const unsigned char *data, size_t size);
fz_pixmap *fz_load_jxr(fz_context *ctx, const unsigned char *data, size_t size);
fz_pixmap *fz_load_gif(fz_context *ctx, const unsigned char *data, size_t size);
fz_pixmap *fz_load_bmp(fz_context *ctx, const unsigned char *data, size_t size);
fz_pixmap *fz_load_pnm(fz_context *ctx, const unsigned char *data, size_t size);
void fz_load_jpeg_info(fz_context *ctx, const unsigned char *data, size_t size, int *w, int *h, int *xres, int *yres, fz_colorspace **cspace);
void fz_load_jpx_info(fz_context *ctx, const unsigned char *data, size_t size, int *w, int *h, int *xres, int *yres, fz_colorspace **cspace);
void fz_load_png_info(fz_context *ctx, const unsigned char *data, size_t size, int *w, int *h, int *xres, int *yres, fz_colorspace **cspace);
void fz_load_tiff_info(fz_context *ctx, const unsigned char *data, size_t size, int *w, int *h, int *xres, int *yres, fz_colorspace **cspace);
void fz_load_jxr_info(fz_context *ctx, const unsigned char *data, size_t size, int *w, int *h, int *xres, int *yres, fz_colorspace **cspace);
void fz_load_gif_info(fz_context *ctx, const unsigned char *data, size_t size, int *w, int *h, int *xres, int *yres, fz_colorspace **cspace);
void fz_load_bmp_info(fz_context *ctx, const unsigned char *data, size_t size, int *w, int *h, int *xres, int *yres, fz_colorspace **cspace);
void fz_load_pnm_info(fz_context *ctx, const unsigned char *data, size_t size, int *w, int *h, int *xres, int *yres, fz_colorspace **cspace);
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);
/*
fz_image_resolution: Request the natural resolution
/**
Request the natural resolution
of an image.
xres, yres: Pointers to ints to be updated with the
@@ -297,12 +361,35 @@ fz_pixmap *fz_load_tiff_subimage(fz_context *ctx, const unsigned char *buf, size
*/
void fz_image_resolution(fz_image *image, int *xres, int *yres);
fz_pixmap *fz_compressed_image_tile(fz_context *ctx, fz_compressed_image *cimg);
void fz_set_compressed_image_tile(fz_context *ctx, fz_compressed_image *cimg, fz_pixmap *pix);
/**
Request the natural orientation of an image.
/*
fz_compressed_image_buffer: Retrieve the underlying compressed
data for an image.
This is for images (such as JPEG) that can contain internal
specifications of rotation/flips. This is ignored by all the
internal decode/rendering routines, but can be used by callers
(such as the image document handler) to respect such
specifications.
The values used by MuPDF are as follows, with the equivalent
Exif specifications given for information:
0: Undefined
1: 0 degree ccw rotation. (Exif = 1)
2: 90 degree ccw rotation. (Exif = 8)
3: 180 degree ccw rotation. (Exif = 3)
4: 270 degree ccw rotation. (Exif = 6)
5: flip on X. (Exif = 2)
6: flip on X, then rotate ccw by 90 degrees. (Exif = 5)
7: flip on X, then rotate ccw by 180 degrees. (Exif = 4)
8: flip on X, then rotate ccw by 270 degrees. (Exif = 7)
*/
uint8_t fz_image_orientation(fz_context *ctx, fz_image *image);
fz_matrix
fz_image_orientation_matrix(fz_context *ctx, fz_image *image);
/**
Retrieve the underlying compressed data for an image.
Returns a pointer to the underlying data buffer for an image,
or NULL if this image is not based upon a compressed data
@@ -314,9 +401,8 @@ void fz_set_compressed_image_tile(fz_context *ctx, fz_compressed_image *cimg, fz
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_image_tile: Retried the underlying fz_pixmap
for an image.
/**
Retrieve the underlying fz_pixmap for an image.
Returns a pointer to the underlying fz_pixmap for an image,
or NULL if this image is not based upon an fz_pixmap.
@@ -328,4 +414,30 @@ void fz_set_compressed_image_buffer(fz_context *ctx, fz_compressed_image *cimg,
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. */
/**
Exposed for PDF.
*/
fz_pixmap *fz_load_jpx(fz_context *ctx, const unsigned char *data, size_t size, fz_colorspace *cs);
/**
Exposed because compression and decompression need to share this.
*/
void opj_lock(fz_context *ctx);
void opj_unlock(fz_context *ctx);
/**
Exposed for CBZ.
*/
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

109
include/mupdf/fitz/link.h
View File

@@ -1,17 +1,39 @@
// Copyright (C) 2004-2022 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_LINK_H
#define MUPDF_FITZ_LINK_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/types.h"
/*
Links
*/
typedef struct fz_link fz_link;
typedef void (fz_link_set_rect_fn)(fz_context *ctx, fz_link *link, fz_rect rect);
typedef void (fz_link_set_uri_fn)(fz_context *ctx, fz_link *link, const char *uri);
typedef void (fz_link_drop_link_fn)(fz_context *ctx, fz_link *link);
typedef struct fz_link_s fz_link;
/*
/**
fz_link is a list of interactive links on a page.
There is no relation between the order of the links in the
@@ -30,26 +52,79 @@ typedef struct fz_link_s fz_link;
next: A pointer to the next link on the same page.
*/
struct fz_link_s
typedef struct fz_link
{
int refs;
fz_link *next;
struct fz_link *next;
fz_rect rect;
void *doc;
char *uri;
};
fz_link_set_rect_fn *set_rect_fn;
fz_link_set_uri_fn *set_uri_fn;
fz_link_drop_link_fn *drop;
} fz_link;
fz_link *fz_new_link(fz_context *ctx, const fz_rect *bbox, void *doc, const char *uri);
typedef enum
{
FZ_LINK_DEST_FIT,
FZ_LINK_DEST_FIT_B,
FZ_LINK_DEST_FIT_H,
FZ_LINK_DEST_FIT_BH,
FZ_LINK_DEST_FIT_V,
FZ_LINK_DEST_FIT_BV,
FZ_LINK_DEST_FIT_R,
FZ_LINK_DEST_XYZ
} fz_link_dest_type;
typedef struct
{
fz_location loc;
fz_link_dest_type type;
float x, y, w, h, zoom;
} fz_link_dest;
fz_link_dest fz_make_link_dest_none(void);
fz_link_dest fz_make_link_dest_xyz(int chapter, int page, float x, float y, float z);
/**
Create a new link record.
next is set to NULL with the expectation that the caller will
handle the linked list setup. Internal function.
Different document types will be implemented by deriving from
fz_link. This macro allocates such derived structures, and
initialises the base sections.
*/
fz_link *fz_new_link_of_size(fz_context *ctx, int size, fz_rect rect, const char *uri);
#define fz_new_derived_link(CTX,TYPE,RECT,URI) \
((TYPE *)Memento_label(fz_new_link_of_size(CTX,sizeof(TYPE),RECT,URI),#TYPE))
/**
Increment the reference count for a link. The same pointer is
returned.
Never throws exceptions.
*/
fz_link *fz_keep_link(fz_context *ctx, fz_link *link);
/*
Checks if a link destination is external or internal.
*/
int fz_is_external_link(fz_context *ctx, const char *uri);
/**
Decrement the reference count for a link. When the reference
count reaches zero, the link is destroyed.
/*
fz_drop_link: Drop and free a list of links.
When a link is freed, the reference for any linked link (next)
is dropped too, thus an entire linked list of fz_link's can be
freed by just dropping the head.
*/
void fz_drop_link(fz_context *ctx, fz_link *link);
/**
Query whether a link is external to a document (determined by
uri containing a ':', intended to match with '://' which
separates the scheme from the scheme specific parts in URIs).
*/
int fz_is_external_link(fz_context *ctx, const char *uri);
void fz_set_link_rect(fz_context *ctx, fz_link *link, fz_rect rect);
void fz_set_link_uri(fz_context *ctx, fz_link *link, const char *uri);
#endif

61
include/mupdf/fitz/log.h Normal file
View File

@@ -0,0 +1,61 @@
// Copyright (C) 2004-2021 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_LOG_H
#define MUPDF_FITZ_LOG_H
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
/**
The functions in this file offer simple logging abilities.
The default logfile is "fitz_log.txt". This can overridden by
defining an environment variable "FZ_LOG_FILE", or module
specific environment variables "FZ_LOG_FILE_<module>" (e.g.
"FZ_LOG_FILE_STORE").
Enable the following define(s) to enable built in debug logging
from within the appropriate module(s).
*/
/* #define ENABLE_STORE_LOGGING */
/**
Output a line to the log.
*/
void fz_log(fz_context *ctx, const char *fmt, ...);
/**
Output a line to the log for a given module.
*/
void fz_log_module(fz_context *ctx, const char *module, const char *fmt, ...);
/**
Internal function to actually do the opening of the logfile.
Caller should close/drop the output when finished with it.
*/
fz_output *fz_new_log_for_module(fz_context *ctx, const char *module);
#endif

195
include/mupdf/fitz/outline.h
View File

@@ -1,14 +1,94 @@
// Copyright (C) 2004-2021 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_OUTLINE_H
#define MUPDF_FITZ_OUTLINE_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/types.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/link.h"
#include "mupdf/fitz/output.h"
/* Outline */
/*
typedef struct {
char *title;
char *uri;
int is_open;
} fz_outline_item;
typedef struct fz_outline_iterator fz_outline_iterator;
/**
Call to get the current outline item.
Can return NULL. The item is only valid until the next call.
*/
fz_outline_item *fz_outline_iterator_item(fz_context *ctx, fz_outline_iterator *iter);
/**
Calls to move the iterator position.
A negative return value means we could not move as requested. Otherwise:
0 = the final position has a valid item.
1 = not a valid item, but we can insert an item here.
*/
int fz_outline_iterator_next(fz_context *ctx, fz_outline_iterator *iter);
int fz_outline_iterator_prev(fz_context *ctx, fz_outline_iterator *iter);
int fz_outline_iterator_up(fz_context *ctx, fz_outline_iterator *iter);
int fz_outline_iterator_down(fz_context *ctx, fz_outline_iterator *iter);
/**
Call to insert a new item BEFORE the current point.
Ownership of pointers are retained by the caller. The item data will be copied.
After an insert, we do not change where we are pointing.
The return code is the same as for next, it indicates the current iterator position.
*/
int fz_outline_iterator_insert(fz_context *ctx, fz_outline_iterator *iter, fz_outline_item *item);
/**
Delete the current item.
This implicitly moves us to the 'next' item, and the return code is as for fz_outline_iterator_next.
*/
int fz_outline_iterator_delete(fz_context *ctx, fz_outline_iterator *iter);
/**
Update the current item properties according to the given item.
*/
void fz_outline_iterator_update(fz_context *ctx, fz_outline_iterator *iter, fz_outline_item *item);
/**
Drop the current iterator.
*/
void fz_drop_outline_iterator(fz_context *ctx, fz_outline_iterator *iter);
/** Structure based API */
/**
fz_outline is a tree of the outline of a document (also known
as table of contents).
@@ -28,22 +108,121 @@
down: The outline items immediate children in the hierarchy.
May be NULL if no children exist.
*/
typedef struct fz_outline_s fz_outline;
struct fz_outline_s
typedef struct fz_outline
{
int refs;
char *title;
char *uri;
int page;
fz_location page;
float x, y;
fz_outline *next;
fz_outline *down;
struct fz_outline *next;
struct fz_outline *down;
int is_open;
};
} fz_outline;
/**
Create a new outline entry with zeroed fields for the caller
to fill in.
*/
fz_outline *fz_new_outline(fz_context *ctx);
/**
Increment the reference count. Returns the same pointer.
Never throws exceptions.
*/
fz_outline *fz_keep_outline(fz_context *ctx, fz_outline *outline);
/**
Decrements the reference count. When the reference point
reaches zero, the outline is freed.
When freed, it will drop linked outline entries (next and down)
too, thus a whole outline structure can be dropped by dropping
the top entry.
Never throws exceptions.
*/
void fz_drop_outline(fz_context *ctx, fz_outline *outline);
/**
Routine to implement the old Structure based API from an iterator.
*/
fz_outline *
fz_load_outline_from_iterator(fz_context *ctx, fz_outline_iterator *iter);
/**
Implementation details.
Of use to people coding new document handlers.
*/
/**
Function type for getting the current item.
Can return NULL. The item is only valid until the next call.
*/
typedef fz_outline_item *(fz_outline_iterator_item_fn)(fz_context *ctx, fz_outline_iterator *iter);
/**
Function types for moving the iterator position.
A negative return value means we could not move as requested. Otherwise:
0 = the final position has a valid item.
1 = not a valid item, but we can insert an item here.
*/
typedef int (fz_outline_iterator_next_fn)(fz_context *ctx, fz_outline_iterator *iter);
typedef int (fz_outline_iterator_prev_fn)(fz_context *ctx, fz_outline_iterator *iter);
typedef int (fz_outline_iterator_up_fn)(fz_context *ctx, fz_outline_iterator *iter);
typedef int (fz_outline_iterator_down_fn)(fz_context *ctx, fz_outline_iterator *iter);
/**
Function type for inserting a new item BEFORE the current point.
Ownership of pointers are retained by the caller. The item data will be copied.
After an insert, we implicitly do a next, so that a successive insert operation
would insert after the item inserted here. The return code is therefore as for next.
*/
typedef int (fz_outline_iterator_insert_fn)(fz_context *ctx, fz_outline_iterator *iter, fz_outline_item *item);
/**
Function type for deleting the current item.
This implicitly moves us to the 'next' item, and the return code is as for fz_outline_iterator_next.
*/
typedef int (fz_outline_iterator_delete_fn)(fz_context *ctx, fz_outline_iterator *iter);
/**
Function type for updating the current item properties according to the given item.
*/
typedef void (fz_outline_iterator_update_fn)(fz_context *ctx, fz_outline_iterator *iter, fz_outline_item *item);
/**
Function type for dropping the current iterator.
*/
typedef void (fz_outline_iterator_drop_fn)(fz_context *ctx, fz_outline_iterator *iter);
#define fz_new_derived_outline_iter(CTX, TYPE, DOC)\
((TYPE *)Memento_label(fz_new_outline_iterator_of_size(ctx,sizeof(TYPE),DOC),#TYPE))
fz_outline_iterator *fz_new_outline_iterator_of_size(fz_context *ctx, size_t size, fz_document *doc);
fz_outline_iterator *fz_outline_iterator_from_outline(fz_context *ctx, fz_outline *outline);
struct fz_outline_iterator {
/* Functions */
fz_outline_iterator_drop_fn *drop;
fz_outline_iterator_item_fn *item;
fz_outline_iterator_next_fn *next;
fz_outline_iterator_prev_fn *prev;
fz_outline_iterator_up_fn *up;
fz_outline_iterator_down_fn *down;
fz_outline_iterator_insert_fn *insert;
fz_outline_iterator_update_fn *update;
fz_outline_iterator_delete_fn *del;
/* Common state */
fz_document *doc;
};
#endif

88
include/mupdf/fitz/output-pcl.h
View File

@@ -1,88 +0,0 @@
#ifndef MUPDF_FITZ_OUTPUT_PCL_H
#define MUPDF_FITZ_OUTPUT_PCL_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/bitmap.h"
/*
PCL output
*/
typedef struct fz_pcl_options_s fz_pcl_options;
struct fz_pcl_options_s
{
/* Features of a particular printer */
int features;
const char *odd_page_init;
const char *even_page_init;
/* Options for this job */
int tumble;
int duplex_set;
int duplex;
int paper_size;
int manual_feed_set;
int manual_feed;
int media_position_set;
int media_position;
int orientation;
/* Updated as we move through the job */
int page_count;
};
/*
fz_pcl_preset: Initialize PCL option struct for a given preset.
Currently defined presets include:
generic Generic PCL printer
ljet4 HP DeskJet
dj500 HP DeskJet 500
fs600 Kyocera FS-600
lj HP LaserJet, HP LaserJet Plus
lj2 HP LaserJet IIp, HP LaserJet IId
lj3 HP LaserJet III
lj3d HP LaserJet IIId
lj4 HP LaserJet 4
lj4pl HP LaserJet 4 PL
lj4d HP LaserJet 4d
lp2563b HP 2563B line printer
oce9050 Oce 9050 Line printer
*/
void fz_pcl_preset(fz_context *ctx, fz_pcl_options *opts, const char *preset);
/*
fz_parse_pcl_options: Parse PCL options.
Currently defined options and values are as follows:
preset=X Either "generic" or one of the presets as for fz_pcl_preset.
spacing=0 No vertical spacing capability
spacing=1 PCL 3 spacing (<ESC>*p+<n>Y)
spacing=2 PCL 4 spacing (<ESC>*b<n>Y)
spacing=3 PCL 5 spacing (<ESC>*b<n>Y and clear seed row)
mode2 Disable/Enable mode 2 graphics compression
mode3 Disable/Enable mode 3 graphics compression
eog_reset End of graphics (<ESC>*rB) resets all parameters
has_duplex Duplex supported (<ESC>&l<duplex>S)
has_papersize Papersize setting supported (<ESC>&l<sizecode>A)
has_copies Number of copies supported (<ESC>&l<copies>X)
is_ljet4pjl Disable/Enable HP 4PJL model-specific output
is_oce9050 Disable/Enable Oce 9050 model-specific output
*/
fz_pcl_options *fz_parse_pcl_options(fz_context *ctx, fz_pcl_options *opts, const char *args);
fz_band_writer *fz_new_mono_pcl_band_writer(fz_context *ctx, fz_output *out, const fz_pcl_options *options);
void fz_write_bitmap_as_pcl(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pcl_options *pcl);
void fz_save_bitmap_as_pcl(fz_context *ctx, fz_bitmap *bitmap, char *filename, int append, const fz_pcl_options *pcl);
fz_band_writer *fz_new_color_pcl_band_writer(fz_context *ctx, fz_output *out, const fz_pcl_options *options);
void fz_write_pixmap_as_pcl(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pcl_options *pcl);
void fz_save_pixmap_as_pcl(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, const fz_pcl_options *pcl);
#endif

41
include/mupdf/fitz/output-pclm.h
View File

@@ -1,41 +0,0 @@
#ifndef MUPDF_FITZ_OUTPUT_PCLM_H
#define MUPDF_FITZ_OUTPUT_PCLM_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/bitmap.h"
/*
PCLm output
*/
typedef struct fz_pclm_options_s fz_pclm_options;
struct fz_pclm_options_s
{
int compress;
int strip_height;
/* Updated as we move through the job */
int page_count;
};
/*
fz_parse_pclm_options: Parse PCLm options.
Currently defined options and values are as follows:
compression=none: No compression
compression=flate: Flate compression
strip-height=n: Strip height (default 16)
*/
fz_pclm_options *fz_parse_pclm_options(fz_context *ctx, fz_pclm_options *opts, const char *args);
fz_band_writer *fz_new_pclm_band_writer(fz_context *ctx, fz_output *out, const fz_pclm_options *options);
fz_document_writer *fz_new_pclm_writer(fz_context *ctx, const char *path, const char *options);
void fz_write_pixmap_as_pclm(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pclm_options *options);
void fz_save_pixmap_as_pclm(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, const fz_pclm_options *options);
#endif

36
include/mupdf/fitz/output-png.h
View File

@@ -1,36 +0,0 @@
#ifndef MUPDF_FITZ_OUTPUT_PNG_H
#define MUPDF_FITZ_OUTPUT_PNG_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/bitmap.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/image.h"
/*
fz_save_pixmap_as_png: Save a pixmap as a PNG image file.
*/
void fz_save_pixmap_as_png(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/*
Write a pixmap to an output stream in PNG format.
*/
void fz_write_pixmap_as_png(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap);
/*
fz_new_png_band_writer: Obtain a fz_band_writer instance
for producing PNG output.
*/
fz_band_writer *fz_new_png_band_writer(fz_context *ctx, fz_output *out);
/*
Create a new buffer containing the image/pixmap in PNG format.
*/
fz_buffer *fz_new_buffer_from_image_as_png(fz_context *ctx, fz_image *image, const fz_color_params *color_params);
fz_buffer *fz_new_buffer_from_pixmap_as_png(fz_context *ctx, fz_pixmap *pixmap, const fz_color_params *color_params);
#endif

51
include/mupdf/fitz/output-pnm.h
View File

@@ -1,51 +0,0 @@
#ifndef MUPDF_FITZ_OUTPUT_PNM_H
#define MUPDF_FITZ_OUTPUT_PNM_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/bitmap.h"
/*
fz_save_pixmap_as_pnm: Save a pixmap as a PNM image file.
*/
void fz_save_pixmap_as_pnm(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
void fz_write_pixmap_as_pnm(fz_context *ctx, fz_output *out, fz_pixmap *pixmap);
fz_band_writer *fz_new_pnm_band_writer(fz_context *ctx, fz_output *out);
/*
fz_save_pixmap_as_pam: Save a pixmap as a PAM image file.
*/
void fz_save_pixmap_as_pam(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
void fz_write_pixmap_as_pam(fz_context *ctx, fz_output *out, fz_pixmap *pixmap);
fz_band_writer *fz_new_pam_band_writer(fz_context *ctx, fz_output *out);
/*
fz_save_bitmap_as_pbm: Save a bitmap as a PBM image file.
*/
void fz_save_bitmap_as_pbm(fz_context *ctx, fz_bitmap *bitmap, const char *filename);
void fz_write_bitmap_as_pbm(fz_context *ctx, fz_output *out, fz_bitmap *bitmap);
fz_band_writer *fz_new_pbm_band_writer(fz_context *ctx, fz_output *out);
void fz_save_pixmap_as_pbm(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/*
fz_save_bitmap_as_pkm: Save a 4bpp cmyk bitmap as a PAM image file.
*/
void fz_save_bitmap_as_pkm(fz_context *ctx, fz_bitmap *bitmap, const char *filename);
void fz_write_bitmap_as_pkm(fz_context *ctx, fz_output *out, fz_bitmap *bitmap);
fz_band_writer *fz_new_pkm_band_writer(fz_context *ctx, fz_output *out);
void fz_save_pixmap_as_pkm(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
#endif

23
include/mupdf/fitz/output-ps.h
View File

@@ -1,23 +0,0 @@
#ifndef MUPDF_FITZ_OUTPUT_PS_H
#define MUPDF_FITZ_OUTPUT_PS_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
/*
PS (image) output
*/
void fz_write_pixmap_as_ps(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap);
void fz_save_pixmap_as_ps(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append);
void fz_write_ps_file_header(fz_context *ctx, fz_output *out);
fz_band_writer *fz_new_ps_band_writer(fz_context *ctx, fz_output *out);
void fz_write_ps_file_trailer(fz_context *ctx, fz_output *out, int pages);
#endif

30
include/mupdf/fitz/output-psd.h
View File

@@ -1,30 +0,0 @@
#ifndef MUPDF_FITZ_OUTPUT_PSD_H
#define MUPDF_FITZ_OUTPUT_PSD_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/bitmap.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/image.h"
/*
fz_save_pixmap_as_psd: Save a pixmap as a PSD image file.
*/
void fz_save_pixmap_as_psd(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/*
Write a pixmap to an output stream in PSD format.
*/
void fz_write_pixmap_as_psd(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap);
/*
fz_new_psd_band_writer: Obtain a fz_band_writer instance
for producing PSD output.
*/
fz_band_writer *fz_new_psd_band_writer(fz_context *ctx, fz_output *out);
#endif

116
include/mupdf/fitz/output-pwg.h
View File

@@ -1,116 +0,0 @@
#ifndef MUPDF_FITZ_OUTPUT_PWG_H
#define MUPDF_FITZ_OUTPUT_PWG_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/bitmap.h"
typedef struct fz_pwg_options_s fz_pwg_options;
struct fz_pwg_options_s
{
/* These are not interpreted as CStrings by the writing code, but
* are rather copied directly out. */
char media_class[64];
char media_color[64];
char media_type[64];
char output_type[64];
unsigned int advance_distance;
int advance_media;
int collate;
int cut_media;
int duplex;
int insert_sheet;
int jog;
int leading_edge;
int manual_feed;
unsigned int media_position;
unsigned int media_weight;
int mirror_print;
int negative_print;
unsigned int num_copies;
int orientation;
int output_face_up;
unsigned int PageSize[2];
int separations;
int tray_switch;
int tumble;
int media_type_num;
int compression;
unsigned int row_count;
unsigned int row_feed;
unsigned int row_step;
/* These are not interpreted as CStrings by the writing code, but
* are rather copied directly out. */
char rendering_intent[64];
char page_size_name[64];
};
/*
fz_save_pixmap_as_pwg: Save a pixmap as a pwg
filename: The filename to save as (including extension).
append: If non-zero, then append a new page to existing file.
pwg: NULL, or a pointer to an options structure (initialised to zero
before being filled in, for future expansion).
*/
void fz_save_pixmap_as_pwg(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, const fz_pwg_options *pwg);
/*
fz_save_bitmap_as_pwg: Save a bitmap as a pwg
filename: The filename to save as (including extension).
append: If non-zero, then append a new page to existing file.
pwg: NULL, or a pointer to an options structure (initialised to zero
before being filled in, for future expansion).
*/
void fz_save_bitmap_as_pwg(fz_context *ctx, fz_bitmap *bitmap, char *filename, int append, const fz_pwg_options *pwg);
/*
Output a pixmap to an output stream as a pwg raster.
*/
void fz_write_pixmap_as_pwg(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg);
/*
Output a bitmap to an output stream as a pwg raster.
*/
void fz_write_bitmap_as_pwg(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pwg_options *pwg);
/*
Output the file header to a pwg stream, ready for pages to follow it.
*/
void fz_write_pwg_file_header(fz_context *ctx, fz_output *out);
/*
Output a page to a pwg stream to follow a header, or other pages.
*/
void fz_write_pixmap_as_pwg_page(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg);
/*
Output a bitmap page to a pwg stream to follow a header, or other pages.
*/
void fz_write_bitmap_as_pwg_page(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pwg_options *pwg);
/*
fz_new_mono_pwg_band_writer: Generate a new band writer for
PWG format images.
*/
fz_band_writer *fz_new_mono_pwg_band_writer(fz_context *ctx, fz_output *out, const fz_pwg_options *pwg);
/*
fz_new_pwg_band_writer: Generate a new band writer for
contone PWG format images.
*/
fz_band_writer *fz_new_pwg_band_writer(fz_context *ctx, fz_output *out, const fz_pwg_options *pwg);
#endif

46
include/mupdf/fitz/output-svg.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_OUTPUT_SVG_H
#define MUPDF_FITZ_OUTPUT_SVG_H
@@ -11,20 +33,32 @@ enum {
FZ_SVG_TEXT_AS_TEXT = 1,
};
/*
fz_new_svg_device: Create a device that outputs (single page)
SVG files to the given output stream.
/**
Create a device that outputs (single page) SVG files to
the given output stream.
Equivalent to fz_new_svg_device_with_id passing id = NULL.
*/
fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, float page_height, int text_format, int reuse_images);
/**
Create a device that outputs (single page) SVG files to
the given output stream.
output: The output stream to send the constructed SVG page to.
page_width, page_height: The page dimensions to use (in points).
text_format: How to emit text. One of the following values:
FZ_SVG_TEXT_AS_TEXT: As <text> elements with possible layout errors and mismatching fonts.
FZ_SVG_TEXT_AS_PATH: As <path> elements with exact visual appearance.
FZ_SVG_TEXT_AS_TEXT: As <text> elements with possible
layout errors and mismatching fonts.
FZ_SVG_TEXT_AS_PATH: As <path> elements with exact
visual appearance.
reuse_images: Share image resources using <symbol> definitions.
id: ID parameter to keep generated IDs unique across SVG files.
*/
fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, float page_height, int text_format, int reuse_images);
fz_device *fz_new_svg_device_with_id(fz_context *ctx, fz_output *out, float page_width, float page_height, int text_format, int reuse_images, int *id);
#endif

37
include/mupdf/fitz/output-tga.h
View File

@@ -1,37 +0,0 @@
#ifndef MUPDF_FITZ_OUTPUT_TGA_H
#define MUPDF_FITZ_OUTPUT_TGA_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
/*
fz_save_pixmap_as_tga: Save a pixmap as a TGA image file.
Can accept RGB, BGR or Grayscale pixmaps, with or without
alpha.
*/
void fz_save_pixmap_as_tga(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/*
Write a pixmap to an output stream in TGA format.
Can accept RGB, BGR or Grayscale pixmaps, with or without
alpha.
*/
void fz_write_pixmap_as_tga(fz_context *ctx, fz_output *out, fz_pixmap *pixmap);
/*
fz_new_tga_band_writer: Generate a new band writer for TGA
format images. Note that image must be generated vertically
flipped for use with this writer!
Can accept RGB, BGR or Grayscale pixmaps, with or without
alpha.
is_bgr: True, if the image is generated in bgr format.
*/
fz_band_writer *fz_new_tga_band_writer(fz_context *ctx, fz_output *out, int is_bgr);
#endif

366
include/mupdf/fitz/output.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2022 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_OUTPUT_H
#define MUPDF_FITZ_OUTPUT_H
@@ -7,14 +29,13 @@
#include "mupdf/fitz/string-util.h"
#include "mupdf/fitz/stream.h"
/*
Generic output streams - generalise between outputting to a file,
a buffer, etc.
/**
Generic output streams - generalise between outputting to a
file, a buffer, etc.
*/
typedef struct fz_output_s fz_output;
/*
fz_output_write_fn: A function type for use when implementing
/**
A function type for use when implementing
fz_outputs. The supplied function of this type is called
whenever data is written to the output.
@@ -26,19 +47,19 @@ typedef struct fz_output_s fz_output;
*/
typedef void (fz_output_write_fn)(fz_context *ctx, void *state, const void *data, size_t n);
/*
fz_output_seek_fn: A function type for use when implementing
/**
A function type for use when implementing
fz_outputs. The supplied function of this type is called when
fz_seek_output is requested.
state: The output stream state to seek within.
offset, whence: as defined for fs_seek_output.
offset, whence: as defined for fz_seek().
*/
typedef void (fz_output_seek_fn)(fz_context *ctx, void *state, int64_t offset, int whence);
/*
fz_output_tell_fn: A function type for use when implementing
/**
A function type for use when implementing
fz_outputs. The supplied function of this type is called when
fz_tell_output is requested.
@@ -48,30 +69,45 @@ typedef void (fz_output_seek_fn)(fz_context *ctx, void *state, int64_t offset, i
*/
typedef int64_t (fz_output_tell_fn)(fz_context *ctx, void *state);
/*
fz_output_close_fn: A function type for use when implementing
/**
A function type for use when implementing
fz_outputs. The supplied function of this type is called
when the output stream is closed, to flush any pending writes.
*/
typedef void (fz_output_close_fn)(fz_context *ctx, void *state);
/*
fz_output_drop_fn: A function type for use when implementing
/**
A function type for use when implementing
fz_outputs. The supplied function of this type is called
when the output stream is dropped, to release the stream specific
state information.
when the output stream is reset, and resets the state
to that when it was first initialised.
*/
typedef void (fz_output_reset_fn)(fz_context *ctx, void *state);
/**
A function type for use when implementing
fz_outputs. The supplied function of this type is called
when the output stream is dropped, to release the stream
specific state information.
*/
typedef void (fz_output_drop_fn)(fz_context *ctx, void *state);
/*
fz_stream_from_output_fn: A function type for use when implementing
/**
A function type for use when implementing
fz_outputs. The supplied function of this type is called
when the fz_stream_from_output is called.
*/
typedef fz_stream *(fz_stream_from_output_fn)(fz_context *ctx, void *state);
/**
A function type for use when implementing
fz_outputs. The supplied function of this type is called
when fz_truncate_output is called to truncate the file
at that point.
*/
typedef void (fz_truncate_fn)(fz_context *ctx, void *state);
struct fz_output_s
struct fz_output
{
void *state;
fz_output_write_fn *write;
@@ -79,12 +115,19 @@ struct fz_output_s
fz_output_tell_fn *tell;
fz_output_close_fn *close;
fz_output_drop_fn *drop;
fz_output_reset_fn *reset;
fz_stream_from_output_fn *as_stream;
fz_truncate_fn *truncate;
int closed;
char *bp, *wp, *ep;
/* If buffered is non-zero, then we have that many
* bits (1-7) waiting to be written in bits. */
int buffered;
int bits;
};
/*
fz_new_output: Create a new output object with the given
/**
Create a new output object with the given
internal state and function pointers.
state: Internal state (opaque to everything but implementation).
@@ -96,8 +139,8 @@ struct fz_output_s
*/
fz_output *fz_new_output(fz_context *ctx, int bufsiz, void *state, fz_output_write_fn *write, fz_output_close_fn *close, fz_output_drop_fn *drop);
/*
fz_new_output_with_path: Open an output stream that writes to a
/**
Open an output stream that writes to a
given path.
filename: The filename to write to (specified in UTF-8).
@@ -107,207 +150,262 @@ fz_output *fz_new_output(fz_context *ctx, int bufsiz, void *state, fz_output_wri
*/
fz_output *fz_new_output_with_path(fz_context *, const char *filename, int append);
/*
fz_new_output_with_buffer: Open an output stream that appends
/**
Open an output stream that writes to a
given FILE *.
file: The file pointers to write to. NULL is interpreted as effectively
meaning /dev/null or similar.
*/
fz_output *fz_new_output_with_file_ptr(fz_context *ctx, FILE *file);
/**
Open an output stream that appends
to a buffer.
buf: The buffer to append to.
*/
fz_output *fz_new_output_with_buffer(fz_context *ctx, fz_buffer *buf);
/*
fz_stdout: The standard out output stream. By default
this stream writes to stdout. This may be overridden
using fz_set_stdout.
/**
Retrieve an fz_output that directs to stdout.
Optionally may be fz_dropped when finished with.
*/
fz_output *fz_stdout(fz_context *ctx);
/*
fz_stderr: The standard error output stream. By default
this stream writes to stderr. This may be overridden
using fz_set_stderr.
/**
Retrieve an fz_output that directs to stdout.
Optionally may be fz_dropped when finished with.
*/
fz_output *fz_stderr(fz_context *ctx);
/*
fz_set_stdout: Replace default standard output stream
with a given stream.
#ifdef _WIN32
/**
Retrieve an fz_output that directs to OutputDebugString.
out: The new stream to use.
Optionally may be fz_dropped when finished with.
*/
void fz_set_stdout(fz_context *ctx, fz_output *out);
fz_output *fz_stdods(fz_context *ctx);
#endif
/*
fz_set_stderr: Replace default standard error stream
with a given stream.
err: The new stream to use.
/**
Set the output stream to be used for fz_stddbg. Set to NULL to
reset to default (stderr).
*/
void fz_set_stderr(fz_context *ctx, fz_output *err);
void fz_set_stddbg(fz_context *ctx, fz_output *out);
/*
fz_write_printf: Format and write data to an output stream.
See fz_vsnprintf for formatting details.
/**
Retrieve an fz_output for the default debugging stream. On
Windows this will be OutputDebugString for non-console apps.
Otherwise, it is always fz_stderr.
Optionally may be fz_dropped when finished with.
*/
fz_output *fz_stddbg(fz_context *ctx);
/**
Format and write data to an output stream.
See fz_format_string for formatting details.
*/
void fz_write_printf(fz_context *ctx, fz_output *out, const char *fmt, ...);
/*
fz_write_vprintf: va_list version of fz_write_printf.
/**
va_list version of fz_write_printf.
*/
void fz_write_vprintf(fz_context *ctx, fz_output *out, const char *fmt, va_list ap);
/*
fz_seek_output: Seek to the specified file position.
/**
Seek to the specified file position.
See fseek for arguments.
Throw an error on unseekable outputs.
*/
void fz_seek_output(fz_context *ctx, fz_output *out, int64_t off, int whence);
/*
fz_tell_output: Return the current file position.
/**
Return the current file position.
Throw an error on untellable outputs.
*/
int64_t fz_tell_output(fz_context *ctx, fz_output *out);
/*
fz_flush_output: Flush unwritten data.
/**
Flush unwritten data.
*/
void fz_flush_output(fz_context *ctx, fz_output *out);
/*
fz_close_output: Flush pending output and close an output stream.
/**
Flush pending output and close an output stream.
*/
void fz_close_output(fz_context *, fz_output *);
/*
fz_drop_output: Free an output stream. Don't forget to close it first!
/**
Reset a closed output stream. Returns state to
(broadly) that which it was in when opened. Not
all outputs can be reset, so this may throw an
exception.
*/
void fz_reset_output(fz_context *, fz_output *);
/**
Free an output stream. Don't forget to close it first!
*/
void fz_drop_output(fz_context *, fz_output *);
/*
fz_stream_from_output: obtain the fz_output in the form of a fz_stream
/**
Query whether a given fz_output supports fz_stream_from_output.
*/
int fz_output_supports_stream(fz_context *ctx, fz_output *out);
This allows data to be read back from some forms of fz_output object.
When finished reading, the fz_stream should be released by calling
fz_drop_stream. Until the fz_stream is dropped, no further operations
should be performed on the fz_output object.
/**
Obtain the fz_output in the form of a fz_stream.
This allows data to be read back from some forms of fz_output
object. When finished reading, the fz_stream should be released
by calling fz_drop_stream. Until the fz_stream is dropped, no
further operations should be performed on the fz_output object.
*/
fz_stream *fz_stream_from_output(fz_context *, fz_output *);
/*
fz_write_data: Write data to output.
/**
Truncate the output at the current position.
This allows output streams which have seeked back from the end
of their storage to be truncated at the current point.
*/
void fz_truncate_output(fz_context *, fz_output *);
/**
Write data to output.
data: Pointer to data to write.
size: Size of data to write in bytes.
*/
void fz_write_data(fz_context *ctx, fz_output *out, const void *data, size_t size);
void fz_write_buffer(fz_context *ctx, fz_output *out, fz_buffer *data);
/*
fz_write_string: Write a string. Does not write zero terminator.
/**
Write a string. Does not write zero terminator.
*/
void fz_write_string(fz_context *ctx, fz_output *out, const char *s);
/*
fz_write_int32_be: Write a big-endian 32-bit binary integer.
/**
Write different sized data to an output stream.
*/
void fz_write_int32_be(fz_context *ctx, fz_output *out, int x);
/*
fz_write_int32_le: Write a little-endian 32-bit binary integer.
*/
void fz_write_int32_le(fz_context *ctx, fz_output *out, int x);
/*
fz_write_int16_be: Write a big-endian 16-bit binary integer.
*/
void fz_write_uint32_be(fz_context *ctx, fz_output *out, unsigned int x);
void fz_write_uint32_le(fz_context *ctx, fz_output *out, unsigned int x);
void fz_write_int16_be(fz_context *ctx, fz_output *out, int x);
/*
fz_write_int16_le: Write a little-endian 16-bit binary integer.
*/
void fz_write_int16_le(fz_context *ctx, fz_output *out, int x);
/*
fz_write_byte: Write a single byte.
*/
void fz_write_uint16_be(fz_context *ctx, fz_output *out, unsigned int x);
void fz_write_uint16_le(fz_context *ctx, fz_output *out, unsigned int x);
void fz_write_char(fz_context *ctx, fz_output *out, char x);
void fz_write_byte(fz_context *ctx, fz_output *out, unsigned char x);
void fz_write_float_be(fz_context *ctx, fz_output *out, float f);
void fz_write_float_le(fz_context *ctx, fz_output *out, float f);
/*
fz_write_rune: Write a UTF-8 encoded unicode character.
/**
Write a UTF-8 encoded unicode character.
*/
void fz_write_rune(fz_context *ctx, fz_output *out, int rune);
/*
fz_write_base64: Write base64 encoded data.
/**
Write a base64 encoded data block, optionally with periodic
newlines.
*/
void fz_write_base64(fz_context *ctx, fz_output *out, const unsigned char *data, size_t size, int newline);
/**
Write a base64 encoded fz_buffer, optionally with periodic
newlines.
*/
void fz_write_base64(fz_context *ctx, fz_output *out, const unsigned char *data, int size, int newline);
void fz_write_base64_buffer(fz_context *ctx, fz_output *out, fz_buffer *data, int newline);
/*
fz_format_string: Our customised 'printf'-like string formatter.
Takes %c, %d, %s, %u, %x, as usual.
Modifiers are not supported except for zero-padding ints (e.g. %02d, %03u, %04x, etc).
%g output in "as short as possible hopefully lossless non-exponent" form,
see fz_ftoa for specifics.
/**
Write num_bits of data to the end of the output stream, assumed to be packed
most significant bits first.
*/
void fz_write_bits(fz_context *ctx, fz_output *out, unsigned int data, int num_bits);
/**
Sync to byte boundary after writing bits.
*/
void fz_write_bits_sync(fz_context *ctx, fz_output *out);
/**
Copy the stream contents to the output.
*/
void fz_write_stream(fz_context *ctx, fz_output *out, fz_stream *in);
/**
Our customised 'printf'-like string formatter.
Takes %c, %d, %s, %u, %x, %X as usual.
Modifiers are not supported except for zero-padding ints (e.g.
%02d, %03u, %04x, etc).
%g output in "as short as possible hopefully lossless
non-exponent" form, see fz_ftoa for specifics.
%f and %e output as usual.
%C outputs a utf8 encoded int.
%M outputs a fz_matrix*. %R outputs a fz_rect*. %P outputs a fz_point*.
%M outputs a fz_matrix*.
%R outputs a fz_rect*.
%P outputs a fz_point*.
%n outputs a PDF name (with appropriate escaping).
%q and %( output escaped strings in C/PDF syntax.
%l{d,u,x} indicates that the values are int64_t.
%z{d,u,x} indicates that the value is a size_t.
%l{d,u,x,X} indicates that the values are int64_t.
%z{d,u,x,X} indicates that the value is a size_t.
user: An opaque pointer that is passed to the emit function.
emit: A function pointer called to emit output bytes as the string is being formatted.
*/
void
fz_format_string(fz_context *ctx, void *user, void (*emit)(fz_context *ctx, void *user, int c), const char *fmt, va_list args);
/*
fz_vsnprintf: A vsnprintf work-alike, using our custom formatter.
emit: A function pointer called to emit output bytes as the
string is being formatted.
*/
void fz_format_string(fz_context *ctx, void *user, void (*emit)(fz_context *ctx, void *user, int c), const char *fmt, va_list args);
/**
A vsnprintf work-alike, using our custom formatter.
*/
size_t fz_vsnprintf(char *buffer, size_t space, const char *fmt, va_list args);
/*
fz_snprintf: The non va_list equivalent of fz_vsnprintf.
/**
The non va_list equivalent of fz_vsnprintf.
*/
size_t fz_snprintf(char *buffer, size_t space, const char *fmt, ...);
/*
fz_asprintf: Print to allocated string.
/**
Allocated sprintf.
Returns a null terminated allocated block containing the
formatted version of the format string/args.
*/
char *fz_asprintf(fz_context *ctx, const char *fmt, ...);
/*
fz_tempfilename: Get a temporary filename based upon 'base'.
'hint' is the path of a file (normally the existing document file)
supplied to give the function an idea of what directory to use. This
may or may not be used depending on the implementation's whim.
The returned path must be freed.
*/
char *fz_tempfilename(fz_context *ctx, const char *base, const char *hint);
/*
fz_save_buffer: Save contents of a buffer to file.
/**
Save the contents of a buffer to a file.
*/
void fz_save_buffer(fz_context *ctx, fz_buffer *buf, const char *filename);
/*
/**
Compression and other filtering outputs.
These outputs write encoded data to another output. Create a filter
output with the destination, write to the filter, then drop it when
you're done. These can also be chained together, for example to write
ASCII Hex encoded, Deflate compressed, and RC4 encrypted data to a
buffer output.
These outputs write encoded data to another output. Create a
filter output with the destination, write to the filter, then
close and drop it when you're done. These can also be chained
together, for example to write ASCII Hex encoded, Deflate
compressed, and RC4 encrypted data to a buffer output.
Output streams don't use reference counting, so make sure to drop all
of the filters in the reverse order of creation so that data is flushed
properly.
Output streams don't use reference counting, so make sure to
close all of the filters in the reverse order of creation so
that data is flushed properly.
Accordingly, ownership of 'chain' is never passed into the
following functions, but remains with the caller, whose
responsibility it is to ensure they exist at least until
the returned fz_output is dropped.
*/
fz_output *fz_new_asciihex_output(fz_context *ctx, fz_output *chain);
fz_output *fz_new_ascii85_output(fz_context *ctx, fz_output *chain);
fz_output *fz_new_rle_output(fz_context *ctx, fz_output *chain);

251
include/mupdf/fitz/path.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_PATH_H
#define MUPDF_FITZ_PATH_H
@@ -5,7 +27,7 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
/*
/**
* Vector path buffer.
* It can be stroked and dashed, or be filled.
* It has a fill rule (nonzero or even_odd).
@@ -14,10 +36,9 @@
* into the Global Edge List.
*/
typedef struct fz_path_s fz_path;
typedef struct fz_stroke_state_s fz_stroke_state;
typedef struct fz_path fz_path;
typedef enum fz_linecap_e
typedef enum
{
FZ_LINECAP_BUTT = 0,
FZ_LINECAP_ROUND = 1,
@@ -25,7 +46,7 @@ typedef enum fz_linecap_e
FZ_LINECAP_TRIANGLE = 3
} fz_linecap;
typedef enum fz_linejoin_e
typedef enum
{
FZ_LINEJOIN_MITER = 0,
FZ_LINEJOIN_ROUND = 1,
@@ -33,7 +54,7 @@ typedef enum fz_linejoin_e
FZ_LINEJOIN_MITER_XPS = 3
} fz_linejoin;
struct fz_stroke_state_s
typedef struct
{
int refs;
fz_linecap start_cap, dash_cap, end_cap;
@@ -43,7 +64,7 @@ struct fz_stroke_state_s
float dash_phase;
int dash_len;
float dash_list[32];
};
} fz_stroke_state;
typedef struct
{
@@ -59,8 +80,8 @@ typedef struct
void (*rectto)(fz_context *ctx, void *arg, float x1, float y1, float x2, float y2);
} fz_path_walker;
/*
fz_walk_path: Walk the segments of a path, calling the
/**
Walk the segments of a path, calling the
appropriate callback function from a given set for each
segment of the path.
@@ -79,59 +100,50 @@ typedef struct
*/
void fz_walk_path(fz_context *ctx, const fz_path *path, const fz_path_walker *walker, void *arg);
/*
fz_new_path: Create an empty path, and return
a reference to it.
Throws exception on failure to allocate.
/**
Create a new (empty) path structure.
*/
fz_path *fz_new_path(fz_context *ctx);
/*
fz_keep_path: Take an additional reference to
a path.
/**
Increment the reference count. Returns the same pointer.
No modifications should be carried out on a path
to which more than one reference is held, as
this can cause race conditions.
All paths can be kept, regardless of their packing type.
Never throws exceptions.
*/
fz_path *fz_keep_path(fz_context *ctx, const fz_path *path);
/*
fz_drop_path: Drop a reference to a path,
destroying the path if it is the last
reference.
/**
Decrement the reference count. When the reference count hits
zero, free the path.
All paths can be dropped, regardless of their packing type.
Packed paths do not own the blocks into which they are packed
so dropping them does not free those blocks.
Never throws exceptions.
*/
void fz_drop_path(fz_context *ctx, const fz_path *path);
/*
fz_trim_path: Minimise the internal storage
used by a path.
/**
Minimise the internal storage used by a path.
As paths are constructed, the internal buffers
grow. To avoid repeated reallocations they
grow with some spare space. Once a path has
been fully constructed, this call allows the
excess space to be trimmed.
Never throws exceptions.
*/
void fz_trim_path(fz_context *ctx, fz_path *path);
/*
fz_packed_path_size: Return the number of
bytes required to pack a path.
Never throws exceptions.
/**
Return the number of bytes required to pack a path.
*/
int fz_packed_path_size(const fz_path *path);
/*
fz_pack_path: Pack a path into the given block.
/**
Pack a path into the given block.
To minimise the size of paths, this function allows them to be
packed into a buffer with other information. Paths can be used
interchangeably regardless of how they are packed.
@@ -140,28 +152,20 @@ int fz_packed_path_size(const fz_path *path);
be aligned by the caller to the same alignment as required for
a fz_path pointer.
max: The number of bytes available in the block.
If max < sizeof(fz_path) then an exception will
be thrown. If max >= the value returned by
fz_packed_path_size, then this call will never
fail, except in low memory situations with large
paths.
path: The path to pack.
Returns the number of bytes within the block used. Callers can
access the packed path data by casting the value of pack on
entry to be a fz_path *.
Throws exceptions on failure to allocate, or if
max < sizeof(fz_path).
Throws exceptions on failure to allocate.
Implementation details: Paths can be 'unpacked', 'flat', or
'open'. Standard paths, as created are 'unpacked'. Paths that
will pack into less than max bytes will be packed as 'flat',
unless they are too large (where large indicates that they
exceed some private implementation defined limits, currently
including having more than 256 coordinates or commands).
'open'. Standard paths, as created are 'unpacked'. Paths
will be packed as 'flat', unless they are too large
(where large indicates that they exceed some private
implementation defined limits, currently including having
more than 256 coordinates or commands).
Large paths are 'open' packed as a header into the given block,
plus pointers to other data blocks.
@@ -170,10 +174,10 @@ int fz_packed_path_size(const fz_path *path);
or 'flat' packed. Simply pack a path (if required), and then
forget about the details.
*/
int fz_pack_path(fz_context *ctx, uint8_t *pack, int max, const fz_path *path);
size_t fz_pack_path(fz_context *ctx, uint8_t *pack, const fz_path *path);
/*
fz_clone_path: Clone the data for a path.
/**
Clone the data for a path.
This is used in preference to fz_keep_path when a whole
new copy of a path is required, rather than just a shared
@@ -186,39 +190,41 @@ int fz_pack_path(fz_context *ctx, uint8_t *pack, int max, const fz_path *path);
*/
fz_path *fz_clone_path(fz_context *ctx, fz_path *path);
/*
fz_currentpoint: Return the current point that a path has
/**
Return the current point that a path has
reached or (0,0) if empty.
path: path to return the current point of.
*/
fz_point fz_currentpoint(fz_context *ctx, fz_path *path);
/*
fz_moveto: Append a 'moveto' command to a path.
/**
Append a 'moveto' command to a path.
This 'opens' a path.
path: The path to modify.
x, y: The coordinate to move to.
Throws exceptions on failure to allocate.
Throws exceptions on failure to allocate, or attempting to
modify a packed path.
*/
void fz_moveto(fz_context *ctx, fz_path *path, float x, float y);
/*
fz_lineto: Append a 'lineto' command to an open path.
/**
Append a 'lineto' command to an open path.
path: The path to modify.
x, y: The coordinate to line to.
Throws exceptions on failure to allocate.
Throws exceptions on failure to allocate, or attempting to
modify a packed path.
*/
void fz_lineto(fz_context *ctx, fz_path *path, float x, float y);
/*
fz_rectto: Append a 'rectto' command to an open path.
/**
Append a 'rectto' command to an open path.
The rectangle is equivalent to:
moveto x0 y0
@@ -233,12 +239,13 @@ void fz_lineto(fz_context *ctx, fz_path *path, float x, float y);
x1, y1: Second corner of the rectangle.
Throws exceptions on failure to allocate.
Throws exceptions on failure to allocate, or attempting to
modify a packed path.
*/
void fz_rectto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, float y1);
/*
fz_quadto: Append a 'quadto' command to an open path. (For a
/**
Append a 'quadto' command to an open path. (For a
quadratic bezier).
path: The path to modify.
@@ -247,12 +254,13 @@ void fz_rectto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, flo
x1, y1: The end coordinates for the quadratic curve.
Throws exceptions on failure to allocate.
Throws exceptions on failure to allocate, or attempting to
modify a packed path.
*/
void fz_quadto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, float y1);
/*
fz_curveto: Append a 'curveto' command to an open path. (For a
/**
Append a 'curveto' command to an open path. (For a
cubic bezier).
path: The path to modify.
@@ -265,12 +273,13 @@ void fz_quadto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, flo
x2, y2: The end coordinates for the curve.
Throws exceptions on failure to allocate.
Throws exceptions on failure to allocate, or attempting to
modify a packed path.
*/
void fz_curveto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, float y1, float x2, float y2);
/*
fz_curvetov: Append a 'curvetov' command to an open path. (For a
/**
Append a 'curvetov' command to an open path. (For a
cubic bezier with the first control coordinate equal to
the start point).
@@ -281,12 +290,13 @@ void fz_curveto(fz_context *ctx, fz_path *path, float x0, float y0, float x1, fl
x2, y2: The end coordinates for the curve.
Throws exceptions on failure to allocate.
Throws exceptions on failure to allocate, or attempting to
modify a packed path.
*/
void fz_curvetov(fz_context *ctx, fz_path *path, float x1, float y1, float x2, float y2);
/*
fz_curvetoy: Append a 'curvetoy' command to an open path. (For a
/**
Append a 'curvetoy' command to an open path. (For a
cubic bezier with the second control coordinate equal to
the end point).
@@ -298,22 +308,24 @@ void fz_curvetov(fz_context *ctx, fz_path *path, float x1, float y1, float x2, f
x2, y2: The end coordinates for the curve (and the second
control coordinate).
Throws exceptions on failure to allocate.
Throws exceptions on failure to allocate, or attempting to
modify a packed path.
*/
void fz_curvetoy(fz_context *ctx, fz_path *path, float x0, float y0, float x2, float y2);
/*
fz_closepath: Close the current subpath.
/**
Close the current subpath.
path: The path to modify.
Throws exceptions on failure to allocate, and illegal
path closes (i.e. closing a non open path).
Throws exceptions on failure to allocate, attempting to modify
a packed path, and illegal path closes (i.e. closing a non open
path).
*/
void fz_closepath(fz_context *ctx, fz_path *path);
/*
fz_transform_path: Transform a path by a given
/**
Transform a path by a given
matrix.
path: The path to modify (must not be a packed path).
@@ -323,10 +335,10 @@ void fz_closepath(fz_context *ctx, fz_path *path);
Throws exceptions if the path is packed, or on failure
to allocate.
*/
void fz_transform_path(fz_context *ctx, fz_path *path, const fz_matrix *transform);
void fz_transform_path(fz_context *ctx, fz_path *path, fz_matrix transform);
/*
fz_bound_path: Return a bounding rectangle for a path.
/**
Return a bounding rectangle for a path.
path: The path to bound.
@@ -341,23 +353,32 @@ void fz_transform_path(fz_context *ctx, fz_path *path, const fz_matrix *transfor
Returns r, updated to contain the bounding rectangle.
*/
fz_rect *fz_bound_path(fz_context *ctx, const fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, fz_rect *r);
fz_rect *fz_adjust_rect_for_stroke(fz_context *ctx, fz_rect *r, const fz_stroke_state *stroke, const fz_matrix *ctm);
fz_rect fz_bound_path(fz_context *ctx, const fz_path *path, const fz_stroke_state *stroke, fz_matrix ctm);
extern const fz_stroke_state fz_default_stroke_state;
/**
Given a rectangle (assumed to be the bounding box for a path),
expand it to allow for the expansion of the bbox that would be
seen by stroking the path with the given stroke state and
transform.
*/
fz_rect fz_adjust_rect_for_stroke(fz_context *ctx, fz_rect rect, const fz_stroke_state *stroke, fz_matrix ctm);
/*
fz_new_stroke_state: Create a new (empty) stroke state
structure (with no dash data) and return a reference to it.
/**
A sane 'default' stroke state.
*/
FZ_DATA extern const fz_stroke_state fz_default_stroke_state;
/**
Create a new (empty) stroke state structure (with no dash
data) and return a reference to it.
Throws exception on failure to allocate.
*/
fz_stroke_state *fz_new_stroke_state(fz_context *ctx);
/*
fz_new_stroke_state_with_dash_len: Create a new (empty)
stroke state structure, with room for dash data of the
given length, and return a reference to it.
/**
Create a new (empty) stroke state structure, with room for
dash data of the given length, and return a reference to it.
len: The number of dash elements to allow room for.
@@ -365,31 +386,24 @@ fz_stroke_state *fz_new_stroke_state(fz_context *ctx);
*/
fz_stroke_state *fz_new_stroke_state_with_dash_len(fz_context *ctx, int len);
/*
fz_keep_stroke_state: Take an additional reference to
a stroke state structure.
/**
Take an additional reference to a stroke state structure.
No modifications should be carried out on a stroke
state to which more than one reference is held, as
this can cause race conditions.
Never throws exceptions.
*/
fz_stroke_state *fz_keep_stroke_state(fz_context *ctx, const fz_stroke_state *stroke);
/*
fz_drop_stroke_state: Drop a reference to a stroke
state structure, destroying the structure if it is
the last reference.
Never throws exceptions.
/**
Drop a reference to a stroke state structure, destroying the
structure if it is the last reference.
*/
void fz_drop_stroke_state(fz_context *ctx, const fz_stroke_state *stroke);
/*
fz_unshare_stroke_state: Given a reference to a
(possibly) shared stroke_state structure, return
a reference to an equivalent stroke_state structure
/**
Given a reference to a (possibly) shared stroke_state structure,
return a reference to an equivalent stroke_state structure
that is guaranteed to be unshared (i.e. one that can
safely be modified).
@@ -403,12 +417,11 @@ void fz_drop_stroke_state(fz_context *ctx, const fz_stroke_state *stroke);
*/
fz_stroke_state *fz_unshare_stroke_state(fz_context *ctx, fz_stroke_state *shared);
/*
fz_unshare_stroke_state_with_dash_len: Given a reference to a
(possibly) shared stroke_state structure, return a reference
to a stroke_state structure (with room for a given amount of
dash data) that is guaranteed to be unshared (i.e. one that
can safely be modified).
/**
Given a reference to a (possibly) shared stroke_state structure,
return a reference to a stroke_state structure (with room for a
given amount of dash data) that is guaranteed to be unshared
(i.e. one that can safely be modified).
shared: The reference to a (possibly) shared structure
to unshare. Ownership of this reference is passed in
@@ -420,9 +433,9 @@ fz_stroke_state *fz_unshare_stroke_state(fz_context *ctx, fz_stroke_state *share
*/
fz_stroke_state *fz_unshare_stroke_state_with_dash_len(fz_context *ctx, fz_stroke_state *shared, int len);
/*
fz_clone_stroke_state: Create an identical stroke_state
structure and return a reference to it.
/**
Create an identical stroke_state structure and return a
reference to it.
stroke: The stroke state reference to clone.

429
include/mupdf/fitz/pixmap.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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
@@ -5,46 +27,51 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/store.h"
#include "mupdf/fitz/colorspace.h"
#include "mupdf/fitz/separation.h"
/*
Pixmaps represent a set of pixels for a 2 dimensional region of a
plane. Each pixel has n components per pixel, the last of which is
always alpha. The data is in premultiplied alpha when rendering, but
non-premultiplied for colorspace conversions and rescaling.
/**
Pixmaps represent a set of pixels for a 2 dimensional region of
a plane. Each pixel has n components per pixel. The components
are in the order process-components, spot-colors, alpha, where
there can be 0 of any of those types. The data is in
premultiplied alpha when rendering, but non-premultiplied for
colorspace conversions and rescaling.
*/
typedef struct fz_pixmap_s fz_pixmap;
typedef struct fz_overprint_s fz_overprint;
typedef struct fz_overprint fz_overprint;
/*
fz_pixmap_bbox: Return the bounding box for a pixmap.
/**
Return the bounding box for a pixmap.
*/
fz_irect *fz_pixmap_bbox(fz_context *ctx, const fz_pixmap *pix, fz_irect *bbox);
fz_irect fz_pixmap_bbox(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_width: Return the width of the pixmap in pixels.
/**
Return the width of the pixmap in pixels.
*/
int fz_pixmap_width(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_width(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_height: Return the height of the pixmap in pixels.
/**
Return the height of the pixmap in pixels.
*/
int fz_pixmap_height(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_height(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_x: Return the x value of the pixmap in pixels.
/**
Return the x value of the pixmap in pixels.
*/
int fz_pixmap_x(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_x(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_y: Return the y value of the pixmap in pixels.
/**
Return the y value of the pixmap in pixels.
*/
int fz_pixmap_y(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_y(fz_context *ctx, const fz_pixmap *pix);
/*
fz_new_pixmap: Create a new pixmap, with its origin at (0,0)
/**
Return sizeof fz_pixmap plus size of data, in bytes.
*/
size_t fz_pixmap_size(fz_context *ctx, fz_pixmap *pix);
/**
Create a new pixmap, with its origin at (0,0)
cs: The colorspace to use for the pixmap, or NULL for an alpha
plane/mask.
@@ -57,14 +84,13 @@ int fz_pixmap_y(fz_context *ctx, fz_pixmap *pix);
alpha: 0 for no alpha, 1 for alpha.
Returns a pointer to the new pixmap. Throws exception on failure to
allocate.
Returns a pointer to the new pixmap. Throws exception on failure
to allocate.
*/
fz_pixmap *fz_new_pixmap(fz_context *ctx, fz_colorspace *cs, int w, int h, fz_separations *seps, int alpha);
/*
fz_new_pixmap_with_bbox: Create a pixmap of a given size,
location and pixel format.
/**
Create a pixmap of a given size, location and pixel format.
The bounding box specifies the size of the created pixmap and
where it will be located. The colorspace determines the number
@@ -80,13 +106,13 @@ fz_pixmap *fz_new_pixmap(fz_context *ctx, fz_colorspace *cs, int w, int h, fz_se
alpha: 0 for no alpha, 1 for alpha.
Returns a pointer to the new pixmap. Throws exception on failure to
allocate.
Returns a pointer to the new pixmap. Throws exception on failure
to allocate.
*/
fz_pixmap *fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, const fz_irect *bbox, 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_new_pixmap_with_data: Create a new pixmap, with its origin at
/**
Create a new pixmap, with its origin at
(0,0) using the supplied data block.
cs: The colorspace to use for the pixmap, or NULL for an alpha
@@ -100,8 +126,8 @@ fz_pixmap *fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, c
alpha: 0 for no alpha, 1 for alpha.
stride: The byte offset from the pixel data in a row to the pixel
data in the next row.
stride: The byte offset from the pixel data in a row to the
pixel data in the next row.
samples: The data block to keep the samples in.
@@ -110,9 +136,9 @@ fz_pixmap *fz_new_pixmap_with_bbox(fz_context *ctx, fz_colorspace *colorspace, c
*/
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_new_pixmap_with_bbox_and_data: Create a pixmap of a given size,
location and pixel format, using the supplied data block.
/**
Create a pixmap of a given size, location and pixel format,
using the supplied data block.
The bounding box specifies the size of the created pixmap and
where it will be located. The colorspace determines the number
@@ -130,111 +156,123 @@ fz_pixmap *fz_new_pixmap_with_data(fz_context *ctx, fz_colorspace *colorspace, i
samples: The data block to keep the samples in.
Returns a pointer to the new pixmap. Throws exception on failure to
allocate.
Returns a pointer to the new pixmap. Throws exception on failure
to allocate.
*/
fz_pixmap *fz_new_pixmap_with_bbox_and_data(fz_context *ctx, fz_colorspace *colorspace, const fz_irect *rect, fz_separations *seps, int alpha, 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_new_pixmap_from_pixmap: Create a new pixmap that represents
a subarea of the specified pixmap. A reference is taken to his
pixmap that will be dropped on destruction.
/**
Create a new pixmap that represents a subarea of the specified
pixmap. A reference is taken to this pixmap that will be dropped
on destruction.
The supplied rectangle must be wholly contained within the original
pixmap.
The supplied rectangle must be wholly contained within the
original pixmap.
Returns a pointer to the new pixmap. Throws exception on failure to
allocate.
Returns a pointer to the new pixmap. Throws exception on failure
to allocate.
*/
fz_pixmap *fz_new_pixmap_from_pixmap(fz_context *ctx, fz_pixmap *pixmap, const fz_irect *rect);
/*
fz_keep_pixmap: Take a reference to a pixmap.
/**
Clone a pixmap, copying the pixels and associated data to new
storage.
pix: The pixmap to increment the reference for.
The reference count of 'old' is unchanged.
*/
fz_pixmap *fz_clone_pixmap(fz_context *ctx, const fz_pixmap *old);
Returns pix.
/**
Increment the reference count for the pixmap. The same pointer
is returned.
Never throws exceptions.
*/
fz_pixmap *fz_keep_pixmap(fz_context *ctx, fz_pixmap *pix);
/*
fz_drop_pixmap: Drop a reference and free a pixmap.
/**
Decrement the reference count for the pixmap. When the
reference count hits 0, the pixmap is freed.
Decrement the reference count for the pixmap. When no
references remain the pixmap will be freed.
Never throws exceptions.
*/
void fz_drop_pixmap(fz_context *ctx, fz_pixmap *pix);
/*
fz_pixmap_colorspace: Return the colorspace of a pixmap
/**
Return the colorspace of a pixmap
Returns colorspace.
*/
fz_colorspace *fz_pixmap_colorspace(fz_context *ctx, fz_pixmap *pix);
fz_colorspace *fz_pixmap_colorspace(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_components: Return the number of components in a pixmap.
/**
Return the number of components in a pixmap.
Returns the number of components (including spots and alpha).
*/
int fz_pixmap_components(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_components(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_colorants: Return the number of colorants in a pixmap.
/**
Return the number of colorants in a pixmap.
Returns the number of colorants (components, less any spots and alpha).
Returns the number of colorants (components, less any spots and
alpha).
*/
int fz_pixmap_colorants(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_colorants(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_spots: Return the number of spots in a pixmap.
/**
Return the number of spots in a pixmap.
Returns the number of spots (components, less colorants and alpha). Does not throw exceptions.
Returns the number of spots (components, less colorants and
alpha). Does not throw exceptions.
*/
int fz_pixmap_spots(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_spots(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_alpha: Return the number of alpha planes in a pixmap.
/**
Return the number of alpha planes in a pixmap.
Returns the number of alphas. Does not throw exceptions.
*/
int fz_pixmap_alpha(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_alpha(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_samples: Returns a pointer to the pixel data of a pixmap.
/**
Returns a pointer to the pixel data of a pixmap.
Returns the pointer.
*/
unsigned char *fz_pixmap_samples(fz_context *ctx, fz_pixmap *pix);
unsigned char *fz_pixmap_samples(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_stride: Return the number of bytes in a row in the pixmap.
/**
Return the number of bytes in a row in the pixmap.
*/
int fz_pixmap_stride(fz_context *ctx, fz_pixmap *pix);
int fz_pixmap_stride(fz_context *ctx, const fz_pixmap *pix);
/*
fz_pixmap_set_resolution: Set the pixels per inch resolution of the pixmap.
/**
Set the pixels per inch resolution of the pixmap.
*/
void fz_set_pixmap_resolution(fz_context *ctx, fz_pixmap *pix, int xres, int yres);
/*
fz_clear_pixmap_with_value: Clears a pixmap with the given value.
/**
Clears a pixmap with the given value.
pix: The pixmap to clear.
value: Values in the range 0 to 255 are valid. Each component
sample for each pixel in the pixmap will be set to this value,
while alpha will always be set to 255 (non-transparent).
This function is horrible, and should be removed from the
API and replaced with a less magic one.
*/
void fz_clear_pixmap_with_value(fz_context *ctx, fz_pixmap *pix, int value);
/*
/**
Fill pixmap with solid color.
*/
void fz_fill_pixmap_with_color(fz_context *ctx, fz_pixmap *pix, fz_colorspace *colorspace, float *color, const fz_color_params *color_params);
void fz_fill_pixmap_with_color(fz_context *ctx, fz_pixmap *pix, fz_colorspace *colorspace, float *color, fz_color_params color_params);
/*
fz_clear_pixmap_with_value: Clears a subrect of a pixmap with the given value.
/**
Clears a subrect of a pixmap with the given value.
pix: The pixmap to clear.
@@ -244,78 +282,113 @@ void fz_fill_pixmap_with_color(fz_context *ctx, fz_pixmap *pix, fz_colorspace *c
r: the rectangle.
*/
void fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *pix, int value, const fz_irect *r);
void fz_clear_pixmap_rect_with_value(fz_context *ctx, fz_pixmap *pix, int value, fz_irect r);
/*
fz_clear_pixmap_with_value: Sets all components (including alpha) of
/**
Sets all components (including alpha) of
all pixels in a pixmap to 0.
pix: The pixmap to clear.
*/
void fz_clear_pixmap(fz_context *ctx, fz_pixmap *pix);
/*
fz_invert_pixmap: Invert all the pixels in a pixmap. All components
of all pixels are inverted (except alpha, which is unchanged).
/**
Invert all the pixels in a pixmap. All components (process and
spots) of all pixels are inverted (except alpha, which is
unchanged).
*/
void fz_invert_pixmap(fz_context *ctx, fz_pixmap *pix);
/*
fz_tint_pixmap: Tint all the pixels in an RGB or Gray pixmap.
Multiplies all the samples with the input color argument.
r,g,b: The color to tint with, in 0 to 255 range.
/**
Invert the alpha fo all the pixels in a pixmap.
*/
void fz_tint_pixmap(fz_context *ctx, fz_pixmap *pix, int r, int g, int b);
void fz_invert_pixmap_alpha(fz_context *ctx, fz_pixmap *pix);
/*
fz_invert_pixmap: Invert all the pixels in a given rectangle of a
pixmap. All components of all pixels in the rectangle are inverted
(except alpha, which is unchanged).
/**
Transform the pixels in a pixmap so that luminance of each
pixel is inverted, and the chrominance remains unchanged (as
much as accuracy allows).
All components of all pixels are inverted (except alpha, which
is unchanged). Only supports Grey and RGB bitmaps.
*/
void fz_invert_pixmap_rect(fz_context *ctx, fz_pixmap *image, const fz_irect *rect);
void fz_invert_pixmap_luminance(fz_context *ctx, fz_pixmap *pix);
/*
fz_gamma_pixmap: Apply gamma correction to a pixmap. All components
/**
Tint all the pixels in an RGB, BGR, or Gray pixmap.
black: Map black to this hexadecimal RGB color.
white: Map white to this hexadecimal RGB color.
*/
void fz_tint_pixmap(fz_context *ctx, fz_pixmap *pix, int black, int white);
/**
Invert all the pixels in a given rectangle of a (premultiplied)
pixmap. All components of all pixels in the rectangle are
inverted (except alpha, which is unchanged).
*/
void fz_invert_pixmap_rect(fz_context *ctx, fz_pixmap *image, fz_irect rect);
/**
Invert all the pixels in a non-premultiplied pixmap in a
very naive manner.
*/
void fz_invert_pixmap_raw(fz_context *ctx, fz_pixmap *pix);
/**
Apply gamma correction to a pixmap. All components
of all pixels are modified (except alpha, which is unchanged).
gamma: The gamma value to apply; 1.0 for no change.
*/
void fz_gamma_pixmap(fz_context *ctx, fz_pixmap *pix, float gamma);
/*
fz_unmultiply_pixmap: Convert a pixmap from premultiplied to
non-premultiplied format.
*/
void fz_unmultiply_pixmap(fz_context *ctx, fz_pixmap *pix);
/*
fz_convert_pixmap: Convert an existing pixmap to a desired
/**
Convert an existing pixmap to a desired
colorspace. Other properties of the pixmap, such as resolution
and position are copied to the converted pixmap.
pix: The pixmap to convert.
default_cs: If NULL pix->colorspace is used. It is possible that the data
may need to be interpreted as one of the color spaces in default_cs.
default_cs: If NULL pix->colorspace is used. It is possible that
the data may need to be interpreted as one of the color spaces
in default_cs.
cs_des: Desired colorspace, may be NULL to denote alpha-only.
prf: Proofing color space through which we need to convert.
color_params: Parameters that may be used in conversion (e.g. ri).
color_params: Parameters that may be used in conversion (e.g.
ri).
keep_alpha: If 0 any alpha component is removed, otherwise
alpha is kept if present in the pixmap.
*/
fz_pixmap *fz_convert_pixmap(fz_context *ctx, fz_pixmap *pix, fz_colorspace *cs_des, fz_colorspace *prf, fz_default_colorspaces *default_cs, const fz_color_params *color_params, int keep_alpha);
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);
/*
Pixmaps represent a set of pixels for a 2 dimensional region of a
plane. Each pixel has n components per pixel, the last of which is
always alpha. The data is in premultiplied alpha when rendering, but
non-premultiplied for colorspace conversions and rescaling.
/**
Check if the pixmap is a 1-channel image containing samples with
only values 0 and 255
*/
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);
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);
/**
Pixmaps represent a set of pixels for a 2 dimensional region of
a plane. Each pixel has n components per pixel. The components
are in the order process-components, spot-colors, alpha, where
there can be 0 of any of those types. The data is in
premultiplied alpha when rendering, but non-premultiplied for
colorspace conversions and rescaling.
x, y: The minimum x and y coord of the region in pixels.
@@ -341,15 +414,20 @@ fz_pixmap *fz_convert_pixmap(fz_context *ctx, fz_pixmap *pix, fz_colorspace *cs_
xres, yres: Image resolution in dpi. Default is 96 dpi.
colorspace: Pointer to a colorspace object describing the colorspace
the pixmap is in. If NULL, the image is a mask.
colorspace: Pointer to a colorspace object describing the
colorspace the pixmap is in. If NULL, the image is a mask.
samples: A simple block of memory w * h * n bytes of memory in which
the components are stored. The first n bytes are components 0 to n-1
for the pixel at (x,y). Each successive n bytes gives another pixel
in scanline order. Subsequent scanlines follow on with no padding.
samples: Pointer to the first byte of the pixmap sample data.
This is typically a simple block of memory w * h * n bytes of
memory in which the components are stored linearly, but with the
use of appropriate stride values, scanlines can be stored in
different orders, and have different amounts of padding. The
first n bytes are components 0 to n-1 for the pixel at (x,y).
Each successive n bytes gives another pixel in scanline order
as we move across the line. The start of each scanline is offset
the start of the previous one by stride bytes.
*/
struct fz_pixmap_s
struct fz_pixmap
{
fz_storable storable;
int x, y, w, h;
@@ -371,56 +449,53 @@ enum
FZ_PIXMAP_FLAG_FREE_SAMPLES = 2
};
void fz_drop_pixmap_imp(fz_context *ctx, fz_storable *pix);
/* 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, const fz_point points[4], int width, int height);
void fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, const fz_irect *r, const fz_default_colorspaces *default_cs);
void fz_premultiply_pixmap(fz_context *ctx, fz_pixmap *pix);
fz_pixmap *fz_alpha_from_gray(fz_context *ctx, fz_pixmap *gray);
size_t fz_pixmap_size(fz_context *ctx, fz_pixmap *pix);
/*
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);
fz_pixmap *fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, fz_irect *clip);
/*
* 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);
typedef struct fz_scale_cache_s fz_scale_cache;
/*
* 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);
fz_scale_cache *fz_new_scale_cache(fz_context *ctx);
void fz_drop_scale_cache(fz_context *ctx, fz_scale_cache *cache);
fz_pixmap *fz_scale_pixmap_cached(fz_context *ctx, const fz_pixmap *src, float x, float y, float w, float h, const fz_irect *clip, fz_scale_cache *cache_x, fz_scale_cache *cache_y);
/*
* 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);
fz_irect *fz_pixmap_bbox_no_ctx(const fz_pixmap *src, fz_irect *bbox);
void fz_decode_tile(fz_context *ctx, fz_pixmap *pix, const float *decode);
void fz_decode_indexed_tile(fz_context *ctx, fz_pixmap *pix, const float *decode, int maxval);
void fz_unpack_tile(fz_context *ctx, fz_pixmap *dst, unsigned char * restrict src, int n, int depth, size_t stride, int scale);
/*
fz_pixmap_converter: Color convert a pixmap. The passing of default_cs is needed due to the base cs of the image possibly
needing to be treated as being in one of the page default color spaces.
*/
typedef void (fz_pixmap_converter)(fz_context *ctx, fz_pixmap *dp, fz_pixmap *sp, fz_colorspace *prf, const fz_default_colorspaces *default_cs, const fz_color_params *color_params, int copy_spots);
fz_pixmap_converter *fz_lookup_pixmap_converter(fz_context *ctx, fz_colorspace *ds, fz_colorspace *ss);
/*
fz_md5_pixmap: Return the md5 digest for a pixmap
*/
void fz_md5_pixmap(fz_context *ctx, fz_pixmap *pixmap, unsigned char digest[16]);
fz_pixmap *fz_new_pixmap_from_8bpp_data(fz_context *ctx, int x, int y, int w, int h, unsigned char *sp, int span);
fz_pixmap *fz_new_pixmap_from_1bpp_data(fz_context *ctx, int x, int y, int w, int h, unsigned char *sp, int span);
#ifdef HAVE_VALGRIND
int fz_valgrind_pixmap(const fz_pixmap *pix);
#else
#define fz_valgrind_pixmap(pix) do {} while (0)
#endif
/*
fz_clone_pixmap_area_with_different_seps: 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, const fz_color_params *color_params, fz_default_colorspaces *default_cs);
fz_pixmap *fz_copy_pixmap_area_converting_seps(fz_context *ctx, fz_pixmap *dst, fz_pixmap *src, const fz_color_params *color_params, fz_colorspace *prf, fz_default_colorspaces *default_cs);
* 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

56
include/mupdf/fitz/pool.h
View File

@@ -1,14 +1,68 @@
// Copyright (C) 2004-2021 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_POOL_H
#define MUPDF_FITZ_POOL_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
typedef struct fz_pool_s fz_pool;
/**
Simple pool allocators.
Allocate from the pool, which can then be freed at once.
*/
typedef struct fz_pool fz_pool;
/**
Create a new pool to allocate from.
*/
fz_pool *fz_new_pool(fz_context *ctx);
/**
Allocate a block of size bytes from the pool.
*/
void *fz_pool_alloc(fz_context *ctx, fz_pool *pool, size_t size);
/**
strdup equivalent allocating from the pool.
*/
char *fz_pool_strdup(fz_context *ctx, fz_pool *pool, const char *s);
/**
The current size of the pool.
The number of bytes of storage currently allocated to the pool.
This is the total of the storage used for the blocks making
up the pool, rather then total of the allocated blocks so far,
so it will increase in 'lumps'.
from the pool, then the pool size may still be X
*/
size_t fz_pool_size(fz_context *ctx, fz_pool *pool);
/**
Drop a pool, freeing and invalidating all storage returned from
the pool.
*/
void fz_drop_pool(fz_context *ctx, fz_pool *pool);
#endif

112
include/mupdf/fitz/separation.h
View File

@@ -1,10 +1,33 @@
// Copyright (C) 2004-2021 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_SEPARATION_H
#define MUPDF_FITZ_SEPARATION_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/color.h"
/*
/**
A fz_separation structure holds details of a set of separations
(such as might be used on within a page of the document).
@@ -17,7 +40,7 @@ enum
FZ_MAX_SEPARATIONS = 64
};
typedef struct fz_separations_s fz_separations;
typedef struct fz_separations fz_separations;
typedef enum
{
@@ -31,54 +54,85 @@ typedef enum
FZ_SEPARATION_DISABLED = 2
} fz_separation_behavior;
/* Create a new separations structure (initially empty) */
/**
Create a new separations structure (initially empty)
*/
fz_separations *fz_new_separations(fz_context *ctx, int controllable);
/* Keep a reference */
/**
Increment the reference count for a separations structure.
Returns the same pointer.
Never throws exceptions.
*/
fz_separations *fz_keep_separations(fz_context *ctx, fz_separations *sep);
/* Drop a reference */
/**
Decrement the reference count for a separations structure.
When the reference count hits zero, the separations structure
is freed.
Never throws exceptions.
*/
void fz_drop_separations(fz_context *ctx, fz_separations *sep);
/* Add a separation (null terminated name, colorspace) */
/**
Add a separation (null terminated name, colorspace)
*/
void fz_add_separation(fz_context *ctx, fz_separations *sep, const char *name, fz_colorspace *cs, int cs_channel);
/* Add a separation with equivalents (null terminated name, colorspace) (old, deprecated) */
/**
Add a separation with equivalents (null terminated name,
colorspace)
(old, deprecated)
*/
void fz_add_separation_equivalents(fz_context *ctx, fz_separations *sep, uint32_t rgba, uint32_t cmyk, const char *name);
/* Control the rendering of a given separation */
/**
Control the rendering of a given separation.
*/
void fz_set_separation_behavior(fz_context *ctx, fz_separations *sep, int separation, fz_separation_behavior behavior);
/* Test for the current behavior of a separation */
/**
Test for the current behavior of a separation.
*/
fz_separation_behavior fz_separation_current_behavior(fz_context *ctx, const fz_separations *sep, int separation);
/* Quick test for all separations composite (the common case) */
int fz_separations_all_composite(fz_context *ctx, const fz_separations *sep);
/* Read separation name */
const char *fz_separation_name(fz_context *ctx, const fz_separations *sep, int separation);
/* Count the number of separations */
int fz_count_separations(fz_context *ctx, const fz_separations *sep);
/* Find out if separations are controllable. */
int fz_separations_controllable(fz_context *ctx, const fz_separations *seps);
/* Return the number of active separations. */
/**
Return the number of active separations.
*/
int fz_count_active_separations(fz_context *ctx, const fz_separations *seps);
/* Return a separations object with all the spots in the input
* separations object that are set to composite, reset to be
* enabled. If there ARE no spots in the object, this returns
* NULL. If the object already has all its spots enabled, then
* just returns another handle on the same object. */
/**
Compare 2 separations structures (or NULLs).
Return 0 if identical, non-zero if not identical.
*/
int fz_compare_separations(fz_context *ctx, const fz_separations *sep1, const fz_separations *sep2);
/**
Return a separations object with all the spots in the input
separations object that are set to composite, reset to be
enabled. If there ARE no spots in the object, this returns
NULL. If the object already has all its spots enabled, then
just returns another handle on the same object.
*/
fz_separations *fz_clone_separations_for_overprint(fz_context *ctx, fz_separations *seps);
/* Convert a color given in terms of one colorspace,
* to a color in terms of another colorspace/separations. */
void fz_convert_separation_colors(fz_context *ctx, const fz_color_params *color_params, const fz_colorspace *dst_cs, const fz_separations *dst_sep, float *dst_color, const fz_colorspace *src_cs, const float *src_color);
/**
Convert a color given in terms of one colorspace,
to a color in terms of another colorspace/separations.
*/
void fz_convert_separation_colors(fz_context *ctx, fz_colorspace *src_cs, const float *src_color, fz_separations *dst_seps, fz_colorspace *dst_cs, float *dst_color, fz_color_params color_params);
/* Get the equivalent separation color in a given colorspace. */
void fz_separation_equivalent(fz_context *ctx, const fz_separations *seps, int i, const fz_color_params *color_params, const fz_colorspace *dst_cs, const fz_colorspace *prf, float *convert);
/**
Get the equivalent separation color in a given colorspace.
*/
void fz_separation_equivalent(fz_context *ctx, const fz_separations *seps, int idx, fz_colorspace *dst_cs, float *dst_color, fz_colorspace *prf, fz_color_params color_params);
#endif

125
include/mupdf/fitz/shade.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_SHADE_H
#define MUPDF_FITZ_SHADE_H
@@ -5,11 +27,10 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/store.h"
#include "mupdf/fitz/colorspace.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/compressed-buffer.h"
/*
/**
* The shading code uses gouraud shaded triangle meshes.
*/
@@ -24,11 +45,11 @@ enum
FZ_MESH_TYPE7 = 7
};
/*
/**
Structure is public to allow derived classes. Do not
access the members directly.
*/
typedef struct fz_shade_s
typedef struct
{
fz_storable storable;
@@ -40,12 +61,14 @@ typedef struct fz_shade_s
float background[FZ_MAX_COLORS];
/* Just to be confusing, PDF Shadings of Type 1 (Function Based
* Shadings), do NOT use_function, but all the others do. This
* Shadings), do NOT use function, but all the others do. This
* is because Type 1 shadings take 2 inputs, whereas all the
* others (when used with a function take 1 input. The type 1
* data is in the 'f' field of the union below. */
int use_function;
float function[256][FZ_MAX_COLORS + 1];
/* If function_stride = 0, then function is not used. Otherwise
* function points to 256*function_stride entries. */
int function_stride;
float *function;
int type; /* function, linear, radial, mesh */
union
@@ -79,33 +102,24 @@ typedef struct fz_shade_s
fz_compressed_buffer *buffer;
} fz_shade;
/*
fz_keep_shade: Add a reference to a fz_shade.
/**
Increment the reference count for the shade structure. The
same pointer is returned.
shade: The reference to keep.
Returns shade.
Never throws exceptions.
*/
fz_shade *fz_keep_shade(fz_context *ctx, fz_shade *shade);
/*
fz_drop_shade: Drop a reference to a fz_shade.
/**
Decrement the reference count for the shade structure. When
the reference count hits zero, the structure is freed.
shade: The reference to drop. If this is the last
reference, shade will be destroyed.
Never throws exceptions.
*/
void fz_drop_shade(fz_context *ctx, fz_shade *shade);
/*
fz_drop_shade_imp: Internal function to destroy a
shade. Only exposed for use with the fz_store.
shade: The reference to destroy.
*/
void fz_drop_shade_imp(fz_context *ctx, fz_storable *shade);
/*
fz_bound_shade: Bound a given shading.
/**
Bound a given shading.
shade: The shade to bound.
@@ -115,10 +129,14 @@ void fz_drop_shade_imp(fz_context *ctx, fz_storable *shade);
Returns r, updated to contain the bounds for the shading.
*/
fz_rect *fz_bound_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_rect *r);
fz_rect fz_bound_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm);
/*
fz_paint_shade: Render a shade to a given pixmap.
typedef struct fz_shade_color_cache fz_shade_color_cache;
void fz_drop_shade_color_cache(fz_context *ctx, fz_shade_color_cache *cache);
/**
Render a shade to a given pixmap.
shade: The shade to paint.
@@ -134,23 +152,25 @@ fz_rect *fz_bound_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm,
bbox: Pointer to a bounding box to limit the rendering
of the shade.
op: NULL, or pointer to overprint bitmap.
*/
void fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_colorspace *override_cs, const fz_matrix *ctm, fz_pixmap *dest, const fz_color_params *color_params, const fz_irect *bbox, const fz_overprint *op);
eop: NULL, or pointer to overprint bitmap.
/*
cache: *cache is used to cache color information. If *cache is NULL it
is set to point to a new fz_shade_color_cache. If cache is NULL it is
ignored.
*/
void fz_paint_shade(fz_context *ctx, fz_shade *shade, fz_colorspace *override_cs, fz_matrix ctm, fz_pixmap *dest, fz_color_params color_params, fz_irect bbox, const fz_overprint *eop, fz_shade_color_cache **cache);
/**
* Handy routine for processing mesh based shades
*/
typedef struct fz_vertex_s fz_vertex;
struct fz_vertex_s
typedef struct
{
fz_point p;
float c[FZ_MAX_COLORS];
};
} fz_vertex;
/*
fz_shade_prepare_fn: Callback function type for use with
/**
Callback function type for use with
fz_process_shade.
arg: Opaque pointer from fz_process_shade caller.
@@ -161,8 +181,8 @@ struct fz_vertex_s
*/
typedef void (fz_shade_prepare_fn)(fz_context *ctx, void *arg, fz_vertex *v, const float *c);
/*
fz_shade_process_fn: Callback function type for use with
/**
Callback function type for use with
fz_process_shade.
arg: Opaque pointer from fz_process_shade caller.
@@ -173,11 +193,11 @@ typedef void (fz_shade_prepare_fn)(fz_context *ctx, void *arg, fz_vertex *v, con
*/
typedef void (fz_shade_process_fn)(fz_context *ctx, void *arg, fz_vertex *av, fz_vertex *bv, fz_vertex *cv);
/*
fz_process_shade: Process a shade, using supplied callback
functions. This decomposes the shading to a mesh (even ones
that are not natively meshes, such as linear or radial
shadings), and processes triangles from those meshes.
/**
Process a shade, using supplied callback functions. This
decomposes the shading to a mesh (even ones that are not
natively meshes, such as linear or radial shadings), and
processes triangles from those meshes.
shade: The shade to process.
@@ -194,9 +214,20 @@ typedef void (fz_shade_process_fn)(fz_context *ctx, void *arg, fz_vertex *av, fz
process_arg: An opaque argument passed through from caller
to callback functions.
*/
void fz_process_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm,
void fz_process_shade(fz_context *ctx, fz_shade *shade, fz_matrix ctm, fz_rect scissor,
fz_shade_prepare_fn *prepare,
fz_shade_process_fn *process,
void *process_arg);
/* Implementation details: subject to change. */
/**
Internal function to destroy a
shade. Only exposed for use with the fz_store.
shade: The reference to destroy.
*/
void fz_drop_shade_imp(fz_context *ctx, fz_storable *shade);
#endif

350
include/mupdf/fitz/store.h
View File

@@ -1,115 +1,220 @@
// Copyright (C) 2004-2021 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_STORE_H
#define MUPDF_FITZ_STORE_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/log.h"
/*
/**
Resource store
MuPDF stores decoded "objects" into a store for potential reuse.
If the size of the store gets too big, objects stored within it can
be evicted and freed to recover space. When MuPDF comes to decode
such an object, it will check to see if a version of this object is
already in the store - if it is, it will simply reuse it. If not, it
will decode it and place it into the store.
If the size of the store gets too big, objects stored within it
can be evicted and freed to recover space. When MuPDF comes to
decode such an object, it will check to see if a version of this
object is already in the store - if it is, it will simply reuse
it. If not, it will decode it and place it into the store.
All objects that can be placed into the store are derived from the
fz_storable type (i.e. this should be the first component of the
objects structure). This allows for consistent (thread safe)
reference counting, and includes a function that will be called to
free the object as soon as the reference count reaches zero.
All objects that can be placed into the store are derived from
the fz_storable type (i.e. this should be the first component of
the objects structure). This allows for consistent (thread safe)
reference counting, and includes a function that will be called
to free the object as soon as the reference count reaches zero.
Most objects offer fz_keep_XXXX/fz_drop_XXXX functions derived
from fz_keep_storable/fz_drop_storable. Creation of such objects
includes a call to FZ_INIT_STORABLE to set up the fz_storable header.
includes a call to FZ_INIT_STORABLE to set up the fz_storable
header.
*/
typedef struct fz_storable fz_storable;
typedef struct fz_storable_s fz_storable;
typedef struct fz_key_storable_s fz_key_storable;
/**
Function type for a function to drop a storable object.
Objects within the store are identified by type by comparing
their drop_fn pointers.
*/
typedef void (fz_store_drop_fn)(fz_context *, fz_storable *);
struct fz_storable_s {
/**
Function type for a function to check whether a storable
object can be dropped at the moment.
Return 0 for 'cannot be dropped', 1 otherwise.
*/
typedef int (fz_store_droppable_fn)(fz_context *, fz_storable *);
/**
Any storable object should include an fz_storable structure
at the start (by convention at least) of their structure.
(Unless it starts with an fz_key_storable, see below).
*/
struct fz_storable {
int refs;
fz_store_drop_fn *drop;
fz_store_droppable_fn *droppable;
};
struct fz_key_storable_s {
/**
Any storable object that can appear in the key of another
storable object should include an fz_key_storable structure
at the start (by convention at least) of their structure.
*/
typedef struct
{
fz_storable storable;
short store_key_refs;
};
} fz_key_storable;
/**
Macros to initialise a storable object.
*/
#define FZ_INIT_STORABLE(S_,RC,DROP) \
do { fz_storable *S = &(S_)->storable; S->refs = (RC); \
S->drop = (DROP); \
S->drop = (DROP); S->droppable = NULL; \
} while (0)
#define FZ_INIT_AWKWARD_STORABLE(S_,RC,DROP,DROPPABLE) \
do { fz_storable *S = &(S_)->storable; S->refs = (RC); \
S->drop = (DROP); S->droppable = (DROPPABLE); \
} while (0)
/**
Macro to initialise a key storable object.
*/
#define FZ_INIT_KEY_STORABLE(KS_,RC,DROP) \
do { fz_key_storable *KS = &(KS_)->key_storable; KS->store_key_refs = 0;\
FZ_INIT_STORABLE(KS,RC,DROP); \
} while (0)
/**
Increment the reference count for a storable object.
Returns the same pointer.
Never throws exceptions.
*/
void *fz_keep_storable(fz_context *, const fz_storable *);
/**
Decrement the reference count for a storable object. When the
reference count hits zero, the drop function for that object
is called to free the object.
Never throws exceptions.
*/
void fz_drop_storable(fz_context *, const fz_storable *);
/**
Increment the (normal) reference count for a key storable
object. Returns the same pointer.
Never throws exceptions.
*/
void *fz_keep_key_storable(fz_context *, const fz_key_storable *);
/**
Decrement the (normal) reference count for a storable object.
When the total reference count hits zero, the drop function for
that object is called to free the object.
Never throws exceptions.
*/
void fz_drop_key_storable(fz_context *, const fz_key_storable *);
/**
Increment the (key) reference count for a key storable
object. Returns the same pointer.
Never throws exceptions.
*/
void *fz_keep_key_storable_key(fz_context *, const fz_key_storable *);
/**
Decrement the (key) reference count for a storable object.
When the total reference count hits zero, the drop function for
that object is called to free the object.
Never throws exceptions.
*/
void fz_drop_key_storable_key(fz_context *, const fz_key_storable *);
/*
The store can be seen as a dictionary that maps keys to fz_storable
values. In order to allow keys of different types to be stored, we
have a structure full of functions for each key 'type'; this
fz_store_type pointer is stored with each key, and tells the store
how to perform certain operations (like taking/dropping a reference,
comparing two keys, outputting details for debugging etc).
/**
The store can be seen as a dictionary that maps keys to
fz_storable values. In order to allow keys of different types to
be stored, we have a structure full of functions for each key
'type'; this fz_store_type pointer is stored with each key, and
tells the store how to perform certain operations (like taking/
dropping a reference, comparing two keys, outputting details for
debugging etc).
The store uses a hash table internally for speed where possible. In
order for this to work, we need a mechanism for turning a generic
'key' into 'a hashable string'. For this purpose the type structure
contains a make_hash_key function pointer that maps from a void *
to a fz_store_hash structure. If make_hash_key function returns 0,
then the key is determined not to be hashable, and the value is
not stored in the hash table.
The store uses a hash table internally for speed where possible.
In order for this to work, we need a mechanism for turning a
generic 'key' into 'a hashable string'. For this purpose the
type structure contains a make_hash_key function pointer that
maps from a void * to a fz_store_hash structure. If
make_hash_key function returns 0, then the key is determined not
to be hashable, and the value is not stored in the hash table.
Some objects can be used both as values within the store, and as a
component of keys within the store. We refer to these objects as
"key storable" objects. In this case, we need to take additional
care to ensure that we do not end up keeping an item within the
store, purely because its value is referred to by another key in
the store.
Some objects can be used both as values within the store, and as
a component of keys within the store. We refer to these objects
as "key storable" objects. In this case, we need to take
additional care to ensure that we do not end up keeping an item
within the store, purely because its value is referred to by
another key in the store.
An example of this are fz_images in PDF files. Each fz_image is
placed into the store to enable it to be easily reused. When the
image is rendered, a pixmap is generated from the image, and the
pixmap is placed into the store so it can be reused on subsequent
renders. The image forms part of the key for the pixmap.
pixmap is placed into the store so it can be reused on
subsequent renders. The image forms part of the key for the
pixmap.
When we close the pdf document (and any associated pages/display
lists etc), we drop the images from the store. This may leave us
in the position of the images having non-zero reference counts
purely because they are used as part of the keys for the pixmaps.
purely because they are used as part of the keys for the
pixmaps.
We therefore use special reference counting functions to keep
track of these "key storable" items, and hence store the number of
references to these items that are used in keys.
track of these "key storable" items, and hence store the number
of references to these items that are used in keys.
When the number of references to an object == the number of
references to an object from keys in the store, we know that we can
remove all the items which have that object as part of the key.
This is done by running a pass over the store, 'reaping' those
items.
references to an object from keys in the store, we know that we
can remove all the items which have that object as part of the
key. This is done by running a pass over the store, 'reaping'
those items.
Reap passes are slower than we would like as they touch every
item in the store. We therefore provide a way to 'batch' such
reap passes together, using fz_defer_reap_start/fz_defer_reap_end
to bracket a region in which many may be triggered.
reap passes together, using fz_defer_reap_start/
fz_defer_reap_end to bracket a region in which many may be
triggered.
*/
typedef struct fz_store_hash_s
typedef struct
{
fz_store_drop_fn *drop;
union
@@ -128,60 +233,76 @@ typedef struct fz_store_hash_s
struct
{
int id;
char has_shape;
char has_group_alpha;
float m[4];
void *ptr;
} im; /* 20 bytes */
} im; /* 28 or 32 bytes */
struct
{
unsigned char src_md5[16];
unsigned char dst_md5[16];
unsigned int ri:2;
unsigned int bp:1;
unsigned int bpp16:1;
unsigned int format:1;
unsigned int proof:1;
unsigned int src_extras:5;
unsigned int dst_extras:5;
unsigned int copy_spots:1;
unsigned int bgr:1;
} link; /* 36 bytes */
} u;
} fz_store_hash; /* 40 or 44 bytes */
typedef struct fz_store_type_s
/**
Every type of object to be placed into the store defines an
fz_store_type. This contains the pointers to functions to
make hashes, manipulate keys, and check for needing reaping.
*/
typedef struct
{
const char *name;
int (*make_hash_key)(fz_context *ctx, fz_store_hash *hash, void *key);
void *(*keep_key)(fz_context *ctx, void *key);
void (*drop_key)(fz_context *ctx, void *key);
int (*cmp_key)(fz_context *ctx, void *a, void *b);
void (*format_key)(fz_context *ctx, char *buf, int size, void *key);
void (*format_key)(fz_context *ctx, char *buf, size_t size, void *key);
int (*needs_reap)(fz_context *ctx, void *key);
} fz_store_type;
/*
fz_store_new_context: Create a new store inside the context
/**
Create a new store inside the context
max: The maximum size (in bytes) that the store is allowed to grow
to. FZ_STORE_UNLIMITED means no limit.
max: The maximum size (in bytes) that the store is allowed to
grow to. FZ_STORE_UNLIMITED means no limit.
*/
void fz_new_store_context(fz_context *ctx, size_t max);
/*
fz_drop_store_context: Drop a reference to the store.
*/
void fz_drop_store_context(fz_context *ctx);
/**
Increment the reference count for the store context. Returns
the same pointer.
/*
fz_keep_store_context: Take a reference to the store.
Never throws exceptions.
*/
fz_store *fz_keep_store_context(fz_context *ctx);
/*
fz_store_item: Add an item to the store.
/**
Decrement the reference count for the store context. When the
reference count hits zero, the store context is freed.
Add an item into the store, returning NULL for success. If an item
with the same key is found in the store, then our item will not be
inserted, and the function will return a pointer to that value
instead. This function takes its own reference to val, as required
(i.e. the caller maintains ownership of its own reference).
Never throws exceptions.
*/
void fz_drop_store_context(fz_context *ctx);
/**
Add an item to the store.
Add an item into the store, returning NULL for success. If an
item with the same key is found in the store, then our item will
not be inserted, and the function will return a pointer to that
value instead. This function takes its own reference to val, as
required (i.e. the caller maintains ownership of its own
reference).
key: The key used to index the item.
@@ -194,28 +315,29 @@ fz_store *fz_keep_store_context(fz_context *ctx);
*/
void *fz_store_item(fz_context *ctx, void *key, void *val, size_t itemsize, const fz_store_type *type);
/*
fz_find_item: Find an item within the store.
/**
Find an item within the store.
drop: The function used to free the value (to ensure we get a value
of the correct type).
drop: The function used to free the value (to ensure we get a
value of the correct type).
key: The key used to index the item.
type: Functions used to manipulate the key.
Returns NULL for not found, otherwise returns a pointer to the value
indexed by key to which a reference has been taken.
Returns NULL for not found, otherwise returns a pointer to the
value indexed by key to which a reference has been taken.
*/
void *fz_find_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, const fz_store_type *type);
/*
fz_remove_item: Remove an item from the store.
/**
Remove an item from the store.
If an item indexed by the given key exists in the store, remove it.
If an item indexed by the given key exists in the store, remove
it.
drop: The function used to free the value (to ensure we get a value
of the correct type).
drop: The function used to free the value (to ensure we get a
value of the correct type).
key: The key used to find the item to remove.
@@ -223,16 +345,16 @@ void *fz_find_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, const fz_
*/
void fz_remove_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, const fz_store_type *type);
/*
fz_empty_store: Evict everything from the store.
/**
Evict every item from the store.
*/
void fz_empty_store(fz_context *ctx);
/*
fz_store_scavenge: Internal function used as part of the scavenging
/**
Internal function used as part of the scavenging
allocator; when we fail to allocate memory, before returning a
failure to the caller, we try to scavenge space within the store by
evicting at least 'size' bytes. The allocator then retries.
failure to the caller, we try to scavenge space within the store
by evicting at least 'size' bytes. The allocator then retries.
size: The number of bytes we are trying to have free.
@@ -242,8 +364,8 @@ void fz_empty_store(fz_context *ctx);
*/
int fz_store_scavenge(fz_context *ctx, size_t size, int *phase);
/*
fz_store_scavenge_external: External function for callers to use
/**
External function for callers to use
to scavenge while trying allocations.
size: The number of bytes we are trying to have free.
@@ -254,28 +376,42 @@ int fz_store_scavenge(fz_context *ctx, size_t size, int *phase);
*/
int fz_store_scavenge_external(fz_context *ctx, size_t size, int *phase);
/*
fz_shrink_store: Evict items from the store until the total size of
/**
Evict items from the store until the total size of
the objects in the store is reduced to a given percentage of its
current size.
percent: %age of current size to reduce the store to.
Returns non zero if we managed to free enough memory, zero otherwise.
Returns non zero if we managed to free enough memory, zero
otherwise.
*/
int fz_shrink_store(fz_context *ctx, unsigned int percent);
/**
Callback function called by fz_filter_store on every item within
the store.
Return 1 to drop the item from the store, 0 to retain.
*/
typedef int (fz_store_filter_fn)(fz_context *ctx, void *arg, void *key);
/**
Filter every element in the store with a matching type with the
given function.
If the function returns 1 for an element, drop the element.
*/
void fz_filter_store(fz_context *ctx, fz_store_filter_fn *fn, void *arg, const fz_store_type *type);
/*
fz_debug_store: Dump the contents of the store for debugging.
/**
Output debugging information for the current state of the store
to the given output channel.
*/
void fz_debug_store(fz_context *ctx);
void fz_debug_store(fz_context *ctx, fz_output *out);
/*
fz_defer_reap_start: Increment the defer reap count.
/**
Increment the defer reap count.
No reap operations will take place (except for those
triggered by an immediate failed malloc) until the
@@ -289,8 +425,8 @@ void fz_debug_store(fz_context *ctx);
*/
void fz_defer_reap_start(fz_context *ctx);
/*
fz_defer_reap_end: Decrement the defer reap count.
/**
Decrement the defer reap count.
If the defer reap count returns to 0, and the store
has reapable objects in, a reap pass will begin.
@@ -303,4 +439,18 @@ void fz_defer_reap_start(fz_context *ctx);
*/
void fz_defer_reap_end(fz_context *ctx);
#ifdef ENABLE_STORE_LOGGING
void fz_log_dump_store(fz_context *ctx, const char *fmt, ...);
#define FZ_LOG_STORE(CTX, ...) fz_log_module(CTX, "STORE", __VA_ARGS__)
#define FZ_LOG_DUMP_STORE(...) fz_log_dump_store(__VA_ARGS__)
#else
#define FZ_LOG_STORE(...) do {} while (0)
#define FZ_LOG_DUMP_STORE(...) do {} while (0)
#endif
#endif

209
include/mupdf/fitz/story-writer.h Normal file
View File

@@ -0,0 +1,209 @@
// Copyright (C) 2022 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_STORY_WRITER_H
#define MUPDF_FITZ_STORY_WRITER_H
#include "mupdf/fitz/story.h"
#include "mupdf/fitz/writer.h"
/*
* A fz_story_element_position plus page number information; used with
* fz_write_story() and fz_write_stabilized_story().
*/
typedef struct
{
fz_story_element_position element;
int page_num;
} fz_write_story_position;
/*
* A set of fz_write_story_position items; used with
* fz_write_stabilized_story().
*/
typedef struct
{
fz_write_story_position *positions;
int num;
} fz_write_story_positions;
/*
* Callback type used by fz_write_story() and fz_write_stabilized_story().
*
* Should set *rect to rect number <num>. If this is on a new page should also
* set *mediabox and return 1, otherwise return 0.
*
* ref:
* As passed to fz_write_story() or fz_write_stabilized_story().
* num:
* The rect number. Will typically increment by one each time, being reset
* to zero when fz_write_stabilized_story() starts a new iteration.
* filled:
* From earlier internal call to fz_place_story().
* rect:
* Out param.
* ctm:
* Out param, defaults to fz_identity.
* mediabox:
* Out param, only used if we return 1.
*/
typedef int (fz_write_story_rectfn)(fz_context *ctx, void *ref, int num, fz_rect filled, fz_rect *rect, fz_matrix *ctm, fz_rect *mediabox);
/*
* Callback used by fz_write_story() to report information about element
* positions. Slightly different from fz_story_position_callback() because
* <position> also includes the page number.
*
* ref:
* As passed to fz_write_story() or fz_write_stabilized_story().
* position:
* Called via internal call to fz_story_position_callback().
*/
typedef void (fz_write_story_positionfn)(fz_context *ctx, void *ref, const fz_write_story_position *position);
/*
* Callback for fz_write_story(), called twice for each page, before (after=0)
* and after (after=1) the story is written.
*
* ref:
* As passed to fz_write_story() or fz_write_stabilized_story().
* page_num:
* Page number, starting from 1.
* mediabox:
* As returned from fz_write_story_rectfn().
* dev:
* Created from the fz_writer passed to fz_write_story() or
* fz_write_stabilized_story().
* after:
* 0 - before writing the story.
* 1 - after writing the story.
*/
typedef void (fz_write_story_pagefn)(fz_context *ctx, void *ref, int page_num, fz_rect mediabox, fz_device *dev, int after);
/*
* Callback type for fz_write_stabilized_story().
*
* Should populate the supplied buffer with html content for use with internal
* calls to fz_new_story(). This may include extra content derived from
* information in <positions>, for example a table of contents.
*
* ref:
* As passed to fz_write_stabilized_story().
* positions:
* Information from previous iteration.
* buffer:
* Where to write the new content. Will be initially empty.
*/
typedef void (fz_write_story_contentfn)(fz_context *ctx, void *ref, const fz_write_story_positions *positions, fz_buffer *buffer);
/*
* Places and writes a story to a fz_document_writer. Avoids the need
* for calling code to implement a loop that calls fz_place_story()
* and fz_draw_story() etc, at the expense of having to provide a
* fz_write_story_rectfn() callback.
*
* story:
* The story to place and write.
* writer:
* Where to write the story; can be NULL.
* rectfn:
* Should return information about the rect to be used in the next
* internal call to fz_place_story().
* rectfn_ref:
* Passed to rectfn().
* positionfn:
* If not NULL, is called via internal calls to fz_story_positions().
* positionfn_ref:
* Passed to positionfn().
* pagefn:
* If not NULL, called at start and end of each page (before and after all
* story content has been written to the device).
* pagefn_ref:
* Passed to pagefn().
*/
void fz_write_story(
fz_context *ctx,
fz_document_writer *writer,
fz_story *story,
fz_write_story_rectfn rectfn,
void *rectfn_ref,
fz_write_story_positionfn positionfn,
void *positionfn_ref,
fz_write_story_pagefn pagefn,
void *pagefn_ref
);
/*
* Does iterative layout of html content to a fz_document_writer. For example
* this allows one to add a table of contents section while ensuring that page
* numbers are patched up until stable.
*
* Repeatedly creates new story from (contentfn(), contentfn_ref, user_css, em)
* and lays it out with internal call to fz_write_story(); uses a NULL writer
* and populates a fz_write_story_positions which is passed to the next call of
* contentfn().
*
* When the html from contentfn() becomes unchanged, we do a final iteration
* using <writer>.
*
* writer:
* Where to write in the final iteration.
* user_css:
* Used in internal calls to fz_new_story().
* em:
* Used in internal calls to fz_new_story().
* contentfn:
* Should return html content for use with fz_new_story(), possibly
* including extra content such as a table-of-contents.
* contentfn_ref:
* Passed to contentfn().
* rectfn:
* Should return information about the rect to be used in the next
* internal call to fz_place_story().
* rectfn_ref:
* Passed to rectfn().
* fz_write_story_pagefn:
* If not NULL, called at start and end of each page (before and after all
* story content has been written to the device).
* pagefn_ref:
* Passed to pagefn().
* dir:
* NULL, or a directory context to load images etc from.
*/
void fz_write_stabilized_story(
fz_context *ctx,
fz_document_writer *writer,
const char *user_css,
float em,
fz_write_story_contentfn contentfn,
void *contentfn_ref,
fz_write_story_rectfn rectfn,
void *rectfn_ref,
fz_write_story_pagefn pagefn,
void *pagefn_ref,
fz_archive *dir
);
#endif

232
include/mupdf/fitz/story.h Normal file
View File

@@ -0,0 +1,232 @@
// Copyright (C) 2004-2021 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_STORY_H
#define MUPDF_FITZ_STORY_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/device.h"
#include "mupdf/fitz/xml.h"
#include "mupdf/fitz/archive.h"
/*
This header file provides an API for laying out and placing styled
text on a page, or pages.
First a text story is created from some styled HTML.
Next, this story can be laid out into a given rectangle (possibly
retrying several times with updated rectangles as required).
Next, the laid out story can be drawn to a given device.
In the case where the text story cannot be fitted into the given
areas all at once, these two steps can be repeated multiple
times until the text story is completely consumed.
Finally, the text story can be dropped in the usual fashion.
*/
typedef struct fz_story fz_story;
/*
Create a text story using styled html.
Passing a NULL buffer will be treated as an empty document.
Passing a NULL user_css will be treated as an empty CSS string.
A non-NULL dir will allow images etc to be loaded. The
story keeps its own reference, so the caller can drop its
reference after this call.
*/
fz_story *fz_new_story(fz_context *ctx, fz_buffer *buf, const char *user_css, float em, fz_archive *dir);
/*
Retrieve the warnings given from parsing this story.
If there are warnings, this will be returned as a NULL terminated
C string. If there are no warnings, this will return NULL.
These warnings will not be complete until AFTER any DOM manipulations
have been completed.
This function does not need to be called, but once it has been
the DOM is no longer accessible, and any fz_xml pointer
retrieved from fz_story_docment is no longer valid.
*/
const char *fz_story_warnings(fz_context *ctx, fz_story *story);
/*
Equivalent to fz_place_story_flags with flags being 0.
*/
int fz_place_story(fz_context *ctx, fz_story *story, fz_rect where, fz_rect *filled);
/*
Place (or continue placing) a story into the supplied rectangle
'where', updating 'filled' with the actual area that was used.
Returns zero (FZ_PLACE_STORY_RETURN_ALL_FITTED) if all the
content fitted, non-zero if there is more to fit.
If the FZ_PLACE_STORY_FLAG_NO_OVERFLOW flag is set, then a
return code of FZ_PLACE_STORY_RETURN_OVERFLOW_WIDTH will be
returned when the next item (word) to be placed would not fit
in a rectangle of that given width.
Note, that filled may not be returned as a strict subset of
where, due to padding/margins at the bottom of pages, and
non-wrapping content extending to the right.
Subsequent calls will attempt to place the same section of story
again and again, until the placed story is drawn using fz_draw_story,
whereupon subsequent calls to fz_place_story will attempt to place
the unused remainder of the story.
After this function is called, the DOM is no longer accessible,
and any fz_xml pointer retrieved from fz_story_document is no
longer valid.
flags: Additional flags controlling layout. Pass 0 if none
required.
*/
int fz_place_story_flags(fz_context *ctx, fz_story *story, fz_rect where, fz_rect *filled, int flags);
enum
{
/* Avoid the usual HTML behaviour of overflowing the box horizontally
* in some circumstances. We now abort the place in such cases and
* return with */
FZ_PLACE_STORY_FLAG_NO_OVERFLOW = 1,
/* Specific return codes from fz_place_story_flags. Also
* "non-zero" for 'more to fit'. */
FZ_PLACE_STORY_RETURN_ALL_FITTED = 0,
FZ_PLACE_STORY_RETURN_OVERFLOW_WIDTH = 2
};
/*
Draw the placed story to the given device.
This moves the point at which subsequent calls to fz_place_story
will restart placing to the end of what has just been output.
*/
void fz_draw_story(fz_context *ctx, fz_story *story, fz_device *dev, fz_matrix ctm);
/*
Reset the position within the story at which the next layout call
will continue to the start of the story.
*/
void fz_reset_story(fz_context *ctx, fz_story *story);
/*
Drop the html story.
*/
void fz_drop_story(fz_context *ctx, fz_story *story);
/*
Get a borrowed reference to the DOM document pointer for this
story. Do not destroy this reference, it will be destroyed
when the story is laid out.
This only makes sense before the first placement of the story
or retrieval of the warnings. Once either of those things happen
the DOM representation is destroyed.
*/
fz_xml *fz_story_document(fz_context *ctx, fz_story *story);
typedef struct
{
/* The overall depth of this element in the box structure.
* This can be used to compare the relative depths of different
* elements, but shouldn't be relied upon not to change between
* different versions of MuPDF. */
int depth;
/* The heading level of this element. 0 if not a header, or 1-6 for h1-h6. */
int heading;
/* The id for this element. */
const char *id;
/* The href for this element. */
const char *href;
/* The rectangle for this element. */
fz_rect rect;
/* The immediate text for this element. */
const char *text;
/* This indicates whether this opens and/or closes this element.
*
* As we traverse the tree we do a depth first search. In order for
* the caller of fz_story_positions to know whether a given element
* is inside another element, we therefore announce 'start' and 'stop'
* for each element. For instance, with:
*
* <div id="part1">
* <h1>Chapter 1</h1>...
* <h1>Chapter 2</h1>...
* ...
* </div>
* <div id="part2">
* <h1>Chapter 10</h1>...
* <h1>Chapter 11</h1>...
* ...
* </div>
*
* We would announce:
* + id='part1' (open)
* + header=1 "Chapter 1" (open/close)
* + header=1 "Chapter 2" (open/close)
* ...
* + id='part1' (close)
* + id='part2' (open)
* + header=1 "Chapter 10" (open/close)
* + header=1 "Chapter 11" (open/close)
* ...
* + id='part2' (close)
*
* If bit 0 is set, then this 'opens' the element.
* If bit 1 is set, then this 'closes' the element.
*/
int open_close;
/* A count of the number of rectangles that the layout code has split the
* story into so far. After the first layout, this will be 1. If a
* layout is repeated, this number is not incremented. */
int rectangle_num;
} fz_story_element_position;
typedef void (fz_story_position_callback)(fz_context *ctx, void *arg, const fz_story_element_position *);
/*
Enumerate the positions for key blocks in the story.
This will cause the supplied function to be called with details of each
element in the story that is either a header, or has an id.
*/
void fz_story_positions(fz_context *ctx, fz_story *story, fz_story_position_callback *cb, void *arg);
#endif

319
include/mupdf/fitz/stream.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_STREAM_H
#define MUPDF_FITZ_STREAM_H
@@ -5,12 +27,12 @@
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/buffer.h"
/*
fz_file_exists: Return true if the named file exists and is readable.
/**
Return true if the named file exists and is readable.
*/
int fz_file_exists(fz_context *ctx, const char *path);
/*
/**
fz_stream is a buffered reader capable of seeking in both
directions.
@@ -19,24 +41,37 @@ int fz_file_exists(fz_context *ctx, const char *path);
Only the data between rp and wp is valid.
*/
typedef struct fz_stream_s fz_stream;
typedef struct fz_stream fz_stream;
/*
fz_open_file: Open the named file and wrap it in a stream.
/**
Open the named file and wrap it in a stream.
filename: Path to a file. On non-Windows machines the filename should
be exactly as it would be passed to fopen(2). On Windows machines, the
path should be UTF-8 encoded so that non-ASCII characters can be
represented. Other platforms do the encoding as standard anyway (and
in most cases, particularly for MacOS and Linux, the encoding they
use is UTF-8 anyway).
filename: Path to a file. On non-Windows machines the filename
should be exactly as it would be passed to fopen(2). On Windows
machines, the path should be UTF-8 encoded so that non-ASCII
characters can be represented. Other platforms do the encoding
as standard anyway (and in most cases, particularly for MacOS
and Linux, the encoding they use is UTF-8 anyway).
*/
fz_stream *fz_open_file(fz_context *ctx, const char *filename);
fz_stream *fz_open_file_progressive(fz_context *ctx, const char *filename, int bps);
/**
Do the same as fz_open_file, but delete the file upon close.
*/
fz_stream *fz_open_file_autodelete(fz_context *ctx, const char *filename);
/*
fz_open_file_w: Open the named file and wrap it in a stream.
/**
Open the named file and wrap it in a stream.
Does the same as fz_open_file, but in the event the file
does not open, it will return NULL rather than throw an
exception.
*/
fz_stream *fz_try_open_file(fz_context *ctx, const char *name);
#ifdef _WIN32
/**
Open the named file and wrap it in a stream.
This function is only available when compiling for Win32.
@@ -44,12 +79,21 @@ fz_stream *fz_open_file_progressive(fz_context *ctx, const char *filename, int b
to _wfopen().
*/
fz_stream *fz_open_file_w(fz_context *ctx, const wchar_t *filename);
#endif /* _WIN32 */
/*
fz_open_memory: Open a block of memory as a stream.
/**
Return the filename (UTF-8 encoded) from which a stream was opened.
data: Pointer to start of data block. Ownership of the data block is
NOT passed in.
Returns NULL if the filename is not available (or the stream was
opened from a source other than a file).
*/
const char *fz_stream_filename(fz_context *ctx, fz_stream *stm);
/**
Open a block of memory as a stream.
data: Pointer to start of data block. Ownership of the data
block is NOT passed in.
len: Number of bytes in data block.
@@ -58,19 +102,19 @@ fz_stream *fz_open_file_w(fz_context *ctx, const wchar_t *filename);
*/
fz_stream *fz_open_memory(fz_context *ctx, const unsigned char *data, size_t len);
/*
fz_open_buffer: Open a buffer as a stream.
/**
Open a buffer as a stream.
buf: The buffer to open. Ownership of the buffer is NOT passed in
(this function takes its own reference).
buf: The buffer to open. Ownership of the buffer is NOT passed
in (this function takes its own reference).
Returns pointer to newly created stream. May throw exceptions on
failure to allocate.
*/
fz_stream *fz_open_buffer(fz_context *ctx, fz_buffer *buf);
/*
fz_open_leecher: Attach a filter to a stream that will store any
/**
Attach a filter to a stream that will store any
characters read from the stream into the supplied buffer.
chain: The underlying stream to leech from.
@@ -83,33 +127,46 @@ fz_stream *fz_open_buffer(fz_context *ctx, fz_buffer *buf);
*/
fz_stream *fz_open_leecher(fz_context *ctx, fz_stream *chain, fz_buffer *buf);
/*
fz_drop_stream: Close an open stream.
/**
Increments the reference count for a stream. Returns the same
pointer.
Drops a reference for the stream. Once no references remain
the stream will be closed, as will any file descriptor the
stream is using.
Never throws exceptions.
*/
fz_stream *fz_keep_stream(fz_context *ctx, fz_stream *stm);
/**
Decrements the reference count for a stream.
When the reference count for the stream hits zero, frees the
storage used for the fz_stream itself, and (usually)
releases the underlying resources that the stream is based upon
(depends on the method used to open the stream initially).
*/
void fz_drop_stream(fz_context *ctx, fz_stream *stm);
/*
fz_tell: return the current reading position within a stream
/**
return the current reading position within a stream
*/
int64_t fz_tell(fz_context *ctx, fz_stream *stm);
/*
fz_seek: Seek within a stream.
/**
Seek within a stream.
stm: The stream to seek within.
offset: The offset to seek to.
whence: From where the offset is measured (see fseek).
SEEK_SET - start of stream.
SEEK_CUR - current position.
SEEK_END - end of stream.
*/
void fz_seek(fz_context *ctx, fz_stream *stm, int64_t offset, int whence);
/*
fz_read: Read from a stream into a given data block.
/**
Read from a stream into a given data block.
stm: The stream to read from.
@@ -121,8 +178,8 @@ void fz_seek(fz_context *ctx, fz_stream *stm, int64_t offset, int whence);
*/
size_t fz_read(fz_context *ctx, fz_stream *stm, unsigned char *data, size_t len);
/*
fz_skip: Read from a stream discarding data.
/**
Read from a stream discarding data.
stm: The stream to read from.
@@ -132,8 +189,8 @@ size_t fz_read(fz_context *ctx, fz_stream *stm, unsigned char *data, size_t len)
*/
size_t fz_skip(fz_context *ctx, fz_stream *stm, size_t len);
/*
fz_read_all: Read all of a stream into a buffer.
/**
Read all of a stream into a buffer.
stm: The stream to read from
@@ -144,12 +201,20 @@ size_t fz_skip(fz_context *ctx, fz_stream *stm, size_t len);
*/
fz_buffer *fz_read_all(fz_context *ctx, fz_stream *stm, size_t initial);
/*
fz_read_file: Read all the contents of a file into a buffer.
/**
Read all the contents of a file into a buffer.
*/
fz_buffer *fz_read_file(fz_context *ctx, const char *filename);
/*
/**
Read all the contents of a file into a buffer.
Returns NULL if the file does not exist, otherwise
behaves exactly as fz_read_file.
*/
fz_buffer *fz_try_read_file(fz_context *ctx, const char *filename);
/**
fz_read_[u]int(16|24|32|64)(_le)?
Read a 16/32/64 bit signed/unsigned integer from stream,
@@ -175,41 +240,40 @@ int16_t fz_read_int16_le(fz_context *ctx, fz_stream *stm);
int32_t fz_read_int32_le(fz_context *ctx, fz_stream *stm);
int64_t fz_read_int64_le(fz_context *ctx, fz_stream *stm);
/*
fz_read_string: Read a null terminated string from the stream into
float fz_read_float_le(fz_context *ctx, fz_stream *stm);
float fz_read_float(fz_context *ctx, fz_stream *stm);
/**
Read a null terminated string from the stream into
a buffer of a given length. The buffer will be null terminated.
Throws on failure (including the failure to fit the entire string
including the terminator into the buffer).
Throws on failure (including the failure to fit the entire
string including the terminator into the buffer).
*/
void fz_read_string(fz_context *ctx, fz_stream *stm, char *buffer, int len);
enum
{
FZ_STREAM_META_PROGRESSIVE = 1,
FZ_STREAM_META_LENGTH = 2
};
/**
Read a utf-8 rune from a stream.
/*
fz_stream_meta: Perform a meta call on a stream (typically to
request meta information about a stream).
stm: The stream to query.
key: The meta request identifier.
size: Meta request specific parameter - typically the size of
the data block pointed to by ptr.
ptr: Meta request specific parameter - typically a pointer to
a block of data to be filled in.
Returns -1 if this stream does not support this meta operation,
or a meta operation specific return value.
In the event of encountering badly formatted utf-8 codes
(such as a leading code with an unexpected number of following
codes) no error/exception is given, but undefined values may be
returned.
*/
int fz_stream_meta(fz_context *ctx, fz_stream *stm, int key, int size, void *ptr);
int fz_read_rune(fz_context *ctx, fz_stream *in);
/*
fz_stream_next_fn: A function type for use when implementing
/**
Read a utf-16 rune from a stream. (little endian and
big endian respectively).
In the event of encountering badly formatted utf-16 codes
(mismatched surrogates) no error/exception is given, but
undefined values may be returned.
*/
int fz_read_utf16_le(fz_context *ctx, fz_stream *stm);
int fz_read_utf16_be(fz_context *ctx, fz_stream *stm);
/**
A function type for use when implementing
fz_streams. The supplied function of this type is called
whenever data is required, and the current buffer is empty.
@@ -226,8 +290,8 @@ int fz_stream_meta(fz_context *ctx, fz_stream *stm, int key, int size, void *ptr
*/
typedef int (fz_stream_next_fn)(fz_context *ctx, fz_stream *stm, size_t max);
/*
fz_stream_drop_fn: A function type for use when implementing
/**
A function type for use when implementing
fz_streams. The supplied function of this type is called
when the stream is dropped, to release the stream specific
state information.
@@ -236,8 +300,8 @@ typedef int (fz_stream_next_fn)(fz_context *ctx, fz_stream *stm, size_t max);
*/
typedef void (fz_stream_drop_fn)(fz_context *ctx, void *state);
/*
fz_stream_seek_fn: A function type for use when implementing
/**
A function type for use when implementing
fz_streams. The supplied function of this type is called when
fz_seek is requested, and the arguments are as defined for
fz_seek.
@@ -246,21 +310,12 @@ typedef void (fz_stream_drop_fn)(fz_context *ctx, void *state);
*/
typedef void (fz_stream_seek_fn)(fz_context *ctx, fz_stream *stm, int64_t offset, int whence);
/*
fz_stream_meta_fn: A function type for use when implementing
fz_streams. The supplied function of this type is called when
fz_meta is requested, and the arguments are as defined for
fz_meta.
The stream can find it's private state in stm->state.
*/
typedef int (fz_stream_meta_fn)(fz_context *ctx, fz_stream *stm, int key, int size, void *ptr);
struct fz_stream_s
struct fz_stream
{
int refs;
int error;
int eof;
int progressive;
int64_t pos;
int avail;
int bits;
@@ -269,11 +324,10 @@ struct fz_stream_s
fz_stream_next_fn *next;
fz_stream_drop_fn *drop;
fz_stream_seek_fn *seek;
fz_stream_meta_fn *meta;
};
/*
fz_new_stream: Create a new stream object with the given
/**
Create a new stream object with the given
internal state and function pointers.
state: Internal state (opaque to everything but implementation).
@@ -287,10 +341,8 @@ struct fz_stream_s
*/
fz_stream *fz_new_stream(fz_context *ctx, void *state, fz_stream_next_fn *next, fz_stream_drop_fn *drop);
fz_stream *fz_keep_stream(fz_context *ctx, fz_stream *stm);
/*
fz_read_best: Attempt to read a stream into a buffer. If truncated
/**
Attempt to read a stream into a buffer. If truncated
is NULL behaves as fz_read_all, sets a truncated flag in case of
error.
@@ -300,21 +352,37 @@ fz_stream *fz_keep_stream(fz_context *ctx, fz_stream *stm);
truncated: Flag to store success/failure indication in.
worst_case: 0 for unknown, otherwise an upper bound for the
size of the stream.
Returns a buffer created from reading from the stream.
*/
fz_buffer *fz_read_best(fz_context *ctx, fz_stream *stm, size_t initial, int *truncated);
fz_buffer *fz_read_best(fz_context *ctx, fz_stream *stm, size_t initial, int *truncated, size_t worst_case);
/*
fz_read_line: Read a line from stream into the buffer until either a
terminating newline or EOF, which it replaces with a null byte ('\0').
/**
Read a line from stream into the buffer until either a
terminating newline or EOF, which it replaces with a null byte
('\0').
Returns buf on success, and NULL when end of file occurs while no characters
have been read.
Returns buf on success, and NULL when end of file occurs while
no characters have been read.
*/
char *fz_read_line(fz_context *ctx, fz_stream *stm, char *buf, size_t max);
/*
fz_available: Ask how many bytes are available immediately from
/**
Skip over a given string in a stream. Return 0 if successfully
skipped, non-zero otherwise. As many characters will be skipped
over as matched in the string.
*/
int fz_skip_string(fz_context *ctx, fz_stream *stm, const char *str);
/**
Skip over whitespace (bytes <= 32) in a stream.
*/
void fz_skip_space(fz_context *ctx, fz_stream *stm);
/**
Ask how many bytes are available immediately from
a given stream.
stm: The stream to read from.
@@ -343,6 +411,7 @@ static inline size_t fz_available(fz_context *ctx, fz_stream *stm, size_t max)
fz_catch(ctx)
{
fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
fz_report_error(ctx);
fz_warn(ctx, "read error; treating as end of file");
stm->error = 1;
c = EOF;
@@ -356,8 +425,8 @@ static inline size_t fz_available(fz_context *ctx, fz_stream *stm, size_t max)
return stm->wp - stm->rp;
}
/*
fz_read_byte: Read the next byte from a stream.
/**
Read the next byte from a stream.
stm: The stream t read from.
@@ -377,6 +446,7 @@ static inline int fz_read_byte(fz_context *ctx, fz_stream *stm)
fz_catch(ctx)
{
fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
fz_report_error(ctx);
fz_warn(ctx, "read error; treating as end of file");
stm->error = 1;
c = EOF;
@@ -386,8 +456,8 @@ static inline int fz_read_byte(fz_context *ctx, fz_stream *stm)
return c;
}
/*
fz_peek_byte: Peek at the next byte in a stream.
/**
Peek at the next byte in a stream.
stm: The stream to peek at.
@@ -411,6 +481,7 @@ static inline int fz_peek_byte(fz_context *ctx, fz_stream *stm)
fz_catch(ctx)
{
fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
fz_report_error(ctx);
fz_warn(ctx, "read error; treating as end of file");
stm->error = 1;
c = EOF;
@@ -420,8 +491,8 @@ static inline int fz_peek_byte(fz_context *ctx, fz_stream *stm)
return c;
}
/*
fz_unread_byte: Unread the single last byte successfully
/**
Unread the single last byte successfully
read from a stream. Do not call this without having
successfully read a byte.
@@ -432,6 +503,13 @@ static inline void fz_unread_byte(fz_context *ctx FZ_UNUSED, fz_stream *stm)
stm->rp--;
}
/**
Query if the stream has reached EOF (during normal bytewise
reading).
See fz_is_eof_bits for the equivalent function for bitwise
reading.
*/
static inline int fz_is_eof(fz_context *ctx, fz_stream *stm)
{
if (stm->rp == stm->wp)
@@ -443,8 +521,8 @@ static inline int fz_is_eof(fz_context *ctx, fz_stream *stm)
return 0;
}
/*
fz_read_bits: Read the next n bits from a stream (assumed to
/**
Read the next n bits from a stream (assumed to
be packed most significant bit first).
stm: The stream to read from.
@@ -486,8 +564,8 @@ static inline unsigned int fz_read_bits(fz_context *ctx, fz_stream *stm, int n)
return x;
}
/*
fz_read_rbits: Read the next n bits from a stream (assumed to
/**
Read the next n bits from a stream (assumed to
be packed least significant bit first).
stm: The stream to read from.
@@ -535,8 +613,8 @@ static inline unsigned int fz_read_rbits(fz_context *ctx, fz_stream *stm, int n)
return x;
}
/*
fz_sync_bits: Called after reading bits to tell the stream
/**
Called after reading bits to tell the stream
that we are about to return to reading bytewise. Resyncs
the stream to whole byte boundaries.
*/
@@ -545,9 +623,24 @@ static inline void fz_sync_bits(fz_context *ctx FZ_UNUSED, fz_stream *stm)
stm->avail = 0;
}
/**
Query if the stream has reached EOF (during bitwise
reading).
See fz_is_eof for the equivalent function for bytewise
reading.
*/
static inline int fz_is_eof_bits(fz_context *ctx, fz_stream *stm)
{
return fz_is_eof(ctx, stm) && (stm->avail == 0 || stm->bits == EOF);
}
/* Implementation details: subject to change. */
/**
Create a stream from a FILE * that will not be closed
when the stream is dropped.
*/
fz_stream *fz_open_file_ptr_no_close(fz_context *ctx, FILE *file);
#endif

244
include/mupdf/fitz/string-util.h
View File

@@ -1,33 +1,66 @@
// Copyright (C) 2004-2022 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_STRING_H
#define MUPDF_FITZ_STRING_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
/* The Unicode character used to incoming character whose value is unknown or unrepresentable. */
/* The Unicode character used to incoming character whose value is
* unknown or unrepresentable. */
#define FZ_REPLACEMENT_CHARACTER 0xFFFD
/*
/**
Safe string functions
*/
/*
fz_strsep: Given a pointer to a C string (or a pointer to NULL) break
it at the first occurrence of a delimiter char (from a given set).
/**
Return strlen(s), if that is less than maxlen, or maxlen if
there is no null byte ('\0') among the first maxlen bytes.
*/
size_t fz_strnlen(const char *s, size_t maxlen);
stringp: Pointer to a C string pointer (or NULL). Updated on exit to
point to the first char of the string after the delimiter that was
found. The string pointed to by stringp will be corrupted by this
call (as the found delimiter will be overwritten by 0).
/**
Given a pointer to a C string (or a pointer to NULL) break
it at the first occurrence of a delimiter char (from a given
set).
stringp: Pointer to a C string pointer (or NULL). Updated on
exit to point to the first char of the string after the
delimiter that was found. The string pointed to by stringp will
be corrupted by this call (as the found delimiter will be
overwritten by 0).
delim: A C string of acceptable delimiter characters.
Returns a pointer to a C string containing the chars of stringp up
to the first delimiter char (or the end of the string), or NULL.
Returns a pointer to a C string containing the chars of stringp
up to the first delimiter char (or the end of the string), or
NULL.
*/
char *fz_strsep(char **stringp, const char *delim);
/*
fz_strlcpy: Copy at most n-1 chars of a string into a destination
/**
Copy at most n-1 chars of a string into a destination
buffer with null termination, returning the real length of the
initial string (excluding terminator).
@@ -41,8 +74,8 @@ char *fz_strsep(char **stringp, const char *delim);
*/
size_t fz_strlcpy(char *dst, const char *src, size_t n);
/*
fz_strlcat: Concatenate 2 strings, with a maximum length.
/**
Concatenate 2 strings, with a maximum length.
dst: pointer to first string in a buffer of n bytes.
@@ -50,50 +83,108 @@ size_t fz_strlcpy(char *dst, const char *src, size_t n);
n: Size (in bytes) of buffer that dst is in.
Returns the real length that a concatenated dst + src would have been
(not including terminator).
Returns the real length that a concatenated dst + src would have
been (not including terminator).
*/
size_t fz_strlcat(char *dst, const char *src, size_t n);
/*
fz_dirname: extract the directory component from a path.
/**
Find the start of the first occurrence of the substring needle in haystack.
*/
void *fz_memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen);
/**
extract the directory component from a path.
*/
void fz_dirname(char *dir, const char *path, size_t dirsize);
/*
fz_urldecode: decode url escapes.
/**
Find the filename component in a path.
*/
const char *fz_basename(const char *path);
/**
Like fz_decode_uri_component but in-place.
*/
char *fz_urldecode(char *url);
/*
fz_format_output_path: create output file name using a template.
If the path contains %[0-9]*d, the first such pattern will be replaced
with the page number. If the template does not contain such a pattern, the page
number will be inserted before the file suffix. If the template does not have
a file suffix, the page number will be added to the end.
/**
* Return a new string representing the unencoded version of the given URI.
* This decodes all escape sequences except those that would result in a reserved
* character that are part of the URI syntax (; / ? : @ & = + $ , #).
*/
char *fz_decode_uri(fz_context *ctx, const char *s);
/**
* Return a new string representing the unencoded version of the given URI component.
* This decodes all escape sequences!
*/
char *fz_decode_uri_component(fz_context *ctx, const char *s);
/**
* Return a new string representing the provided string encoded as a URI.
*/
char *fz_encode_uri(fz_context *ctx, const char *s);
/**
* Return a new string representing the provided string encoded as an URI component.
* This also encodes the special reserved characters (; / ? : @ & = + $ , #).
*/
char *fz_encode_uri_component(fz_context *ctx, const char *s);
/**
* Return a new string representing the provided string encoded as an URI path name.
* This also encodes the special reserved characters except /.
*/
char *fz_encode_uri_pathname(fz_context *ctx, const char *s);
/**
create output file name using a template.
If the path contains %[0-9]*d, the first such pattern will be
replaced with the page number. If the template does not contain
such a pattern, the page number will be inserted before the
filename extension. If the template does not have a filename
extension, the page number will be added to the end.
*/
void fz_format_output_path(fz_context *ctx, char *path, size_t size, const char *fmt, int page);
/*
fz_cleanname: rewrite path to the shortest string that names the same path.
/**
rewrite path to the shortest string that names the same path.
Eliminates multiple and trailing slashes, interprets "." and "..".
Overwrites the string in place.
Eliminates multiple and trailing slashes, interprets "." and
"..". Overwrites the string in place.
*/
char *fz_cleanname(char *name);
/*
/**
rewrite path to the shortest string that names the same path.
Eliminates multiple and trailing slashes, interprets "." and
"..". Allocates a new string that the caller must free.
*/
char *fz_cleanname_strdup(fz_context *ctx, const char *name);
/**
Resolve a path to an absolute file name.
The resolved path buffer must be of at least PATH_MAX size.
*/
char *fz_realpath(const char *path, char *resolved_path);
/**
Case insensitive (ASCII only) string comparison.
*/
int fz_strcasecmp(const char *a, const char *b);
int fz_strncasecmp(const char *a, const char *b, size_t n);
/*
FZ_UTFMAX: Maximum number of bytes in a decoded rune (maximum length returned by fz_chartorune).
/**
FZ_UTFMAX: Maximum number of bytes in a decoded rune (maximum
length returned by fz_chartorune).
*/
enum { FZ_UTFMAX = 4 };
/*
fz_chartorune: UTF8 decode a single rune from a sequence of chars.
/**
UTF8 decode a single rune from a sequence of chars.
rune: Pointer to an int to assign the decoded 'rune' to.
@@ -103,8 +194,8 @@ enum { FZ_UTFMAX = 4 };
*/
int fz_chartorune(int *rune, const char *str);
/*
fz_runetochar: UTF8 encode a rune to a sequence of chars.
/**
UTF8 encode a rune to a sequence of chars.
str: Pointer to a place to put the UTF8 encoded character.
@@ -114,17 +205,42 @@ int fz_chartorune(int *rune, const char *str);
*/
int fz_runetochar(char *str, int rune);
/*
fz_runelen: Count how many chars are required to represent a rune.
/**
Count how many chars are required to represent a rune.
rune: The rune to encode.
Returns the number of bytes required to represent this run in UTF8.
Returns the number of bytes required to represent this run in
UTF8.
*/
int fz_runelen(int rune);
/*
fz_utflen: Count how many runes the UTF-8 encoded string
/**
Compute the index of a rune in a string.
str: Pointer to beginning of a string.
p: Pointer to a char in str.
Returns the index of the rune pointed to by p in str.
*/
int fz_runeidx(const char *str, const char *p);
/**
Obtain a pointer to the char representing the rune
at a given index.
str: Pointer to beginning of a string.
idx: Index of a rune to return a char pointer to.
Returns a pointer to the char where the desired rune starts,
or NULL if the string ends before the index is reached.
*/
const char *fz_runeptr(const char *str, int idx);
/**
Count how many runes the UTF-8 encoded string
consists of.
s: The UTF-8 encoded, NUL-terminated text string.
@@ -134,33 +250,37 @@ int fz_runelen(int rune);
int fz_utflen(const char *s);
/*
fz_strtof: Locale-independent decimal to binary
conversion. On overflow return (-)INFINITY and set errno to ERANGE. On
underflow return 0 and set errno to ERANGE. Special inputs (case
insensitive): "NAN", "INF" or "INFINITY".
Convert a wchar string into a new heap allocated utf8 one.
*/
char *fz_utf8_from_wchar(fz_context *ctx, const wchar_t *s);
/*
Convert a utf8 string into a new heap allocated wchar one.
*/
wchar_t *fz_wchar_from_utf8(fz_context *ctx, const char *path);
/**
Locale-independent decimal to binary conversion. On overflow
return (-)INFINITY and set errno to ERANGE. On underflow return
0 and set errno to ERANGE. Special inputs (case insensitive):
"NAN", "INF" or "INFINITY".
*/
float fz_strtof(const char *s, char **es);
/*
fz_strtof_no_exp: Like fz_strtof, but does not recognize exponent
format. So fz_strtof_no_exp("1.5e20", &tail) will return 1.5 and tail
will point to "e20".
*/
float fz_strtof_no_exp(const char *string, char **tailptr);
/*
fz_grisu: Compute decimal integer m, exp such that:
f = m * 10^exp
m is as short as possible without losing exactness
Assumes special cases (0, NaN, +Inf, -Inf) have been handled.
*/
int fz_grisu(float f, char *s, int *exp);
/*
/**
Check and parse string into page ranges:
( ','? ([0-9]+|'N') ( '-' ([0-9]+|N) )? )+
/,?(-?\d+|N)(-(-?\d+|N))?/
*/
int fz_is_page_range(fz_context *ctx, const char *s);
const char *fz_parse_page_range(fz_context *ctx, const char *s, int *a, int *b, int n);
/**
Unicode aware tolower and toupper functions.
*/
int fz_tolower(int c);
int fz_toupper(int c);
#endif

328
include/mupdf/fitz/structured-text.h
View File

@@ -1,59 +1,151 @@
// Copyright (C) 2004-2021 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_STRUCTURED_TEXT_H
#define MUPDF_FITZ_STRUCTURED_TEXT_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/types.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/geometry.h"
#include "mupdf/fitz/font.h"
#include "mupdf/fitz/colorspace.h"
#include "mupdf/fitz/image.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/device.h"
#include "mupdf/fitz/pool.h"
/*
/**
Simple text layout (for use with annotation editing primarily).
*/
typedef struct fz_layout_char
{
float x, advance;
const char *p; /* location in source text of character */
struct fz_layout_char *next;
} fz_layout_char;
typedef struct fz_layout_line
{
float x, y, font_size;
const char *p; /* location in source text of start of line */
fz_layout_char *text;
struct fz_layout_line *next;
} fz_layout_line;
typedef struct
{
fz_pool *pool;
fz_matrix matrix;
fz_matrix inv_matrix;
fz_layout_line *head, **tailp;
fz_layout_char **text_tailp;
} fz_layout_block;
/**
Create a new layout block, with new allocation pool, zero
matrices, and initialise linked pointers.
*/
fz_layout_block *fz_new_layout(fz_context *ctx);
/**
Drop layout block. Free the pool, and linked blocks.
Never throws exceptions.
*/
void fz_drop_layout(fz_context *ctx, fz_layout_block *block);
/**
Add a new line to the end of the layout block.
*/
void fz_add_layout_line(fz_context *ctx, fz_layout_block *block, float x, float y, float h, const char *p);
/**
Add a new char to the line at the end of the layout block.
*/
void fz_add_layout_char(fz_context *ctx, fz_layout_block *block, float x, float w, const char *p);
/**
Text extraction device: Used for searching, format conversion etc.
(In development - Subject to change in future versions)
*/
typedef struct fz_stext_char_s fz_stext_char;
typedef struct fz_stext_line_s fz_stext_line;
typedef struct fz_stext_block_s fz_stext_block;
typedef struct fz_stext_page_s fz_stext_page;
typedef struct fz_stext_char fz_stext_char;
typedef struct fz_stext_line fz_stext_line;
typedef struct fz_stext_block fz_stext_block;
/*
FZ_STEXT_PRESERVE_LIGATURES: If this option is activated ligatures
are passed through to the application in their original form. If
this option is deactivated ligatures are expanded into their
constituent parts, e.g. the ligature ffi is expanded into three
separate characters f, f and i.
/**
FZ_STEXT_PRESERVE_LIGATURES: If this option is activated
ligatures are passed through to the application in their
original form. If this option is deactivated ligatures are
expanded into their constituent parts, e.g. the ligature ffi is
expanded into three separate characters f, f and i.
FZ_STEXT_PRESERVE_WHITESPACE: If this option is activated whitespace
is passed through to the application in its original form. If this
option is deactivated any type of horizontal whitespace (including
horizontal tabs) will be replaced with space characters of variable
width.
FZ_STEXT_PRESERVE_WHITESPACE: If this option is activated
whitespace is passed through to the application in its original
form. If this option is deactivated any type of horizontal
whitespace (including horizontal tabs) will be replaced with
space characters of variable width.
FZ_STEXT_PRESERVE_IMAGES: If this option is set, then images will
be stored in the structured text structure. The default is to ignore
all images.
FZ_STEXT_PRESERVE_IMAGES: If this option is set, then images
will be stored in the structured text structure. The default is
to ignore all images.
FZ_STEXT_INHIBIT_SPACES: If this option is set, we will not try
to add missing space characters where there are large gaps
between characters.
FZ_STEXT_DEHYPHENATE: If this option is set, hyphens at the
end of a line will be removed and the lines will be merged.
FZ_STEXT_PRESERVE_SPANS: If this option is set, spans on the same line
will not be merged. Each line will thus be a span of text with the same
font, colour, and size.
FZ_STEXT_MEDIABOX_CLIP: If this option is set, characters entirely
outside each page's mediabox will be ignored.
*/
enum
{
FZ_STEXT_PRESERVE_LIGATURES = 1,
FZ_STEXT_PRESERVE_WHITESPACE = 2,
FZ_STEXT_PRESERVE_IMAGES = 4,
FZ_STEXT_INHIBIT_SPACES = 8,
FZ_STEXT_DEHYPHENATE = 16,
FZ_STEXT_PRESERVE_SPANS = 32,
FZ_STEXT_MEDIABOX_CLIP = 64,
FZ_STEXT_USE_CID_FOR_UNKNOWN_UNICODE = 128,
};
/*
A text page is a list of blocks, together with an overall bounding box.
/**
A text page is a list of blocks, together with an overall
bounding box.
*/
struct fz_stext_page_s
typedef struct
{
fz_pool *pool;
fz_rect mediabox;
fz_stext_block *first_block, *last_block;
};
} fz_stext_page;
enum
{
@@ -61,10 +153,11 @@ enum
FZ_STEXT_BLOCK_IMAGE = 1
};
/*
A text block is a list of lines of text (typically a paragraph), or an image.
/**
A text block is a list of lines of text (typically a paragraph),
or an image.
*/
struct fz_stext_block_s
struct fz_stext_block
{
int type;
fz_rect bbox;
@@ -75,10 +168,10 @@ struct fz_stext_block_s
fz_stext_block *prev, *next;
};
/*
/**
A text line is a list of characters that share a common baseline.
*/
struct fz_stext_line_s
struct fz_stext_line
{
int wmode; /* 0 for horizontal, 1 for vertical */
fz_point dir; /* normalized direction of baseline */
@@ -87,111 +180,186 @@ struct fz_stext_line_s
fz_stext_line *prev, *next;
};
/*
A text char is a unicode character, the style in which is appears, and
the point at which it is positioned.
/**
A text char is a unicode character, the style in which is
appears, and the point at which it is positioned.
*/
struct fz_stext_char_s
struct fz_stext_char
{
int c;
int c; /* unicode character value */
int bidi; /* even for LTR, odd for RTL */
int color; /* sRGB hex color */
fz_point origin;
fz_rect bbox;
fz_quad quad;
float size;
fz_font *font;
fz_stext_char *next;
};
extern const char *fz_stext_options_usage;
FZ_DATA extern const char *fz_stext_options_usage;
int fz_stext_char_count(fz_context *ctx, fz_stext_page *page);
const fz_stext_char *fz_stext_char_at(fz_context *ctx, fz_stext_page *page, int idx);
/**
Create an empty text page.
/*
fz_new_stext_page: Create an empty text page.
The text page is filled out by the text device to contain the blocks
and lines of text on the page.
The text page is filled out by the text device to contain the
blocks and lines of text on the page.
mediabox: optional mediabox information.
*/
fz_stext_page *fz_new_stext_page(fz_context *ctx, const fz_rect *mediabox);
fz_stext_page *fz_new_stext_page(fz_context *ctx, fz_rect mediabox);
void fz_drop_stext_page(fz_context *ctx, fz_stext_page *page);
/*
fz_print_stext_page_as_html: Output a page to a file in HTML (visual) format.
/**
Output structured text to a file in HTML (visual) format.
*/
void fz_print_stext_page_as_html(fz_context *ctx, fz_output *out, fz_stext_page *page);
void fz_print_stext_page_as_html(fz_context *ctx, fz_output *out, fz_stext_page *page, int id);
void fz_print_stext_header_as_html(fz_context *ctx, fz_output *out);
void fz_print_stext_trailer_as_html(fz_context *ctx, fz_output *out);
/*
fz_print_stext_page_as_xhtml: Output a page to a file in XHTML (semantic) format.
/**
Output structured text to a file in XHTML (semantic) format.
*/
void fz_print_stext_page_as_xhtml(fz_context *ctx, fz_output *out, fz_stext_page *page);
void fz_print_stext_page_as_xhtml(fz_context *ctx, fz_output *out, fz_stext_page *page, int id);
void fz_print_stext_header_as_xhtml(fz_context *ctx, fz_output *out);
void fz_print_stext_trailer_as_xhtml(fz_context *ctx, fz_output *out);
/*
fz_print_stext_page_as_xml: Output a page to a file in XML format.
/**
Output structured text to a file in XML format.
*/
void fz_print_stext_page_as_xml(fz_context *ctx, fz_output *out, fz_stext_page *page);
void fz_print_stext_page_as_xml(fz_context *ctx, fz_output *out, fz_stext_page *page, int id);
/*
fz_print_stext_page_as_text: Output a page to a file in UTF-8 format.
/**
Output structured text to a file in JSON format.
*/
void fz_print_stext_page_as_json(fz_context *ctx, fz_output *out, fz_stext_page *page, float scale);
/**
Output structured text to a file in plain-text UTF-8 format.
*/
void fz_print_stext_page_as_text(fz_context *ctx, fz_output *out, fz_stext_page *page);
/*
fz_search_stext_page: Search for occurrence of 'needle' in text page.
/**
Search for occurrence of 'needle' in text page.
Return the number of hits and store hit bboxes in the passed in array.
Return the number of hits and store hit quads in the passed in
array.
NOTE: This is an experimental interface and subject to change without notice.
NOTE: This is an experimental interface and subject to change
without notice.
*/
int fz_search_stext_page(fz_context *ctx, fz_stext_page *text, const char *needle, fz_rect *hit_bbox, int hit_max);
int fz_search_stext_page(fz_context *ctx, fz_stext_page *text, const char *needle, int *hit_mark, fz_quad *hit_bbox, int hit_max);
/*
fz_highlight_selection: Return a list of rectangles to highlight lines inside the selection points.
/**
Return a list of quads to highlight lines inside the selection
points.
*/
int fz_highlight_selection(fz_context *ctx, fz_stext_page *page, fz_point a, fz_point b, fz_rect *hit_bbox, int hit_max);
int fz_highlight_selection(fz_context *ctx, fz_stext_page *page, fz_point a, fz_point b, fz_quad *quads, int max_quads);
/*
fz_copy_selection: Return a newly allocated UTF-8 string with the text for a given selection.
enum
{
FZ_SELECT_CHARS,
FZ_SELECT_WORDS,
FZ_SELECT_LINES,
};
crlf: If true, write "\r\n" style line endings (otherwise "\n" only).
fz_quad fz_snap_selection(fz_context *ctx, fz_stext_page *page, fz_point *ap, fz_point *bp, int mode);
/**
Return a newly allocated UTF-8 string with the text for a given
selection.
crlf: If true, write "\r\n" style line endings (otherwise "\n"
only).
*/
char *fz_copy_selection(fz_context *ctx, fz_stext_page *page, fz_point a, fz_point b, int crlf);
/*
struct fz_stext_options: Options for creating a pixmap and draw device.
*/
typedef struct fz_stext_options_s fz_stext_options;
/**
Return a newly allocated UTF-8 string with the text for a given
selection rectangle.
struct fz_stext_options_s
crlf: If true, write "\r\n" style line endings (otherwise "\n"
only).
*/
char *fz_copy_rectangle(fz_context *ctx, fz_stext_page *page, fz_rect area, int crlf);
/**
Options for creating structured text.
*/
typedef struct
{
int flags;
};
float scale;
} fz_stext_options;
/*
fz_parse_stext_options: Parse stext device options from a comma separated key-value string.
/**
Parse stext device options from a comma separated key-value
string.
*/
fz_stext_options *fz_parse_stext_options(fz_context *ctx, fz_stext_options *opts, const char *string);
/*
fz_new_stext_device: Create a device to extract the text on a page.
/**
Create a device to extract the text on a page.
Gather the text on a page into blocks and lines.
The reading order is taken from the order the text is drawn in the
source file, so may not be accurate.
The reading order is taken from the order the text is drawn in
the source file, so may not be accurate.
page: The text page to which content should be added. This will
usually be a newly created (empty) text page, but it can be one
containing data already (for example when merging multiple pages,
or watermarking).
containing data already (for example when merging multiple
pages, or watermarking).
options: Options to configure the stext device.
*/
fz_device *fz_new_stext_device(fz_context *ctx, fz_stext_page *page, const fz_stext_options *options);
/**
Create a device to OCR the text on the page.
Renders the page internally to a bitmap that is then OCRd. Text
is then forwarded onto the target device.
target: The target device to receive the OCRd text.
ctm: The transform to apply to the mediabox to get the size for
the rendered page image. Also used to calculate the resolution
for the page image. In general, this will be the same as the CTM
that you pass to fz_run_page (or fz_run_display_list) to feed
this device.
mediabox: The mediabox (in points). Combined with the CTM to get
the bounds of the pixmap used internally for the rendered page
image.
with_list: If with_list is false, then all non-text operations
are forwarded instantly to the target device. This results in
the target device seeing all NON-text operations, followed by
all the text operations (derived from OCR).
If with_list is true, then all the marking operations are
collated into a display list which is then replayed to the
target device at the end.
language: NULL (for "eng"), or a pointer to a string to describe
the languages/scripts that should be used for OCR (e.g.
"eng,ara").
datadir: NULL (for ""), or a pointer to a path string otherwise
provided to Tesseract in the TESSDATA_PREFIX environment variable.
progress: NULL, or function to be called periodically to indicate
progress. Return 0 to continue, or 1 to cancel. progress_arg is
returned as the void *. The int is a value between 0 and 100 to
indicate progress.
progress_arg: A void * value to be parrotted back to the progress
function.
*/
fz_device *fz_new_ocr_device(fz_context *ctx, fz_device *target, fz_matrix ctm, fz_rect mediabox, int with_list, const char *language,
const char *datadir, int (*progress)(fz_context *, void *, int), void *progress_arg);
fz_document *fz_open_reflowed_document(fz_context *ctx, fz_document *underdoc, const fz_stext_options *opts);
#endif

170
include/mupdf/fitz/system.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2022 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_SYSTEM_H
#define MUPDF_FITZ_SYSTEM_H
@@ -8,13 +30,16 @@
#endif
#endif
/*
/**
Include the standard libc headers.
*/
#include <stddef.h> /* needed for size_t */
#include <stdarg.h> /* needed for va_list vararg functions */
#include <setjmp.h> /* needed for the try/catch macros */
#include <stdio.h> /* useful for debug printfs */
#include "export.h"
#if defined(_MSC_VER) && (_MSC_VER < 1700) /* MSVC older than VS2012 */
typedef signed char int8_t;
@@ -43,7 +68,7 @@ typedef unsigned __int64 uint64_t;
#define FZ_SQRT2 1.41421356f
#define FZ_LN2 0.69314718f
/*
/**
Spot architectures where we have optimisations.
*/
@@ -53,32 +78,43 @@ typedef unsigned __int64 uint64_t;
#endif
#endif
/*
/**
Some differences in libc can be smoothed over
*/
#ifdef __APPLE__
#define HAVE_SIGSETJMP
#elif defined(__unix) && !defined(__NACL__)
#define HAVE_SIGSETJMP
#ifndef __STRICT_ANSI__
#if defined(__APPLE__)
#ifndef HAVE_SIGSETJMP
#define HAVE_SIGSETJMP 1
#endif
#elif defined(__unix)
#ifndef __EMSCRIPTEN__
#ifndef HAVE_SIGSETJMP
#define HAVE_SIGSETJMP 1
#endif
#endif
#endif
#endif
#ifndef HAVE_SIGSETJMP
#define HAVE_SIGSETJMP 0
#endif
/*
Where possible (i.e. on platforms on which they are provided), use
sigsetjmp/siglongjmp in preference to setjmp/longjmp. We don't alter
signal handlers within mupdf, so there is no need for us to
store/restore them - hence we use the non-restoring variants. This
makes a large speed difference on MacOSX (and probably other
platforms too.
/**
Where possible (i.e. on platforms on which they are provided),
use sigsetjmp/siglongjmp in preference to setjmp/longjmp. We
don't alter signal handlers within mupdf, so there is no need
for us to store/restore them - hence we use the non-restoring
variants. This makes a large speed difference on MacOSX (and
probably other platforms too.
*/
#ifdef HAVE_SIGSETJMP
#if HAVE_SIGSETJMP
#define fz_setjmp(BUF) sigsetjmp(BUF, 0)
#define fz_longjmp(BUF,VAL) siglongjmp(BUF, VAL)
#define fz_jmp_buf sigjmp_buf
typedef sigjmp_buf fz_jmp_buf;
#else
#define fz_setjmp(BUF) setjmp(BUF)
#define fz_longjmp(BUF,VAL) longjmp(BUF,VAL)
#define fz_jmp_buf jmp_buf
typedef jmp_buf fz_jmp_buf;
#endif
/* these constants mirror the corresponding macros in stdio.h */
@@ -120,16 +156,15 @@ static __inline int signbit(double x)
#define isinf(x) (!_finite(x))
#endif
#if _MSC_VER <= 1920 /* MSVC 2019 */
#define hypotf _hypotf
#endif
#define atoll _atoi64
#endif
#ifdef _WIN32
char *fz_utf8_from_wchar(const wchar_t *s);
wchar_t *fz_wchar_from_utf8(const char *s);
/* really a FILE* but we don't want to include stdio.h here */
void *fz_fopen_utf8(const char *name, const char *mode);
int fz_remove_utf8(const char *name);
@@ -144,27 +179,41 @@ void fz_free_argv(int argc, char **argv);
#define S_ISDIR(mode) ((mode) & S_IFDIR)
#endif
/* inline is standard in C++. For some compilers we can enable it within C too. */
int64_t fz_stat_ctime(const char *path);
int64_t fz_stat_mtime(const char *path);
int fz_mkdir(char *path);
/* inline is standard in C++. For some compilers we can enable it within
* C too. Some compilers think they know better than we do about when
* to actually honour inline (particularly for large functions); use
* fz_forceinline to kick them into really inlining. */
#ifndef __cplusplus
#if __STDC_VERSION__ == 199901L /* C99 */
#elif _MSC_VER >= 1500 /* MSVC 9 or newer */
#if defined (__STDC_VERSION_) && (__STDC_VERSION__ >= 199901L) /* C99 */
#elif defined(_MSC_VER) && (_MSC_VER >= 1500) /* MSVC 9 or newer */
#define inline __inline
#elif __GNUC__ >= 3 /* GCC 3 or newer */
#define fz_forceinline __forceinline
#elif defined(__GNUC__) && (__GNUC__ >= 3) /* GCC 3 or newer */
#define inline __inline
#else /* Unknown or ancient */
#define inline
#endif
#endif
#ifndef fz_forceinline
#define fz_forceinline inline
#endif
/* restrict is standard in C99, but not in all C++ compilers. */
#if __STDC_VERSION__ == 199901L /* C99 */
#elif _MSC_VER >= 1600 /* MSVC 10 or newer */
#define restrict __restrict
#elif __GNUC__ >= 3 /* GCC 3 or newer */
#define restrict __restrict
#if defined (__STDC_VERSION_) && (__STDC_VERSION__ >= 199901L) /* C99 */
#define FZ_RESTRICT restrict
#elif defined(_MSC_VER) && (_MSC_VER >= 1600) /* MSVC 10 or newer */
#define FZ_RESTRICT __restrict
#elif defined(__GNUC__) && (__GNUC__ >= 3) /* GCC 3 or newer */
#define FZ_RESTRICT __restrict
#else /* Unknown or ancient */
#define restrict
#define FZ_RESTRICT
#endif
/* noreturn is a GCC extension */
@@ -178,8 +227,9 @@ void fz_free_argv(int argc, char **argv);
#endif
#endif
/* Flag unused parameters, for use with 'static inline' functions in headers. */
#if __GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 7
/* Flag unused parameters, for use with 'static inline' functions in
* headers. */
#if defined(__GNUC__) && (__GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 7)
#define FZ_UNUSED __attribute__((__unused__))
#else
#define FZ_UNUSED
@@ -189,7 +239,7 @@ void fz_free_argv(int argc, char **argv);
#ifdef __printflike
#define FZ_PRINTFLIKE(F,V) __printflike(F,V)
#else
#if __GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 7
#if defined(__GNUC__) && (__GNUC__ > 2 || __GNUC__ == 2 && __GNUC_MINOR__ >= 7)
#define FZ_PRINTFLIKE(F,V) __attribute__((__format__ (__printf__, F, V)))
#else
#define FZ_PRINTFLIKE(F,V)
@@ -202,8 +252,8 @@ void fz_free_argv(int argc, char **argv);
/* If we're compiling as thumb code, then we need to tell the compiler
* to enter and exit ARM mode around our assembly sections. If we move
* the ARM functions to a separate file and arrange for it to be compiled
* without thumb mode, we can save some time on entry.
* the ARM functions to a separate file and arrange for it to be
* compiled without thumb mode, we can save some time on entry.
*/
/* This is slightly suboptimal; __thumb__ and __thumb2__ become defined
* and undefined by #pragma arm/#pragma thumb - but we can't define a
@@ -218,10 +268,47 @@ void fz_free_argv(int argc, char **argv);
#endif
/* Memory block alignment */
/* Most architectures are happy with blocks being aligned to the size
* of void *'s. Some (notably sparc) are not.
*
* Some architectures (notably amd64) are happy for pointers to be 32bit
* aligned even on 64bit systems. By making use of this we can save lots
* of memory in data structures (notably the display list).
*
* We attempt to cope with these vagaries via the following definitions.
*/
/* All blocks allocated by mupdf's allocators are expected to be
* returned aligned to FZ_MEMORY_BLOCK_ALIGN_MOD. This is sizeof(void *)
* unless overwritten by a predefinition, or by a specific architecture
* being detected. */
#ifndef FZ_MEMORY_BLOCK_ALIGN_MOD
#if defined(sparc) || defined(__sparc) || defined(__sparc__)
#define FZ_MEMORY_BLOCK_ALIGN_MOD 8
#else
#define FZ_MEMORY_BLOCK_ALIGN_MOD sizeof(void *)
#endif
#endif
/* MuPDF will ensure that its use of pointers in packed structures
* (such as the display list) will be aligned to FZ_POINTER_ALIGN_MOD.
* This is the same as FZ_MEMORY_BLOCK_ALIGN_MOD unless overridden by
* a predefinition, or by a specific architecture being detected. */
#ifndef FZ_POINTER_ALIGN_MOD
#if defined(__amd64) || defined(__amd64__) || defined(__x86_64) || defined(__x86_64__)
#define FZ_POINTER_ALIGN_MOD 4
#else
#define FZ_POINTER_ALIGN_MOD FZ_MEMORY_BLOCK_ALIGN_MOD
#endif
#endif
#ifdef CLUSTER
/* Include this first so our defines don't clash with the system definitions */
/* Include this first so our defines don't clash with the system
* definitions */
#include <math.h>
/*
/**
* Trig functions
*/
static float
@@ -321,6 +408,10 @@ static inline float my_sinf(float x)
x -= xn;
xn *= x2 / 72.0f;
x += xn;
if (x > 1)
x = 1;
else if (x < -1)
x = -1;
return x;
}
@@ -360,4 +451,9 @@ static inline float my_atan2f(float o, float a)
#define atan2f(x,y) my_atan2f((x),(y))
#endif
static inline int fz_is_pow2(int a)
{
return (a != 0) && (a & (a-1)) == 0;
}
#endif

120
include/mupdf/fitz/text.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_TEXT_H
#define MUPDF_FITZ_TEXT_H
@@ -7,7 +29,7 @@
#include "mupdf/fitz/path.h"
#include "mupdf/fitz/bidi.h"
/*
/**
Text buffer.
The trm field contains the a, b, c and d coefficients.
@@ -19,21 +41,18 @@
with indexes into the glyph array.
*/
typedef struct fz_text_s fz_text;
typedef struct fz_text_span_s fz_text_span;
typedef struct fz_text_item_s fz_text_item;
struct fz_text_item_s
typedef struct
{
float x, y;
int gid; /* -1 for one gid to many ucs mappings */
int ucs; /* -1 for one ucs to many gid mappings */
};
int cid; /* CID for CJK fonts, raw character code for other fonts; or unicode for non-PDF formats. */
} fz_text_item;
#define FZ_LANG_TAG2(c1,c2) ((c1-'a'+1) + ((c2-'a'+1)*27))
#define FZ_LANG_TAG3(c1,c2,c3) ((c1-'a'+1) + ((c2-'a'+1)*27) + ((c3-'a'+1)*27*27))
typedef enum fz_text_language_e
typedef enum
{
FZ_LANG_UNSET = 0,
FZ_LANG_ur = FZ_LANG_TAG2('u','r'),
@@ -45,7 +64,7 @@ typedef enum fz_text_language_e
FZ_LANG_zh_Hant = FZ_LANG_TAG3('z','h','t'),
} fz_text_language;
struct fz_text_span_s
typedef struct fz_text_span
{
fz_font *font;
fz_matrix trm;
@@ -55,41 +74,40 @@ struct fz_text_span_s
unsigned language : 15; /* The language as marked in the original document */
int len, cap;
fz_text_item *items;
fz_text_span *next;
};
struct fz_text_span *next;
} fz_text_span;
struct fz_text_s
typedef struct
{
int refs;
fz_text_span *head, *tail;
};
} fz_text;
/*
fz_new_text: Create a new empty fz_text object.
/**
Create a new empty fz_text object.
Throws exception on failure to allocate.
*/
fz_text *fz_new_text(fz_context *ctx);
/*
fz_keep_text: Add a reference to a fz_text.
/**
Increment the reference count for the text object. The same
pointer is returned.
text: text object to keep a reference to.
Return the same text pointer.
Never throws exceptions.
*/
fz_text *fz_keep_text(fz_context *ctx, const fz_text *text);
/*
fz_drop_text: Drop a reference to the object, freeing
if it is the last one.
/**
Decrement the reference count for the text object. When the
reference count hits zero, the text object is freed.
text: Object to drop the reference to.
Never throws exceptions.
*/
void fz_drop_text(fz_context *ctx, const fz_text *text);
/*
fz_show_glyph: Add a glyph/unicode value to a text object.
/**
Add a glyph/unicode value to a text object.
text: Text object to add to.
@@ -101,6 +119,8 @@ void fz_drop_text(fz_context *ctx, const fz_text *text);
unicode: The unicode character for the glyph.
cid: The CJK CID value or raw character code.
wmode: 1 for vertical mode, 0 for horizontal.
bidi_level: The bidirectional level for this glyph.
@@ -113,17 +133,17 @@ void fz_drop_text(fz_context *ctx, const fz_text *text);
Throws exception on failure to allocate.
*/
void fz_show_glyph(fz_context *ctx, fz_text *text, fz_font *font, const fz_matrix *trm, int glyph, int unicode, int wmode, int bidi_level, fz_bidi_direction markup_dir, fz_text_language language);
void fz_show_glyph(fz_context *ctx, fz_text *text, fz_font *font, fz_matrix trm, int glyph, int unicode, int wmode, int bidi_level, fz_bidi_direction markup_dir, fz_text_language language);
void fz_show_glyph_aux(fz_context *ctx, fz_text *text, fz_font *font, fz_matrix trm, int glyph, int unicode, int cid, int wmode, int bidi_level, fz_bidi_direction markup_dir, fz_text_language lang);
/*
fz_show_string: Add a UTF8 string to a text object.
/**
Add a UTF8 string to a text object.
text: Text object to add to.
font: The font the string should be added in.
trm: The transform to use. Will be updated according
to the advance of the string on exit.
trm: The transform to use.
s: The utf-8 string to add.
@@ -131,18 +151,27 @@ void fz_show_glyph(fz_context *ctx, fz_text *text, fz_font *font, const fz_matri
bidi_level: The bidirectional level for this glyph.
markup_dir: The direction of the text as specified in the
markup.
markup_dir: The direction of the text as specified in the markup.
language: The language in use (if known, 0 otherwise)
(e.g. FZ_LANG_zh_Hans).
(e.g. FZ_LANG_zh_Hans).
Throws exception on failure to allocate.
Returns the transform updated with the advance width of the
string.
*/
void fz_show_string(fz_context *ctx, fz_text *text, fz_font *font, fz_matrix *trm, const char *s, int wmode, int bidi_level, fz_bidi_direction markup_dir, fz_text_language language);
fz_matrix fz_show_string(fz_context *ctx, fz_text *text, fz_font *font, fz_matrix trm, const char *s, int wmode, int bidi_level, fz_bidi_direction markup_dir, fz_text_language language);
/*
fz_bound_text: Find the bounds of a given text object.
/**
Measure the advance width of a UTF8 string should it be added to a text object.
This uses the same layout algorithms as fz_show_string, and can be used
to calculate text alignment adjustments.
*/
fz_matrix
fz_measure_string(fz_context *ctx, fz_font *user_font, fz_matrix trm, const char *s, int wmode, int bidi_level, fz_bidi_direction markup_dir, fz_text_language language);
/**
Find the bounds of a given text object.
text: The text object to find the bounds of.
@@ -156,18 +185,9 @@ void fz_show_string(fz_context *ctx, fz_text *text, fz_font *font, fz_matrix *tr
Returns a pointer to r, which is updated to contain the
bounding box for the text object.
*/
fz_rect *fz_bound_text(fz_context *ctx, const fz_text *text, const fz_stroke_state *stroke, const fz_matrix *ctm, fz_rect *r);
fz_rect fz_bound_text(fz_context *ctx, const fz_text *text, const fz_stroke_state *stroke, fz_matrix ctm);
/*
fz_clone_text: Clone a text object.
text: The text object to clone.
Throws an exception on allocation failure.
*/
fz_text *fz_clone_text(fz_context *ctx, const fz_text *text);
/*
/**
Convert ISO 639 (639-{1,2,3,5}) language specification
strings losslessly to a 15 bit fz_text_language code.
@@ -178,7 +198,7 @@ fz_text *fz_clone_text(fz_context *ctx, const fz_text *text);
*/
fz_text_language fz_text_language_from_string(const char *str);
/*
/**
Recover ISO 639 (639-{1,2,3,5}) language specification
strings losslessly from a 15 bit fz_text_language code.

34
include/mupdf/fitz/track-usage.h
View File

@@ -1,29 +1,51 @@
// Copyright (C) 2004-2021 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 TRACK_USAGE_H
#define TRACK_USAGE_H
#ifdef TRACK_USAGE
typedef struct track_usage_data_s {
typedef struct track_usage_data {
int count;
const char *function;
int line;
const char *desc;
struct track_usage_data_s *next;
} track_usage_data_t;
struct track_usage_data *next;
} track_usage_data;
#define TRACK_LABEL(A) \
do { \
static track_usage_data_t USAGE_DATA = { 0 };\
static track_usage_data USAGE_DATA = { 0 };\
track_usage(&USAGE_DATA, __FILE__, __LINE__, A);\
} while (0)
#define TRACK_FN() \
do { \
static track_usage_data_t USAGE_DATA = { 0 };\
static track_usage_data USAGE_DATA = { 0 };\
track_usage(&USAGE_DATA, __FILE__, __LINE__, __FUNCTION__);\
} while (0)
void track_usage(track_usage_data_t *data, const char *function, int line, const char *desc);
void track_usage(track_usage_data *data, const char *function, int line, const char *desc);
#else

34
include/mupdf/fitz/transition.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2021 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_TRANSITION_H
#define MUPDF_FITZ_TRANSITION_H
@@ -5,8 +27,6 @@
#include "mupdf/fitz/pixmap.h"
/* Transition support */
typedef struct fz_transition_s fz_transition;
enum {
FZ_TRANSITION_NONE = 0, /* aka 'R' or 'REPLACE' */
FZ_TRANSITION_SPLIT,
@@ -22,7 +42,7 @@ enum {
FZ_TRANSITION_FADE
};
struct fz_transition_s
typedef struct
{
int type;
float duration; /* Effect duration (seconds) */
@@ -36,10 +56,10 @@ struct fz_transition_s
/* State variables for use of the transition code */
int state0;
int state1;
};
} fz_transition;
/*
fz_generate_transition: Generate a frame of a transition.
/**
Generate a frame of a transition.
tpix: Target pixmap
opix: Old pixmap
@@ -48,6 +68,8 @@ struct fz_transition_s
trans: Transition details
Returns 1 if successfully generated a frame.
Note: Pixmaps must include alpha.
*/
int fz_generate_transition(fz_context *ctx, fz_pixmap *tpix, fz_pixmap *opix, fz_pixmap *npix, int time, fz_transition *trans);

44
include/mupdf/fitz/tree.h
View File

@@ -1,24 +1,62 @@
// Copyright (C) 2004-2021 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_TREE_H
#define MUPDF_FITZ_TREE_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
/*
/**
AA-tree to look up things by strings.
*/
typedef struct fz_tree_s fz_tree;
typedef struct fz_tree fz_tree;
/**
Look for the value of a node in the tree with the given key.
Simple pointer equivalence is used for key.
Returns NULL for no match.
*/
void *fz_tree_lookup(fz_context *ctx, fz_tree *node, const char *key);
/*
/**
Insert a new key/value pair and rebalance the tree.
Return the new root of the tree after inserting and rebalancing.
May be called with a NULL root to create a new tree.
No data is copied into the tree structure; key and value are
merely kept as pointers.
*/
fz_tree *fz_tree_insert(fz_context *ctx, fz_tree *root, const char *key, void *value);
/**
Drop the tree.
The storage used by the tree is freed, and each value has
dropfunc called on it.
*/
void fz_drop_tree(fz_context *ctx, fz_tree *node, void (*dropfunc)(fz_context *ctx, void *value));
#endif

41
include/mupdf/fitz/types.h Normal file
View File

@@ -0,0 +1,41 @@
// Copyright (C) 2021 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_TYPES_H
#define MUPDF_FITZ_TYPES_H
typedef struct fz_document fz_document;
/**
Locations within the document are referred to in terms of
chapter and page, rather than just a page number. For some
documents (such as epub documents with large numbers of pages
broken into many chapters) this can make navigation much faster
as only the required chapter needs to be decoded at a time.
*/
typedef struct
{
int chapter;
int page;
} fz_location;
#endif

136
include/mupdf/fitz/util.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2022 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_UTIL_H
#define MUPDF_FITZ_UTIL_H
@@ -8,70 +30,122 @@
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/structured-text.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/xml.h"
#include "mupdf/fitz/archive.h"
#include "mupdf/fitz/display-list.h"
/*
fz_new_display_list_from_page: Create a display list with the contents of a page.
/**
Create a display list.
Ownership of the display list is returned to the caller.
*/
fz_display_list *fz_new_display_list_from_page(fz_context *ctx, fz_page *page);
fz_display_list *fz_new_display_list_from_page_number(fz_context *ctx, fz_document *doc, int number);
/**
Create a display list from page contents (no annotations).
Ownership of the display list is returned to the caller.
*/
fz_display_list *fz_new_display_list_from_page_contents(fz_context *ctx, fz_page *page);
fz_display_list *fz_new_display_list_from_annot(fz_context *ctx, fz_annot *annot);
/*
fz_new_pixmap_from_page: Render the page to a pixmap using the transform and colorspace.
/**
Render the page to a pixmap using the transform and colorspace.
Ownership of the pixmap is returned to the caller.
*/
fz_pixmap *fz_new_pixmap_from_display_list(fz_context *ctx, fz_display_list *list, const fz_matrix *ctm, fz_colorspace *cs, int alpha);
fz_pixmap *fz_new_pixmap_from_page(fz_context *ctx, fz_page *page, const fz_matrix *ctm, fz_colorspace *cs, int alpha);
fz_pixmap *fz_new_pixmap_from_page_number(fz_context *ctx, fz_document *doc, int number, const fz_matrix *ctm, fz_colorspace *cs, int alpha);
fz_pixmap *fz_new_pixmap_from_display_list(fz_context *ctx, fz_display_list *list, fz_matrix ctm, fz_colorspace *cs, int alpha);
fz_pixmap *fz_new_pixmap_from_page(fz_context *ctx, fz_page *page, fz_matrix ctm, fz_colorspace *cs, int alpha);
fz_pixmap *fz_new_pixmap_from_page_number(fz_context *ctx, fz_document *doc, int number, fz_matrix ctm, fz_colorspace *cs, int alpha);
/*
fz_new_pixmap_from_page_contents: Render the page contents without annotations.
/**
Render the page contents without annotations.
Ownership of the pixmap is returned to the caller.
*/
fz_pixmap *fz_new_pixmap_from_page_contents(fz_context *ctx, fz_page *page, const fz_matrix *ctm, fz_colorspace *cs, int alpha);
fz_pixmap *fz_new_pixmap_from_page_contents(fz_context *ctx, fz_page *page, fz_matrix ctm, fz_colorspace *cs, int alpha);
/*
fz_new_pixmap_from_annot: Render an annotation suitable for blending on top of the opaque
pixmap returned by fz_new_pixmap_from_page_contents.
/**
Render the page contents with control over spot colors.
Ownership of the pixmap is returned to the caller.
*/
fz_pixmap *fz_new_pixmap_from_annot(fz_context *ctx, fz_annot *annot, const fz_matrix *ctm, fz_colorspace *cs, int alpha);
fz_pixmap *fz_new_pixmap_from_display_list_with_separations(fz_context *ctx, fz_display_list *list, fz_matrix ctm, fz_colorspace *cs, fz_separations *seps, int alpha);
fz_pixmap *fz_new_pixmap_from_page_with_separations(fz_context *ctx, fz_page *page, fz_matrix ctm, fz_colorspace *cs, fz_separations *seps, int alpha);
fz_pixmap *fz_new_pixmap_from_page_number_with_separations(fz_context *ctx, fz_document *doc, int number, fz_matrix ctm, fz_colorspace *cs, fz_separations *seps, int alpha);
fz_pixmap *fz_new_pixmap_from_page_contents_with_separations(fz_context *ctx, fz_page *page, fz_matrix ctm, fz_colorspace *cs, fz_separations *seps, int alpha);
/*
fz_new_stext_page_from_page: Extract structured text from a page.
fz_pixmap *fz_fill_pixmap_from_display_list(fz_context *ctx, fz_display_list *list, fz_matrix ctm, fz_pixmap *pix);
/**
Extract text from page.
Ownership of the fz_stext_page is returned to the caller.
*/
fz_stext_page *fz_new_stext_page_from_page(fz_context *ctx, fz_page *page, const fz_stext_options *options);
fz_stext_page *fz_new_stext_page_from_page_number(fz_context *ctx, fz_document *doc, int number, const fz_stext_options *options);
fz_stext_page *fz_new_stext_page_from_chapter_page_number(fz_context *ctx, fz_document *doc, int chapter, int number, const fz_stext_options *options);
fz_stext_page *fz_new_stext_page_from_display_list(fz_context *ctx, fz_display_list *list, const fz_stext_options *options);
/*
fz_new_buffer_from_stext_page: Convert structured text into plain text.
/**
Convert structured text into plain text.
*/
fz_buffer *fz_new_buffer_from_stext_page(fz_context *ctx, fz_stext_page *text);
fz_buffer *fz_new_buffer_from_page(fz_context *ctx, fz_page *page, const fz_stext_options *options);
fz_buffer *fz_new_buffer_from_page_number(fz_context *ctx, fz_document *doc, int number, const fz_stext_options *options);
fz_buffer *fz_new_buffer_from_display_list(fz_context *ctx, fz_display_list *list, const fz_stext_options *options);
/*
fz_search_page: Search for the 'needle' text on the page.
Record the hits in the hit_bbox array and return the number of hits.
Will stop looking once it has filled hit_max rectangles.
/**
Search for the 'needle' text on the page.
Record the hits in the hit_bbox array and return the number of
hits. Will stop looking once it has filled hit_max rectangles.
*/
int fz_search_page(fz_context *ctx, fz_page *page, const char *needle, fz_rect *hit_bbox, int hit_max);
int fz_search_page_number(fz_context *ctx, fz_document *doc, int number, const char *needle, fz_rect *hit_bbox, int hit_max);
int fz_search_display_list(fz_context *ctx, fz_display_list *list, const char *needle, fz_rect *hit_bbox, int hit_max);
int fz_search_page(fz_context *ctx, fz_page *page, const char *needle, int *hit_mark, fz_quad *hit_bbox, int hit_max);
int fz_search_page_number(fz_context *ctx, fz_document *doc, int number, const char *needle, int *hit_mark, fz_quad *hit_bbox, int hit_max);
int fz_search_chapter_page_number(fz_context *ctx, fz_document *doc, int chapter, int page, const char *needle, int *hit_mark, fz_quad *hit_bbox, int hit_max);
int fz_search_display_list(fz_context *ctx, fz_display_list *list, const char *needle, int *hit_mark, fz_quad *hit_bbox, int hit_max);
/*
/**
Parse an SVG document into a display-list.
*/
fz_display_list *fz_new_display_list_from_svg(fz_context *ctx, fz_buffer *buf, float *w, float *h);
fz_display_list *fz_new_display_list_from_svg(fz_context *ctx, fz_buffer *buf, const char *base_uri, fz_archive *dir, float *w, float *h);
/*
/**
Create a scalable image from an SVG document.
*/
fz_image *fz_new_image_from_svg(fz_context *ctx, fz_buffer *buf);
fz_image *fz_new_image_from_svg(fz_context *ctx, fz_buffer *buf, const char *base_uri, fz_archive *dir);
/*
/**
Parse an SVG document into a display-list.
*/
fz_display_list *fz_new_display_list_from_svg_xml(fz_context *ctx, fz_xml_doc *xmldoc, fz_xml *xml, const char *base_uri, fz_archive *dir, float *w, float *h);
/**
Create a scalable image from an SVG document.
*/
fz_image *fz_new_image_from_svg_xml(fz_context *ctx, fz_xml_doc *xmldoc, fz_xml *xml, const char *base_uri, fz_archive *dir);
/**
Write image as a data URI (for HTML and SVG output).
*/
void fz_write_image_as_data_uri(fz_context *ctx, fz_output *out, fz_image *image);
void fz_write_pixmap_as_data_uri(fz_context *ctx, fz_output *out, fz_pixmap *pixmap);
void fz_append_image_as_data_uri(fz_context *ctx, fz_buffer *out, fz_image *image);
void fz_append_pixmap_as_data_uri(fz_context *ctx, fz_buffer *out, fz_pixmap *pixmap);
/**
Use text extraction to convert the input document into XHTML,
then open the result as a new document that can be reflowed.
*/
fz_document *fz_new_xhtml_document_from_document(fz_context *ctx, fz_document *old_doc, const fz_stext_options *opts);
/**
Returns an fz_buffer containing a page after conversion to specified format.
page: The page to convert.
format, options: Passed to fz_new_document_writer_with_output() internally.
transform, cookie: Passed to fz_run_page() internally.
*/
fz_buffer *fz_new_buffer_from_page_with_format(fz_context *ctx, fz_page *page, const char *format, const char *options, fz_matrix transform, fz_cookie *cookie);
#endif

3
include/mupdf/fitz/vendor.go Normal file
View File

@@ -0,0 +1,3 @@
//go:build required
package vendor

28
include/mupdf/fitz/version.h
View File

@@ -1,9 +1,31 @@
// Copyright (C) 2004-2024 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_VERSION_H
#define MUPDF_FITZ_VERSION_H
#ifndef FZ_VERSION
#define FZ_VERSION "1.13.0"
#define FZ_VERSION "1.24.9"
#define FZ_VERSION_MAJOR 1
#define FZ_VERSION_MINOR 13
#define FZ_VERSION_PATCH 0
#define FZ_VERSION_MINOR 24
#define FZ_VERSION_PATCH 9
#endif
#endif

499
include/mupdf/fitz/write-pixmap.h Normal file
View File

@@ -0,0 +1,499 @@
// Copyright (C) 2004-2023 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_WRITE_PIXMAP_H
#define MUPDF_FITZ_WRITE_PIXMAP_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/band-writer.h"
#include "mupdf/fitz/pixmap.h"
#include "mupdf/fitz/bitmap.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/image.h"
#include "mupdf/fitz/writer.h"
/**
PCL output
*/
typedef struct
{
/* Features of a particular printer */
int features;
const char *odd_page_init;
const char *even_page_init;
/* Options for this job */
int tumble;
int duplex_set;
int duplex;
int paper_size;
int manual_feed_set;
int manual_feed;
int media_position_set;
int media_position;
int orientation;
/* Updated as we move through the job */
int page_count;
} fz_pcl_options;
/**
Initialize PCL option struct for a given preset.
Currently defined presets include:
generic Generic PCL printer
ljet4 HP DeskJet
dj500 HP DeskJet 500
fs600 Kyocera FS-600
lj HP LaserJet, HP LaserJet Plus
lj2 HP LaserJet IIp, HP LaserJet IId
lj3 HP LaserJet III
lj3d HP LaserJet IIId
lj4 HP LaserJet 4
lj4pl HP LaserJet 4 PL
lj4d HP LaserJet 4d
lp2563b HP 2563B line printer
oce9050 Oce 9050 Line printer
*/
void fz_pcl_preset(fz_context *ctx, fz_pcl_options *opts, const char *preset);
/**
Parse PCL options.
Currently defined options and values are as follows:
preset=X Either "generic" or one of the presets as for fz_pcl_preset.
spacing=0 No vertical spacing capability
spacing=1 PCL 3 spacing (<ESC>*p+<n>Y)
spacing=2 PCL 4 spacing (<ESC>*b<n>Y)
spacing=3 PCL 5 spacing (<ESC>*b<n>Y and clear seed row)
mode2 Disable/Enable mode 2 graphics compression
mode3 Disable/Enable mode 3 graphics compression
eog_reset End of graphics (<ESC>*rB) resets all parameters
has_duplex Duplex supported (<ESC>&l<duplex>S)
has_papersize Papersize setting supported (<ESC>&l<sizecode>A)
has_copies Number of copies supported (<ESC>&l<copies>X)
is_ljet4pjl Disable/Enable HP 4PJL model-specific output
is_oce9050 Disable/Enable Oce 9050 model-specific output
*/
fz_pcl_options *fz_parse_pcl_options(fz_context *ctx, fz_pcl_options *opts, const char *args);
/**
Create a new band writer, outputing monochrome pcl.
*/
fz_band_writer *fz_new_mono_pcl_band_writer(fz_context *ctx, fz_output *out, const fz_pcl_options *options);
/**
Write a bitmap as mono PCL.
*/
void fz_write_bitmap_as_pcl(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pcl_options *pcl);
/**
Save a bitmap as mono PCL.
*/
void fz_save_bitmap_as_pcl(fz_context *ctx, fz_bitmap *bitmap, char *filename, int append, const fz_pcl_options *pcl);
/**
Create a new band writer, outputing color pcl.
*/
fz_band_writer *fz_new_color_pcl_band_writer(fz_context *ctx, fz_output *out, const fz_pcl_options *options);
/**
Write an (RGB) pixmap as color PCL.
*/
void fz_write_pixmap_as_pcl(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pcl_options *pcl);
/**
Save an (RGB) pixmap as color PCL.
*/
void fz_save_pixmap_as_pcl(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, const fz_pcl_options *pcl);
/**
PCLm output
*/
typedef struct
{
int compress;
int strip_height;
/* Updated as we move through the job */
int page_count;
} fz_pclm_options;
/**
Parse PCLm options.
Currently defined options and values are as follows:
compression=none: No compression
compression=flate: Flate compression
strip-height=n: Strip height (default 16)
*/
fz_pclm_options *fz_parse_pclm_options(fz_context *ctx, fz_pclm_options *opts, const char *args);
/**
Create a new band writer, outputing pclm
*/
fz_band_writer *fz_new_pclm_band_writer(fz_context *ctx, fz_output *out, const fz_pclm_options *options);
/**
Write a (Greyscale or RGB) pixmap as pclm.
*/
void fz_write_pixmap_as_pclm(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pclm_options *options);
/**
Save a (Greyscale or RGB) pixmap as pclm.
*/
void fz_save_pixmap_as_pclm(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, const fz_pclm_options *options);
/**
PDFOCR output
*/
typedef struct
{
int compress;
int strip_height;
char language[256];
char datadir[1024];
/* Updated as we move through the job */
int page_count;
} fz_pdfocr_options;
/**
Parse PDFOCR options.
Currently defined options and values are as follows:
compression=none: No compression
compression=flate: Flate compression
strip-height=n: Strip height (default 16)
ocr-language=<lang>: OCR Language (default eng)
ocr-datadir=<datadir>: OCR data path (default rely on TESSDATA_PREFIX)
*/
fz_pdfocr_options *fz_parse_pdfocr_options(fz_context *ctx, fz_pdfocr_options *opts, const char *args);
/**
Create a new band writer, outputing pdfocr.
Ownership of output stays with the caller, the band writer
borrows the reference. The caller must keep the output around
for the duration of the band writer, and then close/drop as
appropriate.
*/
fz_band_writer *fz_new_pdfocr_band_writer(fz_context *ctx, fz_output *out, const fz_pdfocr_options *options);
/**
Set the progress callback for a pdfocr bandwriter.
*/
void fz_pdfocr_band_writer_set_progress(fz_context *ctx, fz_band_writer *writer, fz_pdfocr_progress_fn *progress_fn, void *progress_arg);
/**
Write a (Greyscale or RGB) pixmap as pdfocr.
*/
void fz_write_pixmap_as_pdfocr(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pdfocr_options *options);
/**
Save a (Greyscale or RGB) pixmap as pdfocr.
*/
void fz_save_pixmap_as_pdfocr(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, const fz_pdfocr_options *options);
/**
Save a (Greyscale or RGB) pixmap as a png.
*/
void fz_save_pixmap_as_png(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/**
Write a pixmap as a JPEG.
*/
void fz_write_pixmap_as_jpeg(fz_context *ctx, fz_output *out, fz_pixmap *pix, int quality, int invert_cmyk);
/**
Save a pixmap as a JPEG.
*/
void fz_save_pixmap_as_jpeg(fz_context *ctx, fz_pixmap *pixmap, const char *filename, int quality);
/**
Write a (Greyscale or RGB) pixmap as a png.
*/
void fz_write_pixmap_as_png(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap);
/**
Pixmap data as JP2K with no subsampling.
quality = 100 = lossless
otherwise for a factor of x compression use 100-x. (so 80 is 1:20 compression)
*/
void fz_write_pixmap_as_jpx(fz_context *ctx, fz_output *out, fz_pixmap *pix, int quality);
/**
Save pixmap data as JP2K with no subsampling.
quality = 100 = lossless
otherwise for a factor of x compression use 100-x. (so 80 is 1:20 compression)
*/
void fz_save_pixmap_as_jpx(fz_context *ctx, fz_pixmap *pixmap, const char *filename, int q);
/**
Create a new png band writer (greyscale or RGB, with or without
alpha).
*/
fz_band_writer *fz_new_png_band_writer(fz_context *ctx, fz_output *out);
/**
Reencode a given image as a PNG into a buffer.
Ownership of the buffer is returned.
*/
fz_buffer *fz_new_buffer_from_image_as_png(fz_context *ctx, fz_image *image, fz_color_params color_params);
fz_buffer *fz_new_buffer_from_image_as_pnm(fz_context *ctx, fz_image *image, fz_color_params color_params);
fz_buffer *fz_new_buffer_from_image_as_pam(fz_context *ctx, fz_image *image, fz_color_params color_params);
fz_buffer *fz_new_buffer_from_image_as_psd(fz_context *ctx, fz_image *image, fz_color_params color_params);
fz_buffer *fz_new_buffer_from_image_as_jpeg(fz_context *ctx, fz_image *image, fz_color_params color_params, int quality, int invert_cmyk);
fz_buffer *fz_new_buffer_from_image_as_jpx(fz_context *ctx, fz_image *image, fz_color_params color_params, int quality);
/**
Reencode a given pixmap as a PNG into a buffer.
Ownership of the buffer is returned.
*/
fz_buffer *fz_new_buffer_from_pixmap_as_png(fz_context *ctx, fz_pixmap *pixmap, fz_color_params color_params);
fz_buffer *fz_new_buffer_from_pixmap_as_pnm(fz_context *ctx, fz_pixmap *pixmap, fz_color_params color_params);
fz_buffer *fz_new_buffer_from_pixmap_as_pam(fz_context *ctx, fz_pixmap *pixmap, fz_color_params color_params);
fz_buffer *fz_new_buffer_from_pixmap_as_psd(fz_context *ctx, fz_pixmap *pix, fz_color_params color_params);
fz_buffer *fz_new_buffer_from_pixmap_as_jpeg(fz_context *ctx, fz_pixmap *pixmap, fz_color_params color_params, int quality, int invert_cmyk);
fz_buffer *fz_new_buffer_from_pixmap_as_jpx(fz_context *ctx, fz_pixmap *pix, fz_color_params color_params, int quality);
/**
Save a pixmap as a pnm (greyscale or rgb, no alpha).
*/
void fz_save_pixmap_as_pnm(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/**
Write a pixmap as a pnm (greyscale or rgb, no alpha).
*/
void fz_write_pixmap_as_pnm(fz_context *ctx, fz_output *out, fz_pixmap *pixmap);
/**
Create a band writer targetting pnm (greyscale or rgb, no
alpha).
*/
fz_band_writer *fz_new_pnm_band_writer(fz_context *ctx, fz_output *out);
/**
Save a pixmap as a pnm (greyscale, rgb or cmyk, with or without
alpha).
*/
void fz_save_pixmap_as_pam(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/**
Write a pixmap as a pnm (greyscale, rgb or cmyk, with or without
alpha).
*/
void fz_write_pixmap_as_pam(fz_context *ctx, fz_output *out, fz_pixmap *pixmap);
/**
Create a band writer targetting pnm (greyscale, rgb or cmyk,
with or without alpha).
*/
fz_band_writer *fz_new_pam_band_writer(fz_context *ctx, fz_output *out);
/**
Save a bitmap as a pbm.
*/
void fz_save_bitmap_as_pbm(fz_context *ctx, fz_bitmap *bitmap, const char *filename);
/**
Write a bitmap as a pbm.
*/
void fz_write_bitmap_as_pbm(fz_context *ctx, fz_output *out, fz_bitmap *bitmap);
/**
Create a new band writer, targetting pbm.
*/
fz_band_writer *fz_new_pbm_band_writer(fz_context *ctx, fz_output *out);
/**
Save a pixmap as a pbm. (Performing halftoning).
*/
void fz_save_pixmap_as_pbm(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/**
Save a CMYK bitmap as a pkm.
*/
void fz_save_bitmap_as_pkm(fz_context *ctx, fz_bitmap *bitmap, const char *filename);
/**
Write a CMYK bitmap as a pkm.
*/
void fz_write_bitmap_as_pkm(fz_context *ctx, fz_output *out, fz_bitmap *bitmap);
/**
Create a new pkm band writer for CMYK pixmaps.
*/
fz_band_writer *fz_new_pkm_band_writer(fz_context *ctx, fz_output *out);
/**
Save a CMYK pixmap as a pkm. (Performing halftoning).
*/
void fz_save_pixmap_as_pkm(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/**
Write a (gray, rgb, or cmyk, no alpha) pixmap out as postscript.
*/
void fz_write_pixmap_as_ps(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap);
/**
Save a (gray, rgb, or cmyk, no alpha) pixmap out as postscript.
*/
void fz_save_pixmap_as_ps(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append);
/**
Create a postscript band writer for gray, rgb, or cmyk, no
alpha.
*/
fz_band_writer *fz_new_ps_band_writer(fz_context *ctx, fz_output *out);
/**
Write the file level header for ps band writer output.
*/
void fz_write_ps_file_header(fz_context *ctx, fz_output *out);
/**
Write the file level trailer for ps band writer output.
*/
void fz_write_ps_file_trailer(fz_context *ctx, fz_output *out, int pages);
/**
Save a pixmap as a PSD file.
*/
void fz_save_pixmap_as_psd(fz_context *ctx, fz_pixmap *pixmap, const char *filename);
/**
Write a pixmap as a PSD file.
*/
void fz_write_pixmap_as_psd(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap);
/**
Open a PSD band writer.
*/
fz_band_writer *fz_new_psd_band_writer(fz_context *ctx, fz_output *out);
typedef struct
{
/* These are not interpreted as CStrings by the writing code,
* but are rather copied directly out. */
char media_class[64];
char media_color[64];
char media_type[64];
char output_type[64];
unsigned int advance_distance;
int advance_media;
int collate;
int cut_media;
int duplex;
int insert_sheet;
int jog;
int leading_edge;
int manual_feed;
unsigned int media_position;
unsigned int media_weight;
int mirror_print;
int negative_print;
unsigned int num_copies;
int orientation;
int output_face_up;
unsigned int PageSize[2];
int separations;
int tray_switch;
int tumble;
int media_type_num;
int compression;
unsigned int row_count;
unsigned int row_feed;
unsigned int row_step;
/* These are not interpreted as CStrings by the writing code, but
* are rather copied directly out. */
char rendering_intent[64];
char page_size_name[64];
} fz_pwg_options;
/**
Save a pixmap as a PWG.
*/
void fz_save_pixmap_as_pwg(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, const fz_pwg_options *pwg);
/**
Save a bitmap as a PWG.
*/
void fz_save_bitmap_as_pwg(fz_context *ctx, fz_bitmap *bitmap, char *filename, int append, const fz_pwg_options *pwg);
/**
Write a pixmap as a PWG.
*/
void fz_write_pixmap_as_pwg(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg);
/**
Write a bitmap as a PWG.
*/
void fz_write_bitmap_as_pwg(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pwg_options *pwg);
/**
Write a pixmap as a PWG page.
Caller should provide a file header by calling
fz_write_pwg_file_header, but can then write several pages to
the same file.
*/
void fz_write_pixmap_as_pwg_page(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg);
/**
Write a bitmap as a PWG page.
Caller should provide a file header by calling
fz_write_pwg_file_header, but can then write several pages to
the same file.
*/
void fz_write_bitmap_as_pwg_page(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pwg_options *pwg);
/**
Create a new monochrome pwg band writer.
*/
fz_band_writer *fz_new_mono_pwg_band_writer(fz_context *ctx, fz_output *out, const fz_pwg_options *pwg);
/**
Create a new color pwg band writer.
*/
fz_band_writer *fz_new_pwg_band_writer(fz_context *ctx, fz_output *out, const fz_pwg_options *pwg);
/**
Output the file header to a pwg stream, ready for pages to follow it.
*/
void fz_write_pwg_file_header(fz_context *ctx, fz_output *out); /* for use by mudraw.c */
#endif

217
include/mupdf/fitz/writer.h
View File

@@ -1,3 +1,25 @@
// Copyright (C) 2004-2023 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_WRITER_H
#define MUPDF_FITZ_WRITER_H
@@ -7,28 +29,28 @@
#include "mupdf/fitz/document.h"
#include "mupdf/fitz/device.h"
typedef struct fz_document_writer_s fz_document_writer;
typedef struct fz_document_writer fz_document_writer;
/*
fz_document_writer_begin_page_fn: Function type to start
/**
Function type to start
the process of writing a page to a document.
mediabox: page size rectangle in points.
Returns a fz_device to write page contents to.
*/
typedef fz_device *(fz_document_writer_begin_page_fn)(fz_context *ctx, fz_document_writer *wri, const fz_rect *mediabox);
typedef fz_device *(fz_document_writer_begin_page_fn)(fz_context *ctx, fz_document_writer *wri, fz_rect mediabox);
/*
fz_document_writer_end_page_fn: Function type to end the
/**
Function type to end the
process of writing a page to a document.
dev: The device created by the begin_page function.
*/
typedef void (fz_document_writer_end_page_fn)(fz_context *ctx, fz_document_writer *wri, fz_device *dev);
/*
fz_document_writer_close_writer_fn: Function type to end
/**
Function type to end
the process of writing pages to a document.
This writes any file level trailers required. After this
@@ -36,8 +58,8 @@ typedef void (fz_document_writer_end_page_fn)(fz_context *ctx, fz_document_write
*/
typedef void (fz_document_writer_close_writer_fn)(fz_context *ctx, fz_document_writer *wri);
/*
fz_document_writer_drop_writer_fn: Function type to discard
/**
Function type to discard
an fz_document_writer. This may be called at any time during
the process to release all the resources owned by the writer.
@@ -47,63 +69,111 @@ typedef void (fz_document_writer_close_writer_fn)(fz_context *ctx, fz_document_w
*/
typedef void (fz_document_writer_drop_writer_fn)(fz_context *ctx, fz_document_writer *wri);
/*
Structure is public to allow other structures to
be derived from it. Do not access members directly.
*/
struct fz_document_writer_s
{
fz_document_writer_begin_page_fn *begin_page;
fz_document_writer_end_page_fn *end_page;
fz_document_writer_close_writer_fn *close_writer;
fz_document_writer_drop_writer_fn *drop_writer;
fz_device *dev;
};
/*
fz_new_document_writer_of_size: Internal function to allocate a
block for a derived document_writer structure, with the base
structure's function pointers populated correctly, and the extra
space zero initialised.
*/
fz_document_writer *fz_new_document_writer_of_size(fz_context *ctx, size_t size,
fz_document_writer_begin_page_fn *begin_page,
fz_document_writer_end_page_fn *end_page,
fz_document_writer_close_writer_fn *close,
fz_document_writer_drop_writer_fn *drop);
#define fz_new_derived_document_writer(CTX,TYPE,BEGIN_PAGE,END_PAGE,CLOSE,DROP) \
((TYPE *)Memento_label(fz_new_document_writer_of_size(CTX,sizeof(TYPE),BEGIN_PAGE,END_PAGE,CLOSE,DROP),#TYPE))
/**
Look for a given option (key) in the opts string. Return 1 if
it has it, and update *val to point to the value within opts.
*/
int fz_has_option(fz_context *ctx, const char *opts, const char *key, const char **val);
/**
Check to see if an option, a, from a string matches a reference
option, b.
(i.e. a could be 'foo' or 'foo,bar...' etc, but b can only be
'foo'.)
*/
int fz_option_eq(const char *a, const char *b);
/*
fz_new_document_writer: Create a new fz_document_writer, for a
/**
Copy an option (val) into a destination buffer (dest), of maxlen
bytes.
Returns the number of bytes (including terminator) that did not
fit. If val is maxlen or greater bytes in size, it will be left
unterminated.
*/
size_t fz_copy_option(fz_context *ctx, const char *val, char *dest, size_t maxlen);
/**
Create a new fz_document_writer, for a
file of the given type.
path: The document name to write (or NULL for default)
format: Which format to write (currently cbz, html, pdf, pam, pbm,
pgm, pkm, png, ppm, pnm, svg, text, tga, xhtml)
format: Which format to write (currently cbz, html, pdf, pam,
pbm, pgm, pkm, png, ppm, pnm, svg, text, xhtml, docx, odt)
options: NULL, or pointer to comma separated string to control
file generation.
*/
fz_document_writer *fz_new_document_writer(fz_context *ctx, const char *path, const char *format, const char *options);
/**
Like fz_new_document_writer but takes a fz_output for writing
the result. Only works for multi-page formats.
*/
fz_document_writer *
fz_new_document_writer_with_output(fz_context *ctx, fz_output *out, const char *format, const char *options);
fz_document_writer *
fz_new_document_writer_with_buffer(fz_context *ctx, fz_buffer *buf, const char *format, const char *options);
/**
Document writers for various possible output formats.
All of the "_with_output" variants pass the ownership of out in
immediately upon calling. The writers are responsible for
dropping the fz_output when they are finished with it (even
if they throw an exception during creation).
*/
fz_document_writer *fz_new_pdf_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pdf_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
fz_document_writer *fz_new_svg_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_svg_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
fz_document_writer *fz_new_text_writer(fz_context *ctx, const char *format, const char *path, const char *options);
fz_document_writer *fz_new_text_writer_with_output(fz_context *ctx, const char *format, fz_output *out, const char *options);
fz_document_writer *fz_new_odt_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_odt_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
fz_document_writer *fz_new_docx_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_docx_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
fz_document_writer *fz_new_ps_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_ps_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
fz_document_writer *fz_new_pcl_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pcl_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
fz_document_writer *fz_new_pclm_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pclm_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
fz_document_writer *fz_new_pwg_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pwg_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
fz_document_writer *fz_new_cbz_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_cbz_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
/**
Used to report progress of the OCR operation.
page: Current page being processed.
percent: Progress of the OCR operation for the
current page in percent. Whether it reaches 100
once a page is finished, depends on the OCR engine.
Return 0 to continue progress, return 1 to cancel the
operation.
*/
typedef int (fz_pdfocr_progress_fn)(fz_context *ctx, void *progress_arg, int page, int percent);
fz_document_writer *fz_new_pdfocr_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pdfocr_writer_with_output(fz_context *ctx, fz_output *out, const char *options);
void fz_pdfocr_writer_set_progress(fz_context *ctx, fz_document_writer *writer, fz_pdfocr_progress_fn *progress, void *);
fz_document_writer *fz_new_jpeg_pixmap_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_png_pixmap_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_tga_pixmap_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pam_pixmap_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pnm_pixmap_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pgm_pixmap_writer(fz_context *ctx, const char *path, const char *options);
@@ -111,24 +181,31 @@ fz_document_writer *fz_new_ppm_pixmap_writer(fz_context *ctx, const char *path,
fz_document_writer *fz_new_pbm_pixmap_writer(fz_context *ctx, const char *path, const char *options);
fz_document_writer *fz_new_pkm_pixmap_writer(fz_context *ctx, const char *path, const char *options);
/*
fz_begin_page: Called to start the process of writing a page to
/**
Called to start the process of writing a page to
a document.
mediabox: page size rectangle in points.
Returns a fz_device to write page contents to.
Returns a borrowed fz_device to write page contents to. This
should be kept if required, and only dropped if it was kept.
*/
fz_device *fz_begin_page(fz_context *ctx, fz_document_writer *wri, const fz_rect *mediabox);
fz_device *fz_begin_page(fz_context *ctx, fz_document_writer *wri, fz_rect mediabox);
/*
fz_end_page: Called to end the process of writing a page to a
/**
Called to end the process of writing a page to a
document.
*/
void fz_end_page(fz_context *ctx, fz_document_writer *wri);
/*
fz_close_document_writer: Called to end the process of writing
/**
Convenience function to feed all the pages of a document to
fz_begin_page/fz_run_page/fz_end_page.
*/
void fz_write_document(fz_context *ctx, fz_document_writer *wri, fz_document *doc);
/**
Called to end the process of writing
pages to a document.
This writes any file level trailers required. After this
@@ -136,8 +213,8 @@ void fz_end_page(fz_context *ctx, fz_document_writer *wri);
*/
void fz_close_document_writer(fz_context *ctx, fz_document_writer *wri);
/*
fz_drop_document_writer: Called to discard a fz_document_writer.
/**
Called to discard a fz_document_writer.
This may be called at any time during the process to release all
the resources owned by the writer.
@@ -149,11 +226,41 @@ void fz_drop_document_writer(fz_context *ctx, fz_document_writer *wri);
fz_document_writer *fz_new_pixmap_writer(fz_context *ctx, const char *path, const char *options, const char *default_path, int n,
void (*save)(fz_context *ctx, fz_pixmap *pix, const char *filename));
extern const char *fz_pdf_write_options_usage;
extern const char *fz_svg_write_options_usage;
FZ_DATA extern const char *fz_pdf_write_options_usage;
FZ_DATA extern const char *fz_svg_write_options_usage;
FZ_DATA extern const char *fz_pcl_write_options_usage;
FZ_DATA extern const char *fz_pclm_write_options_usage;
FZ_DATA extern const char *fz_pwg_write_options_usage;
FZ_DATA extern const char *fz_pdfocr_write_options_usage;
/* Implementation details: subject to change. */
/**
Structure is public to allow other structures to
be derived from it. Do not access members directly.
*/
struct fz_document_writer
{
fz_document_writer_begin_page_fn *begin_page;
fz_document_writer_end_page_fn *end_page;
fz_document_writer_close_writer_fn *close_writer;
fz_document_writer_drop_writer_fn *drop_writer;
fz_device *dev;
};
/**
Internal function to allocate a
block for a derived document_writer structure, with the base
structure's function pointers populated correctly, and the extra
space zero initialised.
*/
fz_document_writer *fz_new_document_writer_of_size(fz_context *ctx, size_t size,
fz_document_writer_begin_page_fn *begin_page,
fz_document_writer_end_page_fn *end_page,
fz_document_writer_close_writer_fn *close,
fz_document_writer_drop_writer_fn *drop);
extern const char *fz_pcl_write_options_usage;
extern const char *fz_pclm_write_options_usage;
extern const char *fz_pwg_write_options_usage;
#endif

373
include/mupdf/fitz/xml.h
View File

@@ -1,88 +1,397 @@
// Copyright (C) 2004-2022 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_XML_H
#define MUPDF_FITZ_XML_H
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/pool.h"
#include "mupdf/fitz/archive.h"
/*
/**
XML document model
*/
typedef struct fz_xml_doc_s fz_xml_doc;
typedef struct fz_xml_s fz_xml;
typedef struct fz_xml fz_xml;
/*
fz_parse_xml: Parse the contents of buffer into a tree of xml nodes.
/* For backwards compatibility */
typedef fz_xml fz_xml_doc;
/**
Parse the contents of buffer into a tree of xml nodes.
preserve_white: whether to keep or delete all-whitespace nodes.
*/
fz_xml_doc *fz_parse_xml(fz_context *ctx, fz_buffer *buf, int preserve_white);
fz_xml *fz_parse_xml(fz_context *ctx, fz_buffer *buf, int preserve_white);
/*
fz_drop_xml: Free the XML node and all its children and siblings.
/**
Parse the contents of buffer into a tree of xml nodes.
preserve_white: whether to keep or delete all-whitespace nodes.
*/
void fz_drop_xml(fz_context *ctx, fz_xml_doc *xml);
fz_xml *fz_parse_xml_stream(fz_context *ctx, fz_stream *stream, int preserve_white);
/*
fz_detach_xml: Detach a node from the tree, unlinking it from its parent,
/**
Parse the contents of an archive entry into a tree of xml nodes.
preserve_white: whether to keep or delete all-whitespace nodes.
*/
fz_xml *fz_parse_xml_archive_entry(fz_context *ctx, fz_archive *dir, const char *filename, int preserve_white);
/**
Try and parse the contents of an archive entry into a tree of xml nodes.
preserve_white: whether to keep or delete all-whitespace nodes.
Will return NULL if the archive entry can't be found. Otherwise behaves
the same as fz_parse_xml_archive_entry. May throw exceptions.
*/
fz_xml *fz_try_parse_xml_archive_entry(fz_context *ctx, fz_archive *dir, const char *filename, int preserve_white);
/**
Parse the contents of a buffer into a tree of XML nodes,
using the HTML5 parsing algorithm.
*/
fz_xml *fz_parse_xml_from_html5(fz_context *ctx, fz_buffer *buf);
/**
Add a reference to the XML.
*/
fz_xml *fz_keep_xml(fz_context *ctx, fz_xml *xml);
/**
Drop a reference to the XML. When the last reference is
dropped, the node and all its children and siblings will
be freed.
*/
void fz_drop_xml(fz_context *ctx, fz_xml *xml);
/**
Detach a node from the tree, unlinking it from its parent,
and setting the document root to the node.
*/
void fz_detach_xml(fz_context *ctx, fz_xml_doc *xml, fz_xml *node);
void fz_detach_xml(fz_context *ctx, fz_xml *node);
/*
fz_xml_root: Get the root node for the document.
/**
Return the topmost XML node of a document.
*/
fz_xml *fz_xml_root(fz_xml_doc *xml);
/*
fz_xml_prev: Return previous sibling of XML node.
/**
Return previous sibling of XML node.
*/
fz_xml *fz_xml_prev(fz_xml *item);
/*
fz_xml_next: Return next sibling of XML node.
/**
Return next sibling of XML node.
*/
fz_xml *fz_xml_next(fz_xml *item);
/*
fz_xml_up: Return parent of XML node.
/**
Return parent of XML node.
*/
fz_xml *fz_xml_up(fz_xml *item);
/*
fz_xml_down: Return first child of XML node.
/**
Return first child of XML node.
*/
fz_xml *fz_xml_down(fz_xml *item);
/*
fz_xml_is_tag: Return true if the tag name matches.
/**
Return true if the tag name matches.
*/
int fz_xml_is_tag(fz_xml *item, const char *name);
/*
fz_xml_tag: Return tag of XML node. Return NULL for text nodes.
/**
Return tag of XML node. Return NULL for text nodes.
*/
char *fz_xml_tag(fz_xml *item);
/*
fz_xml_att: Return the value of an attribute of an XML node.
/**
Return the value of an attribute of an XML node.
NULL if the attribute doesn't exist.
*/
char *fz_xml_att(fz_xml *item, const char *att);
/*
fz_xml_text: Return the text content of an XML node.
/**
Return the value of an attribute of an XML node.
If the first attribute doesn't exist, try the second.
NULL if neither attribute exists.
*/
char *fz_xml_att_alt(fz_xml *item, const char *one, const char *two);
/**
Check for a matching attribute on an XML node.
If the node has the requested attribute (name), and the value
matches (match) then return 1. Otherwise, 0.
*/
int fz_xml_att_eq(fz_xml *item, const char *name, const char *match);
/**
Add an attribute to an XML node.
*/
void fz_xml_add_att(fz_context *ctx, fz_pool *pool, fz_xml *node, const char *key, const char *val);
/**
Return the text content of an XML node.
Return NULL if the node is a tag.
*/
char *fz_xml_text(fz_xml *item);
/*
fz_debug_xml: Pretty-print an XML tree to stdout.
/**
Pretty-print an XML tree to given output.
*/
void fz_output_xml(fz_context *ctx, fz_output *out, fz_xml *item, int level);
/**
Pretty-print an XML tree to stdout. (Deprecated, use
fz_output_xml in preference).
*/
void fz_debug_xml(fz_xml *item, int level);
/**
Search the siblings of XML nodes starting with item looking for
the first with the given tag.
Return NULL if none found.
*/
fz_xml *fz_xml_find(fz_xml *item, const char *tag);
/**
Search the siblings of XML nodes starting with the first sibling
of item looking for the first with the given tag.
Return NULL if none found.
*/
fz_xml *fz_xml_find_next(fz_xml *item, const char *tag);
/**
Search the siblings of XML nodes starting with the first child
of item looking for the first with the given tag.
Return NULL if none found.
*/
fz_xml *fz_xml_find_down(fz_xml *item, const char *tag);
/**
Search the siblings of XML nodes starting with item looking for
the first with the given tag (or any tag if tag is NULL), and
with a matching attribute.
Return NULL if none found.
*/
fz_xml *fz_xml_find_match(fz_xml *item, const char *tag, const char *att, const char *match);
/**
Search the siblings of XML nodes starting with the first sibling
of item looking for the first with the given tag (or any tag if tag
is NULL), and with a matching attribute.
Return NULL if none found.
*/
fz_xml *fz_xml_find_next_match(fz_xml *item, const char *tag, const char *att, const char *match);
/**
Search the siblings of XML nodes starting with the first child
of item looking for the first with the given tag (or any tag if
tag is NULL), and with a matching attribute.
Return NULL if none found.
*/
fz_xml *fz_xml_find_down_match(fz_xml *item, const char *tag, const char *att, const char *match);
/**
Perform a depth first search from item, returning the first
child that matches the given tag (or any tag if tag is NULL),
with the given attribute (if att is non NULL), that matches
match (if match is non NULL).
*/
fz_xml *fz_xml_find_dfs(fz_xml *item, const char *tag, const char *att, const char *match);
/**
Perform a depth first search from item, returning the first
child that matches the given tag (or any tag if tag is NULL),
with the given attribute (if att is non NULL), that matches
match (if match is non NULL). The search stops if it ever
reaches the top of the tree, or the declared 'top' item.
*/
fz_xml *fz_xml_find_dfs_top(fz_xml *item, const char *tag, const char *att, const char *match, fz_xml *top);
/**
Perform a depth first search onwards from item, returning the first
child that matches the given tag (or any tag if tag is NULL),
with the given attribute (if att is non NULL), that matches
match (if match is non NULL).
*/
fz_xml *fz_xml_find_next_dfs(fz_xml *item, const char *tag, const char *att, const char *match);
/**
Perform a depth first search onwards from item, returning the first
child that matches the given tag (or any tag if tag is NULL),
with the given attribute (if att is non NULL), that matches
match (if match is non NULL). The search stops if it ever reaches
the top of the tree, or the declared 'top' item.
*/
fz_xml *fz_xml_find_next_dfs_top(fz_xml *item, const char *tag, const char *att, const char *match, fz_xml *top);
/**
DOM-like functions for html in xml.
*/
/**
Return a borrowed reference for the 'body' element of
the given DOM.
*/
fz_xml *fz_dom_body(fz_context *ctx, fz_xml *dom);
/**
Return a borrowed reference for the document (the top
level element) of the DOM.
*/
fz_xml *fz_dom_document_element(fz_context *ctx, fz_xml *dom);
/**
Create an element of a given tag type for the given DOM.
The element is not linked into the DOM yet.
*/
fz_xml *fz_dom_create_element(fz_context *ctx, fz_xml *dom, const char *tag);
/**
Create a text node for the given DOM.
The element is not linked into the DOM yet.
*/
fz_xml *fz_dom_create_text_node(fz_context *ctx, fz_xml *dom, const char *text);
/**
Find the first element matching the requirements in a depth first traversal from elt.
The tagname must match tag, unless tag is NULL, when all tag names are considered to match.
If att is NULL, then all tags match.
Otherwise:
If match is NULL, then only nodes that have an att attribute match.
If match is non-NULL, then only nodes that have an att attribute that matches match match.
Returns NULL (if no match found), or a borrowed reference to the first matching element.
*/
fz_xml *fz_dom_find(fz_context *ctx, fz_xml *elt, const char *tag, const char *att, const char *match);
/**
Find the next element matching the requirements.
*/
fz_xml *fz_dom_find_next(fz_context *ctx, fz_xml *elt, const char *tag, const char *att, const char *match);
/**
Insert an element as the last child of a parent, unlinking the
child from its current position if required.
*/
void fz_dom_append_child(fz_context *ctx, fz_xml *parent, fz_xml *child);
/**
Insert an element (new_elt), before another element (node),
unlinking the new_elt from its current position if required.
*/
void fz_dom_insert_before(fz_context *ctx, fz_xml *node, fz_xml *new_elt);
/**
Insert an element (new_elt), after another element (node),
unlinking the new_elt from its current position if required.
*/
void fz_dom_insert_after(fz_context *ctx, fz_xml *node, fz_xml *new_elt);
/**
Remove an element from the DOM. The element can be added back elsewhere
if required.
No reference counting changes for the element.
*/
void fz_dom_remove(fz_context *ctx, fz_xml *elt);
/**
Clone an element (and its children).
A borrowed reference to the clone is returned. The clone is not
yet linked into the DOM.
*/
fz_xml *fz_dom_clone(fz_context *ctx, fz_xml *elt);
/**
Return a borrowed reference to the first child of a node,
or NULL if there isn't one.
*/
fz_xml *fz_dom_first_child(fz_context *ctx, fz_xml *elt);
/**
Return a borrowed reference to the parent of a node,
or NULL if there isn't one.
*/
fz_xml *fz_dom_parent(fz_context *ctx, fz_xml *elt);
/**
Return a borrowed reference to the next sibling of a node,
or NULL if there isn't one.
*/
fz_xml *fz_dom_next(fz_context *ctx, fz_xml *elt);
/**
Return a borrowed reference to the previous sibling of a node,
or NULL if there isn't one.
*/
fz_xml *fz_dom_previous(fz_context *ctx, fz_xml *elt);
/**
Add an attribute to an element.
Ownership of att and value remain with the caller.
*/
void fz_dom_add_attribute(fz_context *ctx, fz_xml *elt, const char *att, const char *value);
/**
Remove an attribute from an element.
*/
void fz_dom_remove_attribute(fz_context *ctx, fz_xml *elt, const char *att);
/**
Retrieve the value of a given attribute from a given element.
Returns a borrowed pointer to the value or NULL if not found.
*/
const char *fz_dom_attribute(fz_context *ctx, fz_xml *elt, const char *att);
/**
Enumerate through the attributes of an element.
Call with i=0,1,2,3... to enumerate attributes.
On return *att and the return value will be NULL if there are not
that many attributes to read. Otherwise, *att will be filled in
with a borrowed pointer to the attribute name, and the return
value will be a borrowed pointer to the value.
*/
const char *fz_dom_get_attribute(fz_context *ctx, fz_xml *elt, int i, const char **att);
#endif

184
include/mupdf/memento.h
View File

@@ -1,14 +1,16 @@
/* Copyright (C) 2009-2017 Artifex Software, Inc.
/* Copyright (C) 2009-2022 Artifex Software, Inc.
All Rights Reserved.
This software is provided AS-IS with no warranty, either express or
implied.
This software is distributed under license and may not be copied, modified
or distributed except as expressly authorized under the terms of that
license. Refer to licensing information at http://www.artifex.com
or contact Artifex Software, Inc., 7 Mt. Lassen Drive - Suite A-134,
San Rafael, CA 94903, U.S.A., +1(415)492-9861, for further information.
This software is distributed under license and may not be copied,
modified or distributed except as expressly authorized under the terms
of the license contained in the file COPYING in this distribution.
Refer to licensing information at http://www.artifex.com or contact
Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
CA 94129, USA, for further information.
*/
/* Memento: A library to aid debugging of memory leaks/heap corruption.
@@ -75,8 +77,7 @@
* An example:
* Suppose we have a gs invocation that crashes with memory corruption.
* * Build with -DMEMENTO.
* * In your debugger put breakpoints on Memento_inited and
* Memento_Breakpoint.
* * In your debugger put a breakpoint on Memento_breakpoint.
* * Run the program. It will stop in Memento_inited.
* * Execute Memento_setParanoia(1); (In VS use Ctrl-Alt-Q). (Note #1)
* * Continue execution.
@@ -92,9 +93,9 @@
* and 1458 - so if we rerun and stop the program at 1457, we can then
* step through, possibly with a data breakpoint at 0x172e710 and see
* when it occurs.
* * So restart the program from the beginning. When we hit Memento_inited
* execute Memento_breakAt(1457); (and maybe Memento_setParanoia(1), or
* Memento_setParanoidAt(1457))
* * So restart the program from the beginning. When we stop after
* initialisation execute Memento_breakAt(1457); (and maybe
* Memento_setParanoia(1), or Memento_setParanoidAt(1457))
* * Continue execution until we hit Memento_breakpoint.
* * Now you can step through and watch the memory corruption happen.
*
@@ -140,30 +141,99 @@
* Memento has some experimental code in it to trap new/delete (and
* new[]/delete[] if required) calls.
*
* In order for this to work, either:
* In all cases, Memento will provide a C API that new/delete
* operators can be built upon:
* void *Memento_cpp_new(size_t size);
* void Memento_cpp_delete(void *pointer);
* void *Memento_cpp_new_array(size_t size);
* void Memento_cpp_delete_array(void *pointer);
*
* 1) Build memento.c with the c++ compiler.
* There are various ways that actual operator definitions can be
* provided:
*
* 1) If memento.c is built with the c++ compiler, then global new
* and delete operators will be built in to memento by default.
*
* 2) If memento.c is built as normal with the C compiler, then
* no such veneers will be built in. The caller must provide them
* themselves. This can be done either by:
*
* a) Copying the lines between:
* // C++ Operator Veneers - START
* and
* // C++ Operator Veneers - END
* from memento.c into a C++ file within their own project.
*
* or
*
* 2) Build memento.c as normal with the C compiler, then from any
* one of your .cpp files, do:
* b) Add the following lines to a C++ file in the project:
* #define MEMENTO_CPP_EXTRAS_ONLY
* #include "memento.c"
*
* #define MEMENTO_CPP_EXTRAS_ONLY
* #include "memento.c"
* 3) For those people that would like to be able to compile memento.c
* with a C compiler, and provide new/delete veneers globally
* within their own C++ code (so avoiding the need for memento.h to
* be included from every file), define MEMENTO_NO_CPLUSPLUS as you
* build, and Memento will not provide any veneers itself, instead
* relying on the library user to provide them.
*
* In the case where MEMENTO is not defined, this will not do anything.
* For convenience the lines to implement such veneers can be found
* at the end of memento.c between:
* // C++ Operator Veneers - START
* and
* // C++ Operator Veneers - END
*
* Memento's interception of new/delete can be disabled at runtime
* by using Memento_setIgnoreNewDelete(1). Alternatively the
* MEMENTO_IGNORENEWDELETE environment variable can be set to 1 to
* achieve the same result.
*
* Both Windows and GCC provide separate new[] and delete[] operators
* for arrays. Apparently some systems do not. If this is the case for
* your system, define MEMENTO_CPP_NO_ARRAY_CONSTRUCTORS.
*
* "libbacktrace.so failed to load"
*
* In order to give nice backtraces on unix, Memento will try to use
* a libbacktrace dynamic library. If it can't find it, you'll see
* that warning, and your backtraces won't include file/line information.
*
* To fix this you'll need to build your own libbacktrace. Don't worry
* it's really easy:
* git clone git://github.com/ianlancetaylor/libbacktrace
* cd libbacktrace
* ./configure --enable-shared
* make
*
* This leaves the build .so as .libs/libbacktrace.so
*
* Memento will look for this on LD_LIBRARY_PATH, or in /opt/lib/,
* or in /lib/, or in /usr/lib/, or in /usr/local/lib/. I recommend
* using /opt/lib/ as this won't conflict with anything that you
* get via a package manager like apt.
*
* sudo mkdir /opt
* sudo mkdir /opt/lib
* sudo cp .libs/libbacktrace.so /opt/lib/
*/
#ifdef __cplusplus
// Avoids problems with strdup()'s throw() attribute on Linux.
#include <string.h>
extern "C" {
#endif
#ifndef MEMENTO_H
#define MEMENTO_H
/* Include all these first, so our definitions below do
* not conflict with them. */
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <stddef.h> /* for size_t */
#define MEMENTO_H
#ifndef MEMENTO_UNDERLYING_MALLOC
#define MEMENTO_UNDERLYING_MALLOC malloc
@@ -187,8 +257,6 @@
#define MEMENTO_ALLOCFILL 0xa8
#define MEMENTO_FREEFILL 0xa9
#define MEMENTO_FREELIST_MAX 0x2000000
int Memento_checkBlock(void *);
int Memento_checkAllMemory(void);
int Memento_check(void);
@@ -205,18 +273,36 @@ int Memento_failAt(int);
int Memento_failThisEvent(void);
void Memento_listBlocks(void);
void Memento_listNewBlocks(void);
void Memento_listPhasedBlocks(void);
size_t Memento_setMax(size_t);
void Memento_stats(void);
void *Memento_label(void *, const char *);
void Memento_tick(void);
int Memento_setVerbose(int);
/* Terminate backtraces if we see specified function name. E.g.
'cfunction_call' will exclude Python interpreter functions when Python calls C
code. Returns 0 on success, -1 on failure (out of memory). */
int Memento_addBacktraceLimitFnname(const char *fnname);
/* If <atexitfin> is 0, we do not call Memento_fin() in an atexit() handler. */
int Memento_setAtexitFin(int atexitfin);
int Memento_setIgnoreNewDelete(int ignore);
void *Memento_malloc(size_t s);
void *Memento_realloc(void *, size_t s);
void Memento_free(void *);
void *Memento_calloc(size_t, size_t);
char *Memento_strdup(const char*);
#if !defined(MEMENTO_GS_HACKS) && !defined(MEMENTO_MUPDF_HACKS)
int Memento_asprintf(char **ret, const char *format, ...);
int Memento_vasprintf(char **ret, const char *format, va_list ap);
#endif
void Memento_info(void *addr);
void Memento_listBlockInfo(void);
void Memento_blockInfo(void *blk);
void *Memento_takeByteRef(void *blk);
void *Memento_dropByteRef(void *blk);
void *Memento_takeShortRef(void *blk);
@@ -236,23 +322,48 @@ int Memento_checkIntPointerOrNull(void *blk);
void Memento_startLeaking(void);
void Memento_stopLeaking(void);
/* Returns number of allocation events so far. */
int Memento_sequence(void);
/* Returns non-zero if our process was forked by Memento squeeze. */
int Memento_squeezing(void);
void Memento_fin(void);
void Memento_bt(void);
void *Memento_cpp_new(size_t size);
void Memento_cpp_delete(void *pointer);
void *Memento_cpp_new_array(size_t size);
void Memento_cpp_delete_array(void *pointer);
void Memento_showHash(unsigned int hash);
#ifdef MEMENTO
#ifndef COMPILING_MEMENTO_C
#define malloc Memento_malloc
#define free Memento_free
#define realloc Memento_realloc
#define calloc Memento_calloc
#define malloc Memento_malloc
#define free Memento_free
#define realloc Memento_realloc
#define calloc Memento_calloc
#define strdup Memento_strdup
#if !defined(MEMENTO_GS_HACKS) && !defined(MEMENTO_MUPDF_HACKS)
#define asprintf Memento_asprintf
#define vasprintf Memento_vasprintf
#endif
#endif
#else
#define Memento_malloc MEMENTO_UNDERLYING_MALLOC
#define Memento_free MEMENTO_UNDERLYING_FREE
#define Memento_realloc MEMENTO_UNDERLYING_REALLOC
#define Memento_calloc MEMENTO_UNDERLYING_CALLOC
#define Memento_malloc MEMENTO_UNDERLYING_MALLOC
#define Memento_free MEMENTO_UNDERLYING_FREE
#define Memento_realloc MEMENTO_UNDERLYING_REALLOC
#define Memento_calloc MEMENTO_UNDERLYING_CALLOC
#define Memento_strdup strdup
#if !defined(MEMENTO_GS_HACKS) && !defined(MEMENTO_MUPDF_HACKS)
#define Memento_asprintf asprintf
#define Memento_vasprintf vasprintf
#endif
#define Memento_checkBlock(A) 0
#define Memento_checkAllMemory() 0
@@ -269,11 +380,13 @@ void Memento_fin(void);
#define Memento_failThisEvent() 0
#define Memento_listBlocks() do {} while (0)
#define Memento_listNewBlocks() do {} while (0)
#define Memento_listPhasedBlocks() do {} while (0)
#define Memento_setMax(A) 0
#define Memento_stats() do {} while (0)
#define Memento_label(A,B) (A)
#define Memento_info(A) do {} while (0)
#define Memento_listBlockInfo() do {} while (0)
#define Memento_blockInfo(A) do {} while (0)
#define Memento_takeByteRef(A) (A)
#define Memento_dropByteRef(A) (A)
#define Memento_takeShortRef(A) (A)
@@ -288,12 +401,23 @@ void Memento_fin(void);
#define Memento_checkBytePointerOrNull(A) 0
#define Memento_checkShortPointerOrNull(A) 0
#define Memento_checkIntPointerOrNull(A) 0
#define Memento_setIgnoreNewDelete(v) 0
#define Memento_tick() do {} while (0)
#define Memento_startLeaking() do {} while (0)
#define Memento_stopLeaking() do {} while (0)
#define Memento_fin() do {} while (0)
#define Memento_bt() do {} while (0)
#define Memento_sequence() (0)
#define Memento_squeezing() (0)
#define Memento_setVerbose(A) (A)
#define Memento_addBacktraceLimitFnname(A) (0)
#define Memento_setAtexitFin(atexitfin) (0)
#endif /* MEMENTO */
#ifdef __cplusplus
}
#endif
#endif /* MEMENTO_H */

3
include/mupdf/vendor.go Normal file
View File

@@ -0,0 +1,3 @@
//go:build required
package vendor

3
include/vendor.go Normal file
View File

@@ -0,0 +1,3 @@
//go:build required
package vendor