--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mupdf-source/source/fitz/load-jpx.c	Mon Sep 15 11:43:07 2025 +0200
@@ -0,0 +1,663 @@
+// 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.
+
+#include "mupdf/fitz.h"
+
+#include "pixmap-imp.h"
+
+#include <assert.h>
+#include <string.h>
+
+#if FZ_ENABLE_JPX
+
+static void
+jpx_ycc_to_rgb(fz_context *ctx, fz_pixmap *pix, int cbsign, int crsign)
+{
+	int w = pix->w;
+	int h = pix->h;
+	int stride = pix->stride;
+	int x, y;
+
+	for (y = 0; y < h; y++)
+	{
+		unsigned char * row = &pix->samples[stride * y];
+		for (x = 0; x < w; x++)
+		{
+			int ycc[3];
+			ycc[0] = row[x * 3 + 0];
+			ycc[1] = row[x * 3 + 1];
+			ycc[2] = row[x * 3 + 2];
+
+			/* consciously skip Y */
+			if (cbsign)
+				ycc[1] -= 128;
+			if (crsign)
+				ycc[2] -= 128;
+
+			row[x * 3 + 0] = fz_clampi(ycc[0] + 1.402f * ycc[2], 0, 255);
+			row[x * 3 + 1] = fz_clampi(ycc[0] - 0.34413f * ycc[1] - 0.71414f * ycc[2], 0, 255);
+			row[x * 3 + 2] = fz_clampi(ycc[0] + 1.772f * ycc[1], 0, 255);
+		}
+	}
+}
+
+#include <openjpeg.h>
+
+typedef struct
+{
+	int width;
+	int height;
+	fz_colorspace *cs;
+	int xres;
+	int yres;
+} fz_jpxd;
+
+typedef struct
+{
+	const unsigned char *data;
+	OPJ_SIZE_T size;
+	OPJ_SIZE_T pos;
+} stream_block;
+
+/* OpenJPEG does not provide a safe mechanism to intercept
+ * allocations. In the latest version all allocations go
+ * though opj_malloc etc, but no context is passed around.
+ *
+ * In order to ensure that allocations throughout mupdf
+ * are done consistently, we implement opj_malloc etc as
+ * functions that call down to fz_malloc etc. These
+ * require context variables, so we lock and unlock around
+ * calls to openjpeg. Any attempt to call through
+ * without setting these will be detected.
+ *
+ * It is therefore vital that any fz_lock/fz_unlock
+ * handlers are shared between all the fz_contexts in
+ * use at a time.
+ */
+
+/* Potentially we can write different versions
+ * of get_context and set_context for different
+ * threading systems.
+ */
+
+static fz_context *opj_secret = NULL;
+
+static void set_opj_context(fz_context *ctx)
+{
+	opj_secret = ctx;
+}
+
+static fz_context *get_opj_context(void)
+{
+	return opj_secret;
+}
+
+void opj_lock(fz_context *ctx)
+{
+	fz_ft_lock(ctx);
+
+	set_opj_context(ctx);
+}
+
+void opj_unlock(fz_context *ctx)
+{
+	set_opj_context(NULL);
+
+	fz_ft_unlock(ctx);
+}
+
+void *opj_malloc(size_t size)
+{
+	fz_context *ctx = get_opj_context();
+
+	assert(ctx != NULL);
+
+	return Memento_label(fz_malloc_no_throw(ctx, size), "opj_malloc");
+}
+
+void *opj_calloc(size_t n, size_t size)
+{
+	fz_context *ctx = get_opj_context();
+
+	assert(ctx != NULL);
+
+	return fz_calloc_no_throw(ctx, n, size);
+}
+
+void *opj_realloc(void *ptr, size_t size)
+{
+	fz_context *ctx = get_opj_context();
+
+	assert(ctx != NULL);
+
+	return fz_realloc_no_throw(ctx, ptr, size);
+}
+
+void opj_free(void *ptr)
+{
+	fz_context *ctx = get_opj_context();
+
+	assert(ctx != NULL);
+
+	fz_free(ctx, ptr);
+}
+
+static void * opj_aligned_malloc_n(size_t alignment, size_t size)
+{
+	uint8_t *ptr;
+	size_t off;
+
+	if (size == 0)
+		return NULL;
+
+	size += alignment + sizeof(uint8_t);
+	ptr = opj_malloc(size);
+	if (ptr == NULL)
+		return NULL;
+	off = alignment-(((int)(intptr_t)ptr) & (alignment - 1));
+	ptr[off-1] = (uint8_t)off;
+	return ptr + off;
+}
+
+void * opj_aligned_malloc(size_t size)
+{
+	return opj_aligned_malloc_n(16, size);
+}
+
+void * opj_aligned_32_malloc(size_t size)
+{
+	return opj_aligned_malloc_n(32, size);
+}
+
+void opj_aligned_free(void* ptr_)
+{
+	uint8_t *ptr = (uint8_t *)ptr_;
+	uint8_t off;
+	if (ptr == NULL)
+		return;
+
+	off = ptr[-1];
+	opj_free((void *)(((unsigned char *)ptr) - off));
+}
+
+#if 0
+/* UNUSED currently, and moderately tricky, so deferred until required */
+void * opj_aligned_realloc(void *ptr, size_t size)
+{
+	return opj_realloc(ptr, size);
+}
+#endif
+
+static void fz_opj_error_callback(const char *msg, void *client_data)
+{
+	fz_context *ctx = (fz_context *)client_data;
+	char buf[200];
+	size_t n;
+	fz_strlcpy(buf, msg, sizeof buf);
+	n = strlen(buf);
+	if (buf[n-1] == '\n')
+		buf[n-1] = 0;
+	fz_warn(ctx, "openjpeg error: %s", buf);
+}
+
+static void fz_opj_warning_callback(const char *msg, void *client_data)
+{
+	fz_context *ctx = (fz_context *)client_data;
+	char buf[200];
+	size_t n;
+	fz_strlcpy(buf, msg, sizeof buf);
+	n = strlen(buf);
+	if (buf[n-1] == '\n')
+		buf[n-1] = 0;
+	fz_warn(ctx, "openjpeg warning: %s", buf);
+}
+
+static void fz_opj_info_callback(const char *msg, void *client_data)
+{
+	/* fz_warn("openjpeg info: %s", msg); */
+}
+
+static OPJ_SIZE_T fz_opj_stream_read(void * p_buffer, OPJ_SIZE_T p_nb_bytes, void * p_user_data)
+{
+	stream_block *sb = (stream_block *)p_user_data;
+	OPJ_SIZE_T len;
+
+	len = sb->size - sb->pos;
+	if (len == 0)
+		return (OPJ_SIZE_T)-1; /* End of file! */
+	if (len > p_nb_bytes)
+		len = p_nb_bytes;
+	memcpy(p_buffer, sb->data + sb->pos, len);
+	sb->pos += len;
+	return len;
+}
+
+static OPJ_OFF_T fz_opj_stream_skip(OPJ_OFF_T skip, void * p_user_data)
+{
+	stream_block *sb = (stream_block *)p_user_data;
+
+	if (skip > (OPJ_OFF_T)(sb->size - sb->pos))
+		skip = (OPJ_OFF_T)(sb->size - sb->pos);
+	sb->pos += skip;
+	return sb->pos;
+}
+
+static OPJ_BOOL fz_opj_stream_seek(OPJ_OFF_T seek_pos, void * p_user_data)
+{
+	stream_block *sb = (stream_block *)p_user_data;
+
+	if (seek_pos > (OPJ_OFF_T)sb->size)
+		return OPJ_FALSE;
+	sb->pos = seek_pos;
+	return OPJ_TRUE;
+}
+
+static int32_t
+safe_mul32(fz_context *ctx, int32_t a, int32_t b)
+{
+	int64_t res = ((int64_t)a) * b;
+	int32_t res32 = (int32_t)res;
+
+	if ((res32) != res)
+		fz_throw(ctx, FZ_ERROR_LIMIT, "Overflow while decoding jpx");
+	return res32;
+}
+
+static int32_t
+safe_mla32(fz_context *ctx, int32_t a, int32_t b, int32_t c)
+{
+	int64_t res = ((int64_t)a) * b + c;
+	int32_t res32 = (int32_t)res;
+
+	if ((res32) != res)
+		fz_throw(ctx, FZ_ERROR_LIMIT, "Overflow while decoding jpx");
+	return res32;
+}
+
+static inline void
+template_copy_comp(unsigned char *dst0, int w, int h, int stride, const OPJ_INT32 *src, int32_t ox, int32_t oy, OPJ_UINT32 cdx, OPJ_UINT32 cdy, OPJ_UINT32 cw, OPJ_UINT32 ch, OPJ_UINT32 sgnd, OPJ_UINT32 prec, int comps)
+{
+	int x, y;
+
+	for (y = ch; oy + cdy <= 0 && y > 0; y--)
+	{
+		oy += cdy;
+		dst0 += cdy * stride;
+		src += cw;
+	}
+	for (; y > 0; y--)
+	{
+		int32_t dymin = oy;
+		int32_t dywid = cdy;
+		unsigned char *dst1 = dst0 + ox * comps;
+		int32_t oox = ox;
+		const OPJ_INT32 *src0 = src;
+
+		if (dymin < 0)
+			dywid += dymin, dst1 -= dymin * stride, dymin = 0;
+		if (dymin >= h)
+			break;
+		if (dymin + dywid > h)
+			dywid = h - dymin;
+
+		for (x = cw; oox + cdx <= 0 && x > 0; x--)
+		{
+			oox += cdx;
+			dst1 += cdx * comps;
+			src0++;
+		}
+		for (; x > 0; x--)
+		{
+			OPJ_INT32 v;
+			int32_t xx, yy;
+			int32_t dxmin = oox;
+			int32_t dxwid = cdx;
+			unsigned char *dst2;
+
+			v = *src0++;
+
+			if (sgnd)
+				v = v + (1 << (prec - 1));
+			if (prec > 8)
+				v = v >> (prec - 8);
+			else if (prec < 8)
+				v = v << (8 - prec);
+
+			if (dxmin < 0)
+				dxwid += dxmin, dst1 -= dxmin * comps, dxmin = 0;
+			if (dxmin >= w)
+				break;
+			if (dxmin + dxwid > w)
+				dxwid = w - dxmin;
+
+			dst2 = dst1;
+			for (yy = dywid; yy > 0; yy--)
+			{
+				unsigned char *dst3 = dst2;
+				for (xx = dxwid; xx > 0; xx--)
+				{
+					*dst3 = v;
+					dst3 += comps;
+				}
+				dst2 += stride;
+			}
+			dst1 += comps * cdx;
+			oox += cdx;
+		}
+		dst0 += stride * cdy;
+		src += cw;
+		oy += cdy;
+	}
+}
+
+static void
+copy_jpx_to_pixmap(fz_context *ctx, fz_pixmap *img, opj_image_t *jpx)
+{
+	unsigned char *dst;
+	int stride, comps;
+	int w = img->w;
+	int h = img->h;
+	int k;
+
+	stride = fz_pixmap_stride(ctx, img);
+	comps = fz_pixmap_components(ctx, img);
+	dst = fz_pixmap_samples(ctx, img);
+
+	for (k = 0; k < comps; k++)
+	{
+		opj_image_comp_t *comp = &(jpx->comps[k]);
+		OPJ_UINT32 cdx = comp->dx;
+		OPJ_UINT32 cdy = comp->dy;
+		OPJ_UINT32 cw = comp->w;
+		OPJ_UINT32 ch = comp->h;
+		int32_t oy = safe_mul32(ctx, comp->y0, cdy) - jpx->y0;
+		int32_t ox = safe_mul32(ctx, comp->x0, cdx) - jpx->x0;
+		unsigned char *dst0 = dst + oy * stride;
+		int prec = comp->prec;
+		int sgnd = comp->sgnd;
+
+		if (comp->data == NULL)
+			fz_throw(ctx, FZ_ERROR_FORMAT, "No data for JP2 image component %d", k);
+
+		if (fz_colorspace_is_indexed(ctx, img->colorspace))
+		{
+			prec = 8; /* Don't do any scaling! */
+			sgnd = 0;
+		}
+
+		/* Check that none of the following will overflow. */
+		(void)safe_mla32(ctx, ch, cdy, oy);
+		(void)safe_mla32(ctx, cw, cdx, ox);
+
+		if (cdx == 1 && cdy == 1)
+			template_copy_comp(dst0, w, h, stride, comp->data, ox, oy, 1 /*cdx*/, 1 /*cdy*/, cw, ch, sgnd, prec, comps);
+		else
+			template_copy_comp(dst0, w, h, stride, comp->data, ox, oy, cdx, cdy, cw, ch, sgnd, prec, comps);
+		dst++;
+	}
+}
+
+static fz_pixmap *
+jpx_read_image(fz_context *ctx, fz_jpxd *state, const unsigned char *data, size_t size, fz_colorspace *defcs, int onlymeta)
+{
+	fz_pixmap *img = NULL;
+	opj_dparameters_t params;
+	opj_codec_t *codec;
+	opj_image_t *jpx;
+	opj_stream_t *stream;
+	OPJ_CODEC_FORMAT format;
+	int a, n, k;
+	int w, h;
+	stream_block sb;
+	OPJ_UINT32 i;
+
+	fz_var(img);
+
+	if (size < 2)
+		fz_throw(ctx, FZ_ERROR_FORMAT, "not enough data to determine image format");
+
+	/* Check for SOC marker -- if found we have a bare J2K stream */
+	if (data[0] == 0xFF && data[1] == 0x4F)
+		format = OPJ_CODEC_J2K;
+	else
+		format = OPJ_CODEC_JP2;
+
+	opj_set_default_decoder_parameters(&params);
+	if (fz_colorspace_is_indexed(ctx, defcs))
+		params.flags |= OPJ_DPARAMETERS_IGNORE_PCLR_CMAP_CDEF_FLAG;
+
+	codec = opj_create_decompress(format);
+	opj_set_info_handler(codec, fz_opj_info_callback, ctx);
+	opj_set_warning_handler(codec, fz_opj_warning_callback, ctx);
+	opj_set_error_handler(codec, fz_opj_error_callback, ctx);
+	if (!opj_setup_decoder(codec, &params))
+	{
+		opj_destroy_codec(codec);
+		fz_throw(ctx, FZ_ERROR_LIBRARY, "j2k decode failed");
+	}
+
+	stream = opj_stream_default_create(OPJ_TRUE);
+	sb.data = data;
+	sb.pos = 0;
+	sb.size = size;
+
+	opj_stream_set_read_function(stream, fz_opj_stream_read);
+	opj_stream_set_skip_function(stream, fz_opj_stream_skip);
+	opj_stream_set_seek_function(stream, fz_opj_stream_seek);
+	opj_stream_set_user_data(stream, &sb, NULL);
+	/* Set the length to avoid an assert */
+	opj_stream_set_user_data_length(stream, size);
+
+	if (!opj_read_header(stream, codec, &jpx))
+	{
+		opj_stream_destroy(stream);
+		opj_destroy_codec(codec);
+		fz_throw(ctx, FZ_ERROR_LIBRARY, "Failed to read JPX header");
+	}
+
+	if (!opj_decode(codec, stream, jpx))
+	{
+		opj_stream_destroy(stream);
+		opj_destroy_codec(codec);
+		opj_image_destroy(jpx);
+		fz_throw(ctx, FZ_ERROR_LIBRARY, "Failed to decode JPX image");
+	}
+
+	opj_stream_destroy(stream);
+	opj_destroy_codec(codec);
+
+	/* jpx should never be NULL here, but check anyway */
+	if (!jpx)
+		fz_throw(ctx, FZ_ERROR_LIBRARY, "opj_decode failed");
+
+	/* Count number of alpha and color channels */
+	n = a = 0;
+	for (i = 0; i < jpx->numcomps; ++i)
+	{
+		if (jpx->comps[i].alpha)
+			++a;
+		else
+			++n;
+	}
+
+	for (k = 1; k < n + a; k++)
+	{
+		if (!jpx->comps[k].data)
+		{
+			opj_image_destroy(jpx);
+			fz_throw(ctx, FZ_ERROR_FORMAT, "image components are missing data");
+		}
+	}
+
+	w = state->width = jpx->x1 - jpx->x0;
+	h = state->height = jpx->y1 - jpx->y0;
+	state->xres = 72; /* openjpeg does not read the JPEG 2000 resc box */
+	state->yres = 72; /* openjpeg does not read the JPEG 2000 resc box */
+
+	if (w < 0 || h < 0)
+	{
+		opj_image_destroy(jpx);
+		fz_throw(ctx, FZ_ERROR_LIMIT, "Unbelievable size for jpx");
+	}
+
+	state->cs = NULL;
+
+	if (defcs)
+	{
+		if (defcs->n == n)
+			state->cs = fz_keep_colorspace(ctx, defcs);
+		else
+			fz_warn(ctx, "jpx file and dict colorspace do not match");
+	}
+
+#if FZ_ENABLE_ICC
+	if (!state->cs && jpx->icc_profile_buf && jpx->icc_profile_len > 0)
+	{
+		fz_buffer *cbuf = NULL;
+		fz_var(cbuf);
+
+		fz_try(ctx)
+		{
+			cbuf = fz_new_buffer_from_copied_data(ctx, jpx->icc_profile_buf, jpx->icc_profile_len);
+			state->cs = fz_new_icc_colorspace(ctx, FZ_COLORSPACE_NONE, 0, NULL, cbuf);
+		}
+		fz_always(ctx)
+			fz_drop_buffer(ctx, cbuf);
+		fz_catch(ctx)
+		{
+			fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
+			fz_report_error(ctx);
+			fz_warn(ctx, "ignoring embedded ICC profile in JPX");
+		}
+
+		if (state->cs && state->cs->n != n)
+		{
+			fz_warn(ctx, "invalid number of components in ICC profile, ignoring ICC profile in JPX");
+			fz_drop_colorspace(ctx, state->cs);
+			state->cs = NULL;
+		}
+	}
+#endif
+
+	if (!state->cs)
+	{
+		switch (n)
+		{
+		case 1: state->cs = fz_keep_colorspace(ctx, fz_device_gray(ctx)); break;
+		case 3: state->cs = fz_keep_colorspace(ctx, fz_device_rgb(ctx)); break;
+		case 4: state->cs = fz_keep_colorspace(ctx, fz_device_cmyk(ctx)); break;
+		default:
+			{
+				opj_image_destroy(jpx);
+				fz_throw(ctx, FZ_ERROR_FORMAT, "unsupported number of components: %d", n);
+			}
+		}
+	}
+
+	if (onlymeta)
+	{
+		opj_image_destroy(jpx);
+		return NULL;
+	}
+
+	fz_try(ctx)
+	{
+		a = !!a; /* ignore any superfluous alpha channels */
+		img = fz_new_pixmap(ctx, state->cs, w, h, NULL, a);
+		fz_clear_pixmap_with_value(ctx, img, 0);
+		copy_jpx_to_pixmap(ctx, img, jpx);
+
+		if (jpx->color_space == OPJ_CLRSPC_SYCC && n == 3 && a == 0)
+			jpx_ycc_to_rgb(ctx, img, 1, 1);
+		if (a)
+			fz_premultiply_pixmap(ctx, img);
+	}
+	fz_always(ctx)
+	{
+		fz_drop_colorspace(ctx, state->cs);
+		opj_image_destroy(jpx);
+	}
+	fz_catch(ctx)
+	{
+		fz_drop_pixmap(ctx, img);
+		fz_rethrow(ctx);
+	}
+
+	return img;
+}
+
+fz_pixmap *
+fz_load_jpx(fz_context *ctx, const unsigned char *data, size_t size, fz_colorspace *defcs)
+{
+	fz_jpxd state = { 0 };
+	fz_pixmap *pix = NULL;
+
+	fz_try(ctx)
+	{
+		opj_lock(ctx);
+		pix = jpx_read_image(ctx, &state, data, size, defcs, 0);
+	}
+	fz_always(ctx)
+		opj_unlock(ctx);
+	fz_catch(ctx)
+		fz_rethrow(ctx);
+
+	return pix;
+}
+
+void
+fz_load_jpx_info(fz_context *ctx, const unsigned char *data, size_t size, int *wp, int *hp, int *xresp, int *yresp, fz_colorspace **cspacep)
+{
+	fz_jpxd state = { 0 };
+
+	fz_try(ctx)
+	{
+		opj_lock(ctx);
+		jpx_read_image(ctx, &state, data, size, NULL, 1);
+	}
+	fz_always(ctx)
+		opj_unlock(ctx);
+	fz_catch(ctx)
+		fz_rethrow(ctx);
+
+	*cspacep = state.cs;
+	*wp = state.width;
+	*hp = state.height;
+	*xresp = state.xres;
+	*yresp = state.yres;
+}
+
+#else /* FZ_ENABLE_JPX */
+
+fz_pixmap *
+fz_load_jpx(fz_context *ctx, const unsigned char *data, size_t size, fz_colorspace *defcs)
+{
+	fz_throw(ctx, FZ_ERROR_UNSUPPORTED, "JPX support disabled");
+}
+
+void
+fz_load_jpx_info(fz_context *ctx, const unsigned char *data, size_t size, int *wp, int *hp, int *xresp, int *yresp, fz_colorspace **cspacep)
+{
+	fz_throw(ctx, FZ_ERROR_UNSUPPORTED, "JPX support disabled");
+}
+
+#endif