From d3391bef3cc9f5243368e8899e67f0fb864b57df Mon Sep 17 00:00:00 2001 From: iceman1001 Date: Fri, 21 Aug 2026 20:12:26 +0200 Subject: [PATCH] missing files for jpeg2000 --- client/deps/openjpeg.cmake | 35 +++++ client/src/imgjp2.c | 308 +++++++++++++++++++++++++++++++++++++ client/src/imgjp2.h | 47 ++++++ 3 files changed, 390 insertions(+) create mode 100644 client/deps/openjpeg.cmake create mode 100644 client/src/imgjp2.c create mode 100644 client/src/imgjp2.h diff --git a/client/deps/openjpeg.cmake b/client/deps/openjpeg.cmake new file mode 100644 index 000000000..403f6c32f --- /dev/null +++ b/client/deps/openjpeg.cmake @@ -0,0 +1,35 @@ +# Vendored openjpeg (openjp2), decoder + encoder core, BSD-2-Clause. +# Only the sources listed in upstream OPENJPEG_SRCS are kept, JPIP index +# handling is left out. See client/deps/openjpeg/README.pm3 +add_library(pm3rrg_rdv4_openjpeg STATIC + openjpeg/bio.c + openjpeg/cio.c + openjpeg/dwt.c + openjpeg/event.c + openjpeg/function_list.c + openjpeg/ht_dec.c + openjpeg/image.c + openjpeg/invert.c + openjpeg/j2k.c + openjpeg/jp2.c + openjpeg/mct.c + openjpeg/mqc.c + openjpeg/openjpeg.c + openjpeg/opj_clock.c + openjpeg/opj_malloc.c + openjpeg/pi.c + openjpeg/sparse_array.c + openjpeg/t1.c + openjpeg/t2.c + openjpeg/tcd.c + openjpeg/tgt.c + openjpeg/thread.c + ) + +target_include_directories(pm3rrg_rdv4_openjpeg INTERFACE openjpeg) +target_include_directories(pm3rrg_rdv4_openjpeg PRIVATE openjpeg) +# Third party code, don't hold it to our warning settings +target_compile_options(pm3rrg_rdv4_openjpeg PRIVATE -w -O3) +set_property(TARGET pm3rrg_rdv4_openjpeg PROPERTY POSITION_INDEPENDENT_CODE ON) +find_package(Threads REQUIRED) +target_link_libraries(pm3rrg_rdv4_openjpeg PRIVATE Threads::Threads) diff --git a/client/src/imgjp2.c b/client/src/imgjp2.c new file mode 100644 index 000000000..a90a36e5b --- /dev/null +++ b/client/src/imgjp2.c @@ -0,0 +1,308 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program 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 General Public License for more details. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// JPEG2000 decoding, so the picture viewer can show eMRTD biometrics. +//----------------------------------------------------------------------------- + +#include "imgjp2.h" + +#include +#include + +#include "openjpeg.h" +#include "ui.h" + +static const uint8_t jp2_signature[8] = { 0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20 }; +static const uint8_t j2k_signature[4] = { 0xFF, 0x4F, 0xFF, 0x51 }; + +// openjpeg has no memory stream of its own, it wants callbacks +typedef struct { + const uint8_t *data; + size_t len; + size_t pos; +} jp2_membuf_t; + +static OPJ_SIZE_T jp2_mem_read(void *buffer, OPJ_SIZE_T nb_bytes, void *user_data) { + jp2_membuf_t *mb = (jp2_membuf_t *)user_data; + + if (mb->pos >= mb->len) { + return (OPJ_SIZE_T) - 1; + } + + size_t remaining = mb->len - mb->pos; + if (nb_bytes > remaining) { + nb_bytes = remaining; + } + + memcpy(buffer, mb->data + mb->pos, nb_bytes); + mb->pos += nb_bytes; + return nb_bytes; +} + +static OPJ_OFF_T jp2_mem_skip(OPJ_OFF_T nb_bytes, void *user_data) { + jp2_membuf_t *mb = (jp2_membuf_t *)user_data; + + if (nb_bytes < 0) { + // rewinding past the start is a hard error + if ((OPJ_OFF_T)mb->pos + nb_bytes < 0) { + return (OPJ_OFF_T) - 1; + } + mb->pos = (size_t)((OPJ_OFF_T)mb->pos + nb_bytes); + return nb_bytes; + } + + size_t remaining = mb->len - mb->pos; + if ((OPJ_SIZE_T)nb_bytes > remaining) { + // skipping to the end is fine, it just means we're done + mb->pos = mb->len; + return (OPJ_OFF_T)remaining; + } + + mb->pos += (size_t)nb_bytes; + return nb_bytes; +} + +static OPJ_BOOL jp2_mem_seek(OPJ_OFF_T nb_bytes, void *user_data) { + jp2_membuf_t *mb = (jp2_membuf_t *)user_data; + + if (nb_bytes < 0 || (OPJ_SIZE_T)nb_bytes > mb->len) { + return OPJ_FALSE; + } + + mb->pos = (size_t)nb_bytes; + return OPJ_TRUE; +} + +static void jp2_err(const char *msg, void *client_data) { + (void)client_data; + PrintAndLogEx(DEBUG, "jpeg2000 error... %s", msg); +} + +static void jp2_warn(const char *msg, void *client_data) { + (void)client_data; + PrintAndLogEx(DEBUG, "jpeg2000 warning... %s", msg); +} + +static void jp2_info(const char *msg, void *client_data) { + (void)client_data; + (void)msg; +} + +bool jp2_is_jpeg2000(const uint8_t *data, size_t datalen) { + if (data == NULL) { + return false; + } + + if (datalen >= sizeof(jp2_signature) && memcmp(data, jp2_signature, sizeof(jp2_signature)) == 0) { + return true; + } + + if (datalen >= sizeof(j2k_signature) && memcmp(data, j2k_signature, sizeof(j2k_signature)) == 0) { + return true; + } + + return false; +} + +// Pull one sample out of a component and normalise it to 0..255. +// Handles signed components, precisions other than 8 bit and subsampling. +static uint8_t jp2_sample(const opj_image_comp_t *c, int x, int y) { + + int sx = x / (int)c->dx; + int sy = y / (int)c->dy; + + if (sx < 0) { + sx = 0; + } + if (sy < 0) { + sy = 0; + } + if (sx >= (int)c->w) { + sx = (int)c->w - 1; + } + if (sy >= (int)c->h) { + sy = (int)c->h - 1; + } + + int v = c->data[sy * (int)c->w + sx]; + + // signed components are stored centred on zero + if (c->sgnd) { + v += 1 << (c->prec - 1); + } + + // scale whatever precision we got to 8 bit + if (c->prec > 8) { + v >>= (c->prec - 8); + } else if (c->prec < 8) { + v <<= (8 - c->prec); + } + + if (v < 0) { + v = 0; + } + if (v > 255) { + v = 255; + } + + return (uint8_t)v; +} + +// ITU-R BT.601 , openjpeg leaves sYCC to the application +static void jp2_sycc_to_rgb(int y, int cb, int cr, uint8_t *rgb) { + + cb -= 128; + cr -= 128; + + int r = y + ((91881 * cr) >> 16); + int g = y - ((22554 * cb + 46802 * cr) >> 16); + int b = y + ((116130 * cb) >> 16); + + rgb[0] = (r < 0) ? 0 : ((r > 255) ? 255 : (uint8_t)r); + rgb[1] = (g < 0) ? 0 : ((g > 255) ? 255 : (uint8_t)g); + rgb[2] = (b < 0) ? 0 : ((b > 255) ? 255 : (uint8_t)b); +} + +uint8_t *jp2_decode_rgb(const uint8_t *data, size_t datalen, int *width, int *height) { + + if (data == NULL || width == NULL || height == NULL) { + return NULL; + } + + if (jp2_is_jpeg2000(data, datalen) == false) { + return NULL; + } + + OPJ_CODEC_FORMAT codec_format = OPJ_CODEC_J2K; + if (datalen >= sizeof(jp2_signature) && memcmp(data, jp2_signature, sizeof(jp2_signature)) == 0) { + codec_format = OPJ_CODEC_JP2; + } + + jp2_membuf_t mb = { data, datalen, 0 }; + uint8_t *rgb = NULL; + opj_image_t *image = NULL; + opj_codec_t *codec = NULL; + + // OPJ_TRUE == this is an input stream + opj_stream_t *stream = opj_stream_default_create(OPJ_TRUE); + if (stream == NULL) { + return NULL; + } + + opj_stream_set_read_function(stream, jp2_mem_read); + opj_stream_set_skip_function(stream, jp2_mem_skip); + opj_stream_set_seek_function(stream, jp2_mem_seek); + opj_stream_set_user_data(stream, &mb, NULL); + opj_stream_set_user_data_length(stream, datalen); + + codec = opj_create_decompress(codec_format); + if (codec == NULL) { + goto out; + } + + opj_set_error_handler(codec, jp2_err, NULL); + opj_set_warning_handler(codec, jp2_warn, NULL); + opj_set_info_handler(codec, jp2_info, NULL); + + opj_dparameters_t params; + opj_set_default_decoder_parameters(¶ms); + + if (opj_setup_decoder(codec, ¶ms) == OPJ_FALSE) { + goto out; + } + + if (opj_read_header(stream, codec, &image) == OPJ_FALSE) { + goto out; + } + + if (opj_decode(codec, stream, image) == OPJ_FALSE) { + goto out; + } + + if (opj_end_decompress(codec, stream) == OPJ_FALSE) { + goto out; + } + + if (image->numcomps < 1 || image->comps[0].data == NULL) { + PrintAndLogEx(DEBUG, "jpeg2000 image has no usable components"); + goto out; + } + + // work in the reference grid, components may be subsampled + int w = (int)(image->x1 - image->x0); + int h = (int)(image->y1 - image->y0); + if (w <= 0 || h <= 0) { + goto out; + } + + // sanity cap, a passport portrait is nowhere near this + if ((int64_t)w * (int64_t)h > (int64_t)64 * 1024 * 1024) { + PrintAndLogEx(DEBUG, "jpeg2000 image too large... %i x %i", w, h); + goto out; + } + + rgb = (uint8_t *)calloc((size_t)w * (size_t)h * 3, sizeof(uint8_t)); + if (rgb == NULL) { + goto out; + } + + bool have_color = (image->numcomps >= 3 && + image->comps[1].data != NULL && + image->comps[2].data != NULL); + + bool is_sycc = (image->color_space == OPJ_CLRSPC_SYCC); + + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) { + + uint8_t *out = rgb + ((size_t)y * (size_t)w + (size_t)x) * 3; + + if (have_color == false) { + // greyscale, replicate to all three channels + uint8_t v = jp2_sample(&image->comps[0], x, y); + out[0] = v; + out[1] = v; + out[2] = v; + continue; + } + + uint8_t c0 = jp2_sample(&image->comps[0], x, y); + uint8_t c1 = jp2_sample(&image->comps[1], x, y); + uint8_t c2 = jp2_sample(&image->comps[2], x, y); + + if (is_sycc) { + jp2_sycc_to_rgb(c0, c1, c2, out); + } else { + out[0] = c0; + out[1] = c1; + out[2] = c2; + } + } + } + + *width = w; + *height = h; + +out: + if (image) { + opj_image_destroy(image); + } + if (codec) { + opj_destroy_codec(codec); + } + opj_stream_destroy(stream); + + return rgb; +} diff --git a/client/src/imgjp2.h b/client/src/imgjp2.h new file mode 100644 index 000000000..fb3a337f2 --- /dev/null +++ b/client/src/imgjp2.h @@ -0,0 +1,47 @@ +//----------------------------------------------------------------------------- +// Copyright (C) Proxmark3 contributors. See AUTHORS.md for details. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program 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 General Public License for more details. +// +// See LICENSE.txt for the text of the license. +//----------------------------------------------------------------------------- +// JPEG2000 decoding, so the picture viewer can show eMRTD biometrics. +// +// Qt has no JPEG2000 image handler, the old JasPer based plugin was dropped +// from qtimageformats and distros don't ship a replacement. Most passports +// store EF_DG2 as JPEG2000, so we decode it ourselves with the vendored +// openjpeg in client/deps/openjpeg and hand plain RGB to the viewer. +//----------------------------------------------------------------------------- + +#ifndef IMGJP2_H__ +#define IMGJP2_H__ + +#include "common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// Does this buffer start with a JPEG2000 signature? +// Both the JP2 container (00 00 00 0C 6A 50 20 20) and a raw +// codestream (FF 4F FF 51) are recognized. +bool jp2_is_jpeg2000(const uint8_t *data, size_t datalen); + +// Decode a JPEG2000 image into a freshly allocated, tightly packed RGB888 +// buffer of w * h * 3 bytes. Returns NULL on failure, otherwise the caller +// owns the buffer and must free() it. +uint8_t *jp2_decode_rgb(const uint8_t *data, size_t datalen, int *width, int *height); + +#ifdef __cplusplus +} +#endif + +#endif // IMGJP2_H__