PyMuPDF 1.26.6__cp310-abi3-win_amd64.whl

pymupdf/mupdf-devel/include/mupdf/fitz/bidi.h

@@ -0,0 +1,90 @@
+/**
+	Bidirectional text processing.
+
+	Derived from the SmartOffice code, which is itself derived
+	from the example unicode standard code. Original copyright
+	messages follow:
+
+	Copyright (C) Picsel, 2004-2008. All Rights Reserved.
+
+	Processes Unicode text by arranging the characters into an order
+	suitable for display. E.g. Hebrew text will be arranged from
+	right-to-left and any English within the text will remain in the
+	left-to-right order.
+
+	This is an implementation of the Unicode Bidirectional Algorithm
+	which can be found here: http://www.unicode.org/reports/tr9/ and
+	is based on the reference implementation found on Unicode.org.
+*/
+
+#ifndef FITZ_BIDI_H
+#define FITZ_BIDI_H
+
+#include "mupdf/fitz/system.h"
+#include "mupdf/fitz/context.h"
+
+/* Implementation details: subject to change. */
+
+typedef enum
+{
+	FZ_BIDI_LTR = 0,
+	FZ_BIDI_RTL = 1,
+	FZ_BIDI_NEUTRAL = 2
+}
+fz_bidi_direction;
+
+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
+	@param	fragmentLen	number of characters in fragment
+	@param	bidiLevel	The bidirectional level for this text.
+				The bottom bit will be set iff block
+				should concatenate with other blocks as
+				right-to-left
+	@param	script		the script in use for this fragment (other
+				than common or inherited)
+	@param	arg		data from caller of Bidi_fragmentText
+*/
+typedef void (fz_bidi_fragment_fn)(const uint32_t *fragment,
+					size_t fragmentLen,
+					int bidiLevel,
+					int script,
+					void *arg);
+
+/**
+	Partitions the given Unicode sequence into one or more
+	unidirectional fragments and invokes the given callback
+	function for each fragment.
+
+	For example, if directionality of text is:
+			0123456789
+			rrlllrrrrr,
+	we'll invoke callback with:
+			&text[0], length == 2
+			&text[2], length == 3
+			&text[5], length == 5
+
+	@param[in] text	start of Unicode sequence
+	@param[in] textlen   number of Unicodes to analyse
+	@param[in] baseDir   direction of paragraph (specify FZ_BIDI_NEUTRAL to force auto-detection)
+	@param[in] callback  function to be called for each fragment
+	@param[in] arg	data to be passed to the callback function
+	@param[in] flags     flags to control operation (see fz_bidi_flags above)
+*/
+void fz_bidi_fragment_text(fz_context *ctx,
+			const uint32_t *text,
+			size_t textlen,
+			fz_bidi_direction *baseDir,
+			fz_bidi_fragment_fn *callback,
+			void *arg,
+			int flags);
+
+#endif

pymupdf/mupdf-devel/include/mupdf/fitz/bitmap.h

@@ -0,0 +1,188 @@
+// Copyright (C) 2004-2025 Artifex Software, Inc.
+//
+// This file is part of MuPDF.
+//
+// MuPDF is free software: you can redistribute it and/or modify it under the
+// terms of the GNU Affero General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+// details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
+//
+// Alternative licensing terms are available from the licensor.
+// For commercial licensing, see <https://www.artifex.com/> or contact
+// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
+// CA 94129, USA, for further information.
+
+#ifndef MUPDF_FITZ_BITMAP_H
+#define MUPDF_FITZ_BITMAP_H
+
+#include "mupdf/fitz/system.h"
+#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.
+
+	The internals of this struct are considered implementation
+	details and subject to change. Where possible, accessor
+	functions should be used in preference.
+*/
+typedef struct
+{
+	int refs;
+	int w, h, stride, n;
+	int xres, yres;
+	unsigned char *samples;
+} fz_bitmap;
+
+/**
+	Take an additional reference to the bitmap. The same pointer
+	is returned.
+
+	Never throws exceptions.
+*/
+fz_bitmap *fz_keep_bitmap(fz_context *ctx, fz_bitmap *bit);
+
+/**
+	Drop a reference to the bitmap. When the reference count reaches
+	zero, the bitmap will be destroyed.
+
+	Never throws exceptions.
+*/
+void fz_drop_bitmap(fz_context *ctx, fz_bitmap *bit);
+
+/**
+	Invert bitmap.
+
+	Never throws exceptions.
+*/
+void fz_invert_bitmap(fz_context *ctx, fz_bitmap *bmp);
+
+/**
+	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;
+
+/**
+	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.
+
+	Returns the resultant bitmap. Throws exceptions in the case of
+	failure to allocate.
+*/
+fz_bitmap *fz_new_bitmap_from_pixmap(fz_context *ctx, fz_pixmap *pix, fz_halftone *ht);
+
+/**
+	Make a bitmap from a pixmap and a halftone.
+
+	img: The image to generate from. Currently must be a single
+	color component with no alpha.
+
+	ht: The halftone to use. NULL implies the default halftone.
+
+	Returns the resultant bitmap. Throws exceptions in the case of
+	failure to allocate.
+*/
+fz_bitmap *fz_new_bitmap_from_image(fz_context *ctx, fz_image *img, fz_halftone *ht);
+
+/**
+	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.
+
+	ht: The halftone to use. NULL implies the default halftone.
+
+	band_start: Vertical offset within the overall banded rendering
+	(in pixels)
+
+	Returns the resultant bitmap. Throws exceptions in the case of
+	failure to allocate.
+*/
+fz_bitmap *fz_new_bitmap_from_pixmap_band(fz_context *ctx, fz_pixmap *pix, fz_halftone *ht, int band_start);
+
+/**
+	Create a new bitmap.
+
+	w, h: Width and Height for the bitmap
+
+	n: Number of color components (assumed to be a divisor of 8)
+
+	xres, yres: X and Y resolutions (in pixels per inch).
+
+	Returns pointer to created bitmap structure. The bitmap
+	data is uninitialised.
+*/
+fz_bitmap *fz_new_bitmap(fz_context *ctx, int w, int h, int n, int xres, int yres);
+
+/**
+	Retrieve details of a given bitmap.
+
+	bitmap: The bitmap to query.
+
+	w: Pointer to storage to retrieve width (or NULL).
+
+	h: Pointer to storage to retrieve height (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);
+
+/**
+	Set the entire bitmap to 0.
+
+	Never throws exceptions.
+*/
+void fz_clear_bitmap(fz_context *ctx, fz_bitmap *bit);
+
+/**
+	Create a 'default' halftone structure
+	for the given number of components.
+
+	num_comps: The number of components to use.
+
+	Returns a simple default halftone. The default halftone uses
+	the same halftone tile for each plane, which may not be ideal
+	for all purposes.
+*/
+fz_halftone *fz_default_halftone(fz_context *ctx, int num_comps);
+
+/**
+	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);
+
+/**
+	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);
+
+#endif

pymupdf/mupdf-devel/include/mupdf/fitz/buffer.h

@@ -0,0 +1,250 @@
+// 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.
+
+	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
+{
+	int refs;
+	unsigned char *data;
+	size_t cap, len;
+	int unused_bits;
+	int shared;
+} fz_buffer;
+
+/**
+	Take an additional reference to the buffer. The same pointer
+	is returned.
+
+	Never throws exceptions.
+*/
+fz_buffer *fz_keep_buffer(fz_context *ctx, fz_buffer *buf);
+
+/**
+	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);
+
+/**
+	Retrieve internal memory of buffer.
+
+	datap: Output parameter that will be pointed to the data.
+
+	Returns the current size of the data in bytes.
+*/
+size_t fz_buffer_storage(fz_context *ctx, fz_buffer *buf, unsigned char **datap);
+
+/**
+	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_buffer *fz_new_buffer(fz_context *ctx, size_t capacity);
+
+/**
+	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.
+
+	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);
+
+/**
+	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);
+
+/**
+	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);
+
+/**
+	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);
+
+/**
+	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.
+*/
+void fz_resize_buffer(fz_context *ctx, fz_buffer *buf, size_t capacity);
+
+/**
+	Make some space within a buffer (i.e. ensure that
+	capacity > size).
+*/
+void fz_grow_buffer(fz_context *ctx, fz_buffer *buf);
+
+/**
+	Trim wasted capacity from a buffer by resizing internal memory.
+*/
+void fz_trim_buffer(fz_context *ctx, fz_buffer *buf);
+
+/**
+	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.
+
+	The buffer will automatically grow as required.
+*/
+void fz_append_data(fz_context *ctx, fz_buffer *buf, const void *data, size_t len);
+void fz_append_string(fz_context *ctx, fz_buffer *buf, const char *data);
+void fz_append_byte(fz_context *ctx, fz_buffer *buf, int c);
+void fz_append_rune(fz_context *ctx, fz_buffer *buf, int c);
+void fz_append_int32_le(fz_context *ctx, fz_buffer *buf, int x);
+void fz_append_int16_le(fz_context *ctx, fz_buffer *buf, int x);
+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);
+
+/**
+	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_append_printf: Format and append data to buffer using
+	printf-like formatting (see fz_vsnprintf).
+
+	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);
+
+/**
+	Create an MD5 digest from buffer contents.
+
+	Never throws exceptions.
+*/
+void fz_md5_buffer(fz_context *ctx, fz_buffer *buffer, unsigned char digest[16]);
+
+/**
+	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.
+
+	Note: Bad things may happen if this is called on a buffer with
+	multiple references that is being used from multiple threads.
+
+	data: Pointer to place to retrieve data pointer.
+
+	Returns length of stream.
+*/
+size_t fz_buffer_extract(fz_context *ctx, fz_buffer *buf, unsigned char **data);
+
+#endif