From 9adb6f3427448d9187c97493c933ea2b491783b6 Mon Sep 17 00:00:00 2001 From: Jeremy Nguyen Date: Wed, 30 Sep 2026 15:48:59 -0700 Subject: [PATCH 1/4] refactor(image-utils): rewrite C++ code to adhere better to standards - Remove "using" directive and instead use emscripten namespace - Include C/C++ std headers when necessary - Use std::equal instead of memcpy - Use std namespace for C std functions - Use std::optional in more reasonable way - Rename constants based on C++ naming scheme --- packages/image-utils/ports/libheif.py | 4 +- packages/image-utils/src/codecs/heif.cpp | 52 +++++++----- packages/image-utils/src/codecs/heif.h | 4 +- packages/image-utils/src/codecs/jpeg.cpp | 75 +++++++++++------- packages/image-utils/src/codecs/jpeg.h | 4 +- packages/image-utils/src/codecs/png.cpp | 69 +++++++++------- packages/image-utils/src/codecs/png.h | 4 +- packages/image-utils/src/codecs/webp.cpp | 79 +++++++++++-------- packages/image-utils/src/codecs/webp.h | 4 +- .../src/{constants.hpp => constants.h} | 7 +- packages/image-utils/src/main.cpp | 6 +- 11 files changed, 182 insertions(+), 126 deletions(-) rename packages/image-utils/src/{constants.hpp => constants.h} (66%) diff --git a/packages/image-utils/ports/libheif.py b/packages/image-utils/ports/libheif.py index f72b3f4f..058cef2a 100644 --- a/packages/image-utils/ports/libheif.py +++ b/packages/image-utils/ports/libheif.py @@ -173,8 +173,8 @@ def create(final): # enable virtual-function-elimination, which also requires lto=full. # # `heif_context_read_from_memory_without_copy` - # -> `HeifContext::read` -> `HeifContext::interpret_heif_file` - # -> `HeifContext::interpret_heif_file_images` + # -> `HeifContext::read` + # -> `HeifContext::interpret_heif_file` # -> `HeifContext::interpret_heif_file_images` # -> `ImageItem::alloc_for_infe_box` # diff --git a/packages/image-utils/src/codecs/heif.cpp b/packages/image-utils/src/codecs/heif.cpp index 94994012..16ec27fd 100644 --- a/packages/image-utils/src/codecs/heif.cpp +++ b/packages/image-utils/src/codecs/heif.cpp @@ -1,11 +1,19 @@ +#include "heif.h" + +#include +#include + +#include +#include +#include + +#include #include #include #include -#include "../constants.hpp" -#include "heif.h" - -using namespace emscripten; +#include "../common.h" +#include "../constants.h" std::optional heif_get_exif_data(const std::string heif_data) { struct heif_context *ctx = heif_context_alloc(); @@ -31,7 +39,7 @@ std::optional heif_get_exif_data(const std::string heif_data) { if (n == 1) { size_t exif_size = heif_image_handle_get_metadata_size(image_handle, exif_item_id); - uint8_t *exif_data = static_cast(malloc(exif_size)); + uint8_t *exif_data = static_cast(std::malloc(exif_size)); if (exif_data != nullptr) { struct heif_error metadata_err = @@ -41,35 +49,37 @@ std::optional heif_get_exif_data(const std::string heif_data) { // The first four bytes are the offset to the start of the TIFF header // of the Exif data exif_size -= 4; - memmove(exif_data, exif_data + 4, exif_size); + std::memmove(exif_data, exif_data + 4, exif_size); const bool has_exif_header = - exif_size >= std::size(constants::ExifHeader) && - std::equal(std::begin(constants::ExifHeader), - std::end(constants::ExifHeader), exif_data); + exif_size >= std::size(constants::kExifHeader) && + std::equal(std::begin(constants::kExifHeader), + std::end(constants::kExifHeader), exif_data); // From the very small sample size I've seen, it seems that HEIC files // begin with the Exif header and AVIF files do not if (has_exif_header) { - output = Uint8Array(val(typed_memory_view(exif_size, exif_data))); + output = Uint8Array(emscripten::val( + emscripten::typed_memory_view(exif_size, exif_data))); } else { auto *exif_data_with_header = static_cast( - malloc(std::size(constants::ExifHeader) + exif_size)); + std::malloc(std::size(constants::kExifHeader) + exif_size)); if (exif_data_with_header != nullptr) { - memcpy(exif_data_with_header, constants::ExifHeader, - std::size(constants::ExifHeader)); - memcpy(exif_data_with_header + std::size(constants::ExifHeader), - exif_data, exif_size); - - output = Uint8Array(val( - typed_memory_view(std::size(constants::ExifHeader) + exif_size, - exif_data_with_header))); + std::memcpy(exif_data_with_header, constants::kExifHeader, + std::size(constants::kExifHeader)); + std::memcpy(exif_data_with_header + + std::size(constants::kExifHeader), + exif_data, exif_size); + + output = Uint8Array(emscripten::val(emscripten::typed_memory_view( + std::size(constants::kExifHeader) + exif_size, + exif_data_with_header))); } - free(exif_data); + std::free(exif_data); } } else { - free(exif_data); + std::free(exif_data); } } } diff --git a/packages/image-utils/src/codecs/heif.h b/packages/image-utils/src/codecs/heif.h index 34f1dd0c..e27f12a7 100644 --- a/packages/image-utils/src/codecs/heif.h +++ b/packages/image-utils/src/codecs/heif.h @@ -1,6 +1,8 @@ #pragma once +#include +#include + #include "../common.h" -#include std::optional heif_get_exif_data(const std::string heif_data); diff --git a/packages/image-utils/src/codecs/jpeg.cpp b/packages/image-utils/src/codecs/jpeg.cpp index 31dd56f8..5bb79c7b 100644 --- a/packages/image-utils/src/codecs/jpeg.cpp +++ b/packages/image-utils/src/codecs/jpeg.cpp @@ -1,23 +1,28 @@ -#include +#include "jpeg.h" -#include +#include -#include "../constants.hpp" -#include "jpeg.h" +#include +#include +#include -using namespace emscripten; +#include +#include + +#include "../common.h" +#include "../constants.h" // "JFIF\0" -constexpr unsigned char JfifHeader[5] = {0x4A, 0x46, 0x49, 0x46, 0x00}; +constexpr uint8_t kJfifHeader[5] = {0x4A, 0x46, 0x49, 0x46, 0x00}; // "Adobe" -constexpr unsigned char AdobeHeader[5] = {0x41, 0x64, 0x6F, 0x62, 0x65}; +constexpr uint8_t kAdobeHeader[5] = {0x41, 0x64, 0x6F, 0x62, 0x65}; -constexpr int JPEG_APP1 = JPEG_APP0 + 1; -constexpr int JPEG_APP14 = JPEG_APP0 + 14; +constexpr int kApp1Marker = JPEG_APP0 + 1; +constexpr int kApp14Marker = JPEG_APP0 + 14; // Does not include the two bytes needed for the data size // https://github.com/winlibs/libjpeg/blob/66ef88ad97f3c47eb1c7b85f2637ff1073ebce9b/src/jcicc.c#L37 -constexpr int MAX_BYTES_IN_MARKER = 0xFFFF - 2; +constexpr int kMaxBytesInMarker = 0xFFFF - 2; /** * @see {@link @@ -25,7 +30,7 @@ constexpr int MAX_BYTES_IN_MARKER = 0xFFFF - 2; */ Uint8Array jpeg_set_exif_data(const std::string jpeg_data, const std::string exif_data) { - if (exif_data.size() > MAX_BYTES_IN_MARKER) { + if (exif_data.size() > kMaxBytesInMarker) { throw std::invalid_argument("Exif data is too big!"); } @@ -38,25 +43,30 @@ Uint8Array jpeg_set_exif_data(const std::string jpeg_data, jpeg_create_decompress(&srcinfo); jpeg_create_compress(&dstinfo); - unsigned char *out_buffer; - size_t out_size; + unsigned char *output_data; + size_t output_size; jpeg_mem_src(&srcinfo, reinterpret_cast(jpeg_data.data()), jpeg_data.size()); - jpeg_mem_dest(&dstinfo, &out_buffer, &out_size); + jpeg_mem_dest(&dstinfo, &output_data, &output_size); + // Save all APPn markers for (int index = 0; index < 16; index++) { - jpeg_save_markers(&srcinfo, JPEG_APP0 + index, 0xFFFF); + jpeg_save_markers(&srcinfo, JPEG_APP0 + index, /* length_limit */ 0xFFFF); } const int header_result = jpeg_read_header(&srcinfo, /* require_image */ boolean::TRUE); + // Since require_image is true, header_result can only be + // JPEG_SUSPENDED/JPEG_HEADER_OK if (header_result != JPEG_HEADER_OK) { jpeg_destroy_compress(&dstinfo); jpeg_destroy_decompress(&srcinfo); throw std::invalid_argument("Invalid JPEG data"); } + // Get raw DCT coefficients for lossless encoding + // https://github.com/winlibs/libjpeg/blob/66ef88ad97f3c47eb1c7b85f2637ff1073ebce9b/src/jpeglib.h#L1131-L1132 jvirt_barray_ptr *src_coefficients = jpeg_read_coefficients(&srcinfo); jpeg_copy_critical_parameters(&srcinfo, &dstinfo); @@ -64,12 +74,13 @@ Uint8Array jpeg_set_exif_data(const std::string jpeg_data, jpeg_write_coefficients(&dstinfo, src_coefficients); bool is_exif_marker_found = false; + // Update marker in srcinfo with our Exif data for (jpeg_saved_marker_ptr marker = srcinfo.marker_list; marker != NULL; marker = marker->next) { - if (marker->marker == JPEG_APP1 && - marker->data_length >= std::size(constants::ExifHeader) && - memcmp(marker->data, constants::ExifHeader, - std::size(constants::ExifHeader)) == 0) { + if (marker->marker == kApp1Marker && + marker->data_length >= std::size(constants::kExifHeader) && + std::equal(std::begin(constants::kExifHeader), + std::end(constants::kExifHeader), marker->data)) { is_exif_marker_found = true; marker->data = reinterpret_cast( const_cast(exif_data.data())); @@ -80,26 +91,33 @@ Uint8Array jpeg_set_exif_data(const std::string jpeg_data, for (jpeg_saved_marker_ptr marker = srcinfo.marker_list; marker != nullptr; marker = marker->next) { + // Only write JFIF marker when dstinfo.write_JFIF_header (false for non-JFIF + // colorspaces) if (dstinfo.write_JFIF_header && marker->marker == JPEG_APP0 && - marker->data_length >= std::size(JfifHeader) && - memcmp(marker->data, JfifHeader, std::size(JfifHeader)) == 0) + marker->data_length >= std::size(kJfifHeader) && + std::equal(std::begin(kJfifHeader), std::end(kJfifHeader), + marker->data)) { continue; - if (dstinfo.write_Adobe_marker && marker->marker == JPEG_APP14 && - marker->data_length >= std::size(AdobeHeader) && - memcmp(marker->data, AdobeHeader, std::size(AdobeHeader)) == 0) + } + // Only write Adobe marker when dstinfo.write_Adobe_marker + if (dstinfo.write_Adobe_marker && marker->marker == kApp14Marker && + marker->data_length >= std::size(kAdobeHeader) && + std::equal(std::begin(kAdobeHeader), std::end(kAdobeHeader), + marker->data)) { continue; + } jpeg_write_marker(&dstinfo, marker->marker, marker->data, marker->data_length); } - // Appending to the end of the JPEG markers if there is no original Exif - // marker since that is how libexif's exif CLI handles adding Exif data + // If there is no Exif marker in jpeg_data, append one to the end. This is how + // libexif's CLI tool exif handles adding Exif data // // https://github.com/libexif/exif/blob/9af1f54d5879e72d0b2bf78f65162db84ebcba26/libjpeg/jpeg-data.c#L493 if (!is_exif_marker_found) { jpeg_write_marker( - &dstinfo, JPEG_APP1, + &dstinfo, kApp1Marker, reinterpret_cast(const_cast(exif_data.data())), exif_data.size()); } @@ -110,5 +128,6 @@ Uint8Array jpeg_set_exif_data(const std::string jpeg_data, jpeg_finish_decompress(&srcinfo); jpeg_destroy_decompress(&srcinfo); - return Uint8Array(val(typed_memory_view(out_size, out_buffer))); + return Uint8Array( + emscripten::val(emscripten::typed_memory_view(output_size, output_data))); } diff --git a/packages/image-utils/src/codecs/jpeg.h b/packages/image-utils/src/codecs/jpeg.h index 152b074f..357710ae 100644 --- a/packages/image-utils/src/codecs/jpeg.h +++ b/packages/image-utils/src/codecs/jpeg.h @@ -1,7 +1,9 @@ #pragma once +#include +#include + #include "../common.h" -#include Uint8Array jpeg_set_exif_data(const std::string jpeg_data, const std::string exif_data); diff --git a/packages/image-utils/src/codecs/png.cpp b/packages/image-utils/src/codecs/png.cpp index effa4d68..106a04cb 100644 --- a/packages/image-utils/src/codecs/png.cpp +++ b/packages/image-utils/src/codecs/png.cpp @@ -1,9 +1,17 @@ -#include - -#include "../constants.hpp" #include "png.h" -using namespace emscripten; +#include +#include + +#include +#include +#include +#include + +#include + +#include "../common.h" +#include "../constants.h" struct PngReadBuffer { const unsigned char *data; @@ -19,7 +27,7 @@ static void png_read_from_memory(png_structp png_ptr, png_bytep data, png_error(png_ptr, "unexpected end of PNG data"); } - memcpy(data, io_ptr->data + io_ptr->offset, length); + std::memcpy(data, io_ptr->data + io_ptr->offset, length); io_ptr->offset += length; } @@ -42,7 +50,7 @@ static void png_write_to_memory(png_structp png_ptr, png_bytep data, new_capacity = io_ptr->size + length; } auto *new_data = - static_cast(realloc(io_ptr->data, new_capacity)); + static_cast(std::realloc(io_ptr->data, new_capacity)); if (new_data == nullptr) { png_error(png_ptr, "failed to allocate memory for PNG buffer"); return; @@ -51,7 +59,7 @@ static void png_write_to_memory(png_structp png_ptr, png_bytep data, io_ptr->capacity = new_capacity; } - memcpy(io_ptr->data + io_ptr->size, data, length); + std::memcpy(io_ptr->data + io_ptr->size, data, length); io_ptr->size += length; } @@ -82,30 +90,29 @@ std::optional png_get_exif_data(const std::string png_data) { png_read_info(png_ptr, info_ptr); + std::optional output = std::nullopt; + #ifdef PNG_eXIf_SUPPORTED png_uint_32 exif_data_len = 0; png_bytep exif_data_ptr = nullptr; if (png_get_eXIf_1(png_ptr, info_ptr, &exif_data_len, &exif_data_ptr) != 0 && exif_data_ptr != nullptr && exif_data_len > 0) { - auto *output = static_cast( - malloc(std::size(constants::ExifHeader) + exif_data_len)); - if (output == nullptr) { - png_destroy_read_struct(&png_ptr, &info_ptr, nullptr); - return std::nullopt; + auto *exif_data = static_cast( + std::malloc(std::size(constants::kExifHeader) + exif_data_len)); + if (exif_data != nullptr) { + std::memcpy(exif_data, constants::kExifHeader, + std::size(constants::kExifHeader)); + std::memcpy(exif_data + std::size(constants::kExifHeader), exif_data_ptr, + exif_data_len); + output = Uint8Array(emscripten::val(emscripten::typed_memory_view( + std::size(constants::kExifHeader) + exif_data_len, exif_data))); } - - memcpy(output, constants::ExifHeader, std::size(constants::ExifHeader)); - memcpy(output + std::size(constants::ExifHeader), exif_data_ptr, - exif_data_len); - png_destroy_read_struct(&png_ptr, &info_ptr, nullptr); - return std::optional{Uint8Array(val(typed_memory_view( - std::size(constants::ExifHeader) + exif_data_len, output)))}; } #endif png_destroy_read_struct(&png_ptr, &info_ptr, nullptr); - return std::nullopt; + return output; } Uint8Array png_set_exif_data(const std::string png_data, @@ -122,7 +129,7 @@ Uint8Array png_set_exif_data(const std::string png_data, png_destroy_write_struct(&write_png_ptr, nullptr); } throw std::runtime_error( - "An error occurred while creating read_png_ptr or write_png_ptr"); + "An error occurred while creating read_png_ptr and/or write_png_ptr"); } png_infop info_ptr = png_create_info_struct(read_png_ptr); @@ -146,21 +153,23 @@ Uint8Array png_set_exif_data(const std::string png_data, png_read_png(read_png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL); #ifdef PNG_eXIf_SUPPORTED - bool has_exif_header = memcmp(exif_data.data(), constants::ExifHeader, - std::size(constants::ExifHeader)) == 0; + bool has_exif_header = + exif_data.size() >= std::size(constants::kExifHeader) && + std::equal(std::begin(constants::kExifHeader), + std::end(constants::kExifHeader), exif_data.data()); auto png_exif_data = reinterpret_cast(const_cast( - has_exif_header ? exif_data.data() + std::size(constants::ExifHeader) + has_exif_header ? exif_data.data() + std::size(constants::kExifHeader) : exif_data.data())); - auto png_exif_data_size = static_cast( - has_exif_header ? exif_data.size() - std::size(constants::ExifHeader) + auto png_exif_size = static_cast( + has_exif_header ? exif_data.size() - std::size(constants::kExifHeader) : exif_data.size()); - png_set_eXIf_1(read_png_ptr, info_ptr, png_exif_data_size, png_exif_data); + png_set_eXIf_1(read_png_ptr, info_ptr, png_exif_size, png_exif_data); #endif size_t rowbytes = png_get_rowbytes(read_png_ptr, info_ptr); PngWriteBuffer write_buffer = { - .data = static_cast(malloc(rowbytes)), + .data = static_cast(std::malloc(rowbytes)), .size = 0, .capacity = rowbytes}; png_set_write_fn(write_png_ptr, &write_buffer, png_write_to_memory, @@ -177,6 +186,6 @@ Uint8Array png_set_exif_data(const std::string png_data, png_destroy_read_struct(&read_png_ptr, &info_ptr, nullptr); png_destroy_write_struct(&write_png_ptr, nullptr); - return Uint8Array( - val(typed_memory_view(write_buffer.size, write_buffer.data))); + return Uint8Array(emscripten::val( + emscripten::typed_memory_view(write_buffer.size, write_buffer.data))); } diff --git a/packages/image-utils/src/codecs/png.h b/packages/image-utils/src/codecs/png.h index efaef567..80ca11b0 100644 --- a/packages/image-utils/src/codecs/png.h +++ b/packages/image-utils/src/codecs/png.h @@ -1,7 +1,9 @@ #pragma once +#include +#include + #include "../common.h" -#include std::optional png_get_exif_data(const std::string png_data); Uint8Array png_set_exif_data(const std::string png_data, diff --git a/packages/image-utils/src/codecs/webp.cpp b/packages/image-utils/src/codecs/webp.cpp index e1f69407..f3304d93 100644 --- a/packages/image-utils/src/codecs/webp.cpp +++ b/packages/image-utils/src/codecs/webp.cpp @@ -1,10 +1,20 @@ +#include "webp.h" + +#include +#include +#include + +#include +#include +#include +#include + +#include #include #include -#include "../constants.hpp" -#include "webp.h" - -using namespace emscripten; +#include "../common.h" +#include "../constants.h" std::optional webp_get_exif_data(const std::string webp_data) { WebPData input_data = {reinterpret_cast(webp_data.data()), @@ -15,33 +25,31 @@ std::optional webp_get_exif_data(const std::string webp_data) { return std::nullopt; } + std::optional output = std::nullopt; + uint32_t flags = WebPDemuxGetI(demux, WEBP_FF_FORMAT_FLAGS); - WebPChunkIterator chunk_iter; if (flags & EXIF_FLAG) { - WebPDemuxGetChunk(demux, "EXIF", 1, &chunk_iter); - auto *output = static_cast( - malloc(std::size(constants::ExifHeader) + chunk_iter.chunk.size)); - if (output == nullptr) { - WebPDemuxReleaseChunkIterator(&chunk_iter); - WebPDemuxDelete(demux); - return std::nullopt; + WebPChunkIterator chunk_iter; + WebPDemuxGetChunk(demux, "EXIF", /* chunk_number */ 1, &chunk_iter); + size_t exif_data_size = + std::size(constants::kExifHeader) + chunk_iter.chunk.size; + auto *exif_data = static_cast(std::malloc(exif_data_size)); + + if (exif_data != nullptr) { + std::memcpy(exif_data, constants::kExifHeader, + std::size(constants::kExifHeader)); + std::memcpy(exif_data + std::size(constants::kExifHeader), + chunk_iter.chunk.bytes, chunk_iter.chunk.size); + + output = Uint8Array(emscripten::val( + emscripten::typed_memory_view(exif_data_size, exif_data))); } - memcpy(output, constants::ExifHeader, std::size(constants::ExifHeader)); - memcpy(output + std::size(constants::ExifHeader), chunk_iter.chunk.bytes, - chunk_iter.chunk.size); - size_t output_size = - std::size(constants::ExifHeader) + chunk_iter.chunk.size; - WebPDemuxReleaseChunkIterator(&chunk_iter); - WebPDemuxDelete(demux); - - return std::optional{ - Uint8Array(val(typed_memory_view(output_size, output)))}; } WebPDemuxDelete(demux); - return std::nullopt; + return output; } Uint8Array webp_set_exif_data(const std::string webp_data, @@ -54,19 +62,20 @@ Uint8Array webp_set_exif_data(const std::string webp_data, "An error occurred while creating the WebP mux object"); } - bool has_exif_header = exif_data.size() >= std::size(constants::ExifHeader) && - memcmp(exif_data.data(), constants::ExifHeader, - std::size(constants::ExifHeader)) == 0; + bool has_exif_header = + exif_data.size() >= std::size(constants::kExifHeader) && + std::equal(std::begin(constants::kExifHeader), + std::end(constants::kExifHeader), exif_data.data()); - const char *exif_ptr = - has_exif_header ? exif_data.data() + std::size(constants::ExifHeader) + const char *webp_exif_data = + has_exif_header ? exif_data.data() + std::size(constants::kExifHeader) : exif_data.data(); - size_t exif_size = has_exif_header - ? exif_data.size() - std::size(constants::ExifHeader) - : exif_data.size(); + size_t webp_exif_size = + has_exif_header ? exif_data.size() - std::size(constants::kExifHeader) + : exif_data.size(); - WebPData exif_chunk = {reinterpret_cast(exif_ptr), - exif_size}; + WebPData exif_chunk = {reinterpret_cast(webp_exif_data), + webp_exif_size}; WebPMuxError set_err = WebPMuxSetChunk(mux, "EXIF", &exif_chunk, 1); if (set_err != WEBP_MUX_OK) { @@ -83,6 +92,6 @@ Uint8Array webp_set_exif_data(const std::string webp_data, "An error occurred while assembling the WebP data"); } - return Uint8Array( - val(typed_memory_view(output_data.size, output_data.bytes))); + return Uint8Array(emscripten::val( + emscripten::typed_memory_view(output_data.size, output_data.bytes))); } diff --git a/packages/image-utils/src/codecs/webp.h b/packages/image-utils/src/codecs/webp.h index f2317f38..f3b92a92 100644 --- a/packages/image-utils/src/codecs/webp.h +++ b/packages/image-utils/src/codecs/webp.h @@ -1,7 +1,9 @@ #pragma once +#include +#include + #include "../common.h" -#include std::optional webp_get_exif_data(const std::string webp_data); Uint8Array webp_set_exif_data(const std::string webp_data, diff --git a/packages/image-utils/src/constants.hpp b/packages/image-utils/src/constants.h similarity index 66% rename from packages/image-utils/src/constants.hpp rename to packages/image-utils/src/constants.h index 1af95969..cf6ac175 100644 --- a/packages/image-utils/src/constants.hpp +++ b/packages/image-utils/src/constants.h @@ -1,8 +1,11 @@ #pragma once +#include + namespace constants { // Equivalent to "Exif\0\0". Necessary for libexif to parse Exif data by itself // https://github.com/libexif/libexif/blob/aebe2a7b61a2fcd95f8d72e2d317027faf73fdc1/libexif/exif-data.c#L871-L881 -inline constexpr unsigned char ExifHeader[6] = {0x45, 0x78, 0x69, - 0x66, 0x00, 0x00}; +inline constexpr uint8_t kExifHeader[6] = { + 'E', 'x', 'i', 'f', '\0', '\0', +}; } // namespace constants diff --git a/packages/image-utils/src/main.cpp b/packages/image-utils/src/main.cpp index 597647b7..1e0ff3cf 100644 --- a/packages/image-utils/src/main.cpp +++ b/packages/image-utils/src/main.cpp @@ -6,11 +6,9 @@ #include "codecs/webp.h" #include "common.h" -using namespace emscripten; - EMSCRIPTEN_BINDINGS(image_utils) { - register_type("Uint8Array"); - register_optional(); + emscripten::register_type("Uint8Array"); + emscripten::register_optional(); function("jpeg_set_exif_data(jpeg_data, exif_data)", &jpeg_set_exif_data); From 2eefdf147007527588bcc970c64fb1b2862f0809 Mon Sep 17 00:00:00 2001 From: Jeremy Nguyen Date: Wed, 30 Sep 2026 16:21:21 -0700 Subject: [PATCH 2/4] feat(image-utils): rewrite heif_get_exif_data logic to read tiff offset --- packages/image-utils/src/codecs/heif.cpp | 77 ++++++++++++------------ 1 file changed, 38 insertions(+), 39 deletions(-) diff --git a/packages/image-utils/src/codecs/heif.cpp b/packages/image-utils/src/codecs/heif.cpp index 16ec27fd..7ad8679d 100644 --- a/packages/image-utils/src/codecs/heif.cpp +++ b/packages/image-utils/src/codecs/heif.cpp @@ -15,6 +15,13 @@ #include "../common.h" #include "../constants.h" +// Read the first four bytes as big-endian uint32_t +constexpr uint32_t read_be32(const uint8_t *data) noexcept { + return (static_cast(data[0]) << 24) | + (static_cast(data[1]) << 16) | + (static_cast(data[2]) << 8) | static_cast(data[3]); +} + std::optional heif_get_exif_data(const std::string heif_data) { struct heif_context *ctx = heif_context_alloc(); @@ -37,50 +44,42 @@ std::optional heif_get_exif_data(const std::string heif_data) { std::optional output = std::nullopt; if (n == 1) { - size_t exif_size = + size_t heif_exif_size = heif_image_handle_get_metadata_size(image_handle, exif_item_id); - uint8_t *exif_data = static_cast(std::malloc(exif_size)); - - if (exif_data != nullptr) { - struct heif_error metadata_err = - heif_image_handle_get_metadata(image_handle, exif_item_id, exif_data); - - if (metadata_err.code == heif_error_Ok && exif_size >= 4) { - // The first four bytes are the offset to the start of the TIFF header - // of the Exif data - exif_size -= 4; - std::memmove(exif_data, exif_data + 4, exif_size); - - const bool has_exif_header = - exif_size >= std::size(constants::kExifHeader) && - std::equal(std::begin(constants::kExifHeader), - std::end(constants::kExifHeader), exif_data); - - // From the very small sample size I've seen, it seems that HEIC files - // begin with the Exif header and AVIF files do not - if (has_exif_header) { - output = Uint8Array(emscripten::val( - emscripten::typed_memory_view(exif_size, exif_data))); - } else { - auto *exif_data_with_header = static_cast( - std::malloc(std::size(constants::kExifHeader) + exif_size)); - - if (exif_data_with_header != nullptr) { - std::memcpy(exif_data_with_header, constants::kExifHeader, + uint8_t *heif_exif_data = + static_cast(std::malloc(heif_exif_size)); + + if (heif_exif_data != nullptr) { + struct heif_error metadata_err = heif_image_handle_get_metadata( + image_handle, exif_item_id, heif_exif_data); + + if (metadata_err.code == heif_error_Ok && heif_exif_size >= 4) { + // If tiff_offset is 10, then there is an Exif header (Exif\0\0). If + // tiff_offset is 4, then it is followed directly by the TIFF header + // (MM/II). It seems that based on my experiences, HEIC will have the + // header while AVIF will not. Since we always want the Exif header, use + // this offset to normalize the output + // https://github.com/Exiv2/exiv2/issues/2162#issuecomment-1079000778 + // https://github.com/strukturag/libheif/blob/eda8f2dc3670d7c07cee3769b247476f86229c24/libheif/api/libheif/heif_metadata.h#L80-L81 + const uint64_t tiff_offset = read_be32(heif_exif_data) + 4ULL; + + if (tiff_offset < heif_exif_size) { + const size_t exif_size = std::size(constants::kExifHeader) + + (heif_exif_size - tiff_offset); + auto *exif_data = static_cast(std::malloc(exif_size)); + + if (exif_data != nullptr) { + std::memcpy(exif_data, constants::kExifHeader, std::size(constants::kExifHeader)); - std::memcpy(exif_data_with_header + - std::size(constants::kExifHeader), - exif_data, exif_size); - - output = Uint8Array(emscripten::val(emscripten::typed_memory_view( - std::size(constants::kExifHeader) + exif_size, - exif_data_with_header))); + std::memcpy(exif_data + std::size(constants::kExifHeader), + heif_exif_data + tiff_offset, + heif_exif_size - tiff_offset); + output = Uint8Array(emscripten::val( + emscripten::typed_memory_view(exif_size, exif_data))); } - std::free(exif_data); } - } else { - std::free(exif_data); } + std::free(heif_exif_data); } } From 5817f36df95165ce2dd5674c08476ffaf06ab611 Mon Sep 17 00:00:00 2001 From: Jeremy Nguyen Date: Wed, 30 Sep 2026 16:39:57 -0700 Subject: [PATCH 3/4] refactor(image-utils): consistent variable names across codecs - make variables in codecs more consistent - make kJfifHeader and kAdobeHeader use the ASCII form - Make all codec getters noexcept --- packages/image-utils/src/codecs/heif.cpp | 3 ++- packages/image-utils/src/codecs/heif.h | 3 ++- packages/image-utils/src/codecs/jpeg.cpp | 12 +++++------ packages/image-utils/src/codecs/png.cpp | 27 +++++++++++++----------- packages/image-utils/src/codecs/png.h | 3 ++- packages/image-utils/src/codecs/webp.cpp | 22 ++++++++++--------- packages/image-utils/src/codecs/webp.h | 3 ++- 7 files changed, 40 insertions(+), 33 deletions(-) diff --git a/packages/image-utils/src/codecs/heif.cpp b/packages/image-utils/src/codecs/heif.cpp index 7ad8679d..2761469a 100644 --- a/packages/image-utils/src/codecs/heif.cpp +++ b/packages/image-utils/src/codecs/heif.cpp @@ -22,7 +22,8 @@ constexpr uint32_t read_be32(const uint8_t *data) noexcept { (static_cast(data[2]) << 8) | static_cast(data[3]); } -std::optional heif_get_exif_data(const std::string heif_data) { +std::optional +heif_get_exif_data(const std::string heif_data) noexcept { struct heif_context *ctx = heif_context_alloc(); struct heif_error read_err = heif_context_read_from_memory_without_copy( diff --git a/packages/image-utils/src/codecs/heif.h b/packages/image-utils/src/codecs/heif.h index e27f12a7..d45cc5f6 100644 --- a/packages/image-utils/src/codecs/heif.h +++ b/packages/image-utils/src/codecs/heif.h @@ -5,4 +5,5 @@ #include "../common.h" -std::optional heif_get_exif_data(const std::string heif_data); +std::optional +heif_get_exif_data(const std::string heif_data) noexcept; diff --git a/packages/image-utils/src/codecs/jpeg.cpp b/packages/image-utils/src/codecs/jpeg.cpp index 5bb79c7b..b1e649cd 100644 --- a/packages/image-utils/src/codecs/jpeg.cpp +++ b/packages/image-utils/src/codecs/jpeg.cpp @@ -12,10 +12,8 @@ #include "../common.h" #include "../constants.h" -// "JFIF\0" -constexpr uint8_t kJfifHeader[5] = {0x4A, 0x46, 0x49, 0x46, 0x00}; -// "Adobe" -constexpr uint8_t kAdobeHeader[5] = {0x41, 0x64, 0x6F, 0x62, 0x65}; +constexpr uint8_t kJfifHeader[5] = {'J', 'F', 'I', 'F', '\0'}; +constexpr uint8_t kAdobeHeader[5] = {'A', 'd', 'o', 'b', 'e'}; constexpr int kApp1Marker = JPEG_APP0 + 1; constexpr int kApp14Marker = JPEG_APP0 + 14; @@ -43,11 +41,11 @@ Uint8Array jpeg_set_exif_data(const std::string jpeg_data, jpeg_create_decompress(&srcinfo); jpeg_create_compress(&dstinfo); - unsigned char *output_data; + unsigned char *output; size_t output_size; jpeg_mem_src(&srcinfo, reinterpret_cast(jpeg_data.data()), jpeg_data.size()); - jpeg_mem_dest(&dstinfo, &output_data, &output_size); + jpeg_mem_dest(&dstinfo, &output, &output_size); // Save all APPn markers for (int index = 0; index < 16; index++) { @@ -129,5 +127,5 @@ Uint8Array jpeg_set_exif_data(const std::string jpeg_data, jpeg_destroy_decompress(&srcinfo); return Uint8Array( - emscripten::val(emscripten::typed_memory_view(output_size, output_data))); + emscripten::val(emscripten::typed_memory_view(output_size, output))); } diff --git a/packages/image-utils/src/codecs/png.cpp b/packages/image-utils/src/codecs/png.cpp index 106a04cb..aa92399f 100644 --- a/packages/image-utils/src/codecs/png.cpp +++ b/packages/image-utils/src/codecs/png.cpp @@ -65,7 +65,8 @@ static void png_write_to_memory(png_structp png_ptr, png_bytep data, static void png_flush_memory(png_structp png_ptr) { (void)png_ptr; } -std::optional png_get_exif_data(const std::string png_data) { +std::optional +png_get_exif_data(const std::string png_data) noexcept { png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr); if (png_ptr == nullptr) { @@ -93,20 +94,21 @@ std::optional png_get_exif_data(const std::string png_data) { std::optional output = std::nullopt; #ifdef PNG_eXIf_SUPPORTED - png_uint_32 exif_data_len = 0; - png_bytep exif_data_ptr = nullptr; + png_uint_32 png_exif_size = 0; + png_bytep png_exif_data = nullptr; + + if (png_get_eXIf_1(png_ptr, info_ptr, &png_exif_size, &png_exif_data) != 0 && + png_exif_data != nullptr && png_exif_size > 0) { + size_t exif_size = (std::size(constants::kExifHeader) + png_exif_size); + auto *exif_data = static_cast(std::malloc(exif_size)); - if (png_get_eXIf_1(png_ptr, info_ptr, &exif_data_len, &exif_data_ptr) != 0 && - exif_data_ptr != nullptr && exif_data_len > 0) { - auto *exif_data = static_cast( - std::malloc(std::size(constants::kExifHeader) + exif_data_len)); if (exif_data != nullptr) { std::memcpy(exif_data, constants::kExifHeader, std::size(constants::kExifHeader)); - std::memcpy(exif_data + std::size(constants::kExifHeader), exif_data_ptr, - exif_data_len); - output = Uint8Array(emscripten::val(emscripten::typed_memory_view( - std::size(constants::kExifHeader) + exif_data_len, exif_data))); + std::memcpy(exif_data + std::size(constants::kExifHeader), png_exif_data, + png_exif_size); + output = Uint8Array( + emscripten::val(emscripten::typed_memory_view(exif_size, exif_data))); } } #endif @@ -181,7 +183,8 @@ Uint8Array png_set_exif_data(const std::string png_data, throw std::runtime_error("An error occurred while writing the PNG"); } - png_write_png(write_png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, nullptr); + png_write_png(write_png_ptr, info_ptr, + /* transforms */ PNG_TRANSFORM_IDENTITY, /* params */ nullptr); png_destroy_read_struct(&read_png_ptr, &info_ptr, nullptr); png_destroy_write_struct(&write_png_ptr, nullptr); diff --git a/packages/image-utils/src/codecs/png.h b/packages/image-utils/src/codecs/png.h index 80ca11b0..0861f945 100644 --- a/packages/image-utils/src/codecs/png.h +++ b/packages/image-utils/src/codecs/png.h @@ -5,6 +5,7 @@ #include "../common.h" -std::optional png_get_exif_data(const std::string png_data); +std::optional +png_get_exif_data(const std::string png_data) noexcept; Uint8Array png_set_exif_data(const std::string png_data, const std::string exif_data); diff --git a/packages/image-utils/src/codecs/webp.cpp b/packages/image-utils/src/codecs/webp.cpp index f3304d93..3c9d18e2 100644 --- a/packages/image-utils/src/codecs/webp.cpp +++ b/packages/image-utils/src/codecs/webp.cpp @@ -16,7 +16,8 @@ #include "../common.h" #include "../constants.h" -std::optional webp_get_exif_data(const std::string webp_data) { +std::optional +webp_get_exif_data(const std::string webp_data) noexcept { WebPData input_data = {reinterpret_cast(webp_data.data()), webp_data.size()}; @@ -31,9 +32,9 @@ std::optional webp_get_exif_data(const std::string webp_data) { if (flags & EXIF_FLAG) { WebPChunkIterator chunk_iter; WebPDemuxGetChunk(demux, "EXIF", /* chunk_number */ 1, &chunk_iter); - size_t exif_data_size = + size_t exif_size = std::size(constants::kExifHeader) + chunk_iter.chunk.size; - auto *exif_data = static_cast(std::malloc(exif_data_size)); + auto *exif_data = static_cast(std::malloc(exif_size)); if (exif_data != nullptr) { std::memcpy(exif_data, constants::kExifHeader, @@ -41,8 +42,8 @@ std::optional webp_get_exif_data(const std::string webp_data) { std::memcpy(exif_data + std::size(constants::kExifHeader), chunk_iter.chunk.bytes, chunk_iter.chunk.size); - output = Uint8Array(emscripten::val( - emscripten::typed_memory_view(exif_data_size, exif_data))); + output = Uint8Array( + emscripten::val(emscripten::typed_memory_view(exif_size, exif_data))); } WebPDemuxReleaseChunkIterator(&chunk_iter); @@ -77,14 +78,15 @@ Uint8Array webp_set_exif_data(const std::string webp_data, WebPData exif_chunk = {reinterpret_cast(webp_exif_data), webp_exif_size}; - WebPMuxError set_err = WebPMuxSetChunk(mux, "EXIF", &exif_chunk, 1); + WebPMuxError set_err = + WebPMuxSetChunk(mux, "EXIF", &exif_chunk, /* copy_data */ 1); if (set_err != WEBP_MUX_OK) { WebPMuxDelete(mux); - throw std::runtime_error("An error occurred while setting the EXIF chunk"); + throw std::runtime_error("An error occurred while setting the Exif chunk"); } - WebPData output_data; - WebPMuxError assemble_err = WebPMuxAssemble(mux, &output_data); + WebPData output; + WebPMuxError assemble_err = WebPMuxAssemble(mux, &output); WebPMuxDelete(mux); if (assemble_err != WEBP_MUX_OK) { @@ -93,5 +95,5 @@ Uint8Array webp_set_exif_data(const std::string webp_data, } return Uint8Array(emscripten::val( - emscripten::typed_memory_view(output_data.size, output_data.bytes))); + emscripten::typed_memory_view(output.size, output.bytes))); } diff --git a/packages/image-utils/src/codecs/webp.h b/packages/image-utils/src/codecs/webp.h index f3b92a92..84958199 100644 --- a/packages/image-utils/src/codecs/webp.h +++ b/packages/image-utils/src/codecs/webp.h @@ -5,6 +5,7 @@ #include "../common.h" -std::optional webp_get_exif_data(const std::string webp_data); +std::optional +webp_get_exif_data(const std::string webp_data) noexcept; Uint8Array webp_set_exif_data(const std::string webp_data, const std::string exif_data); From 281edc9ad6b271901a1e571f02048b23c38bae9f Mon Sep 17 00:00:00 2001 From: Jeremy Nguyen Date: Wed, 30 Sep 2026 17:04:16 -0700 Subject: [PATCH 4/4] chore(image-utils): add error code in WebP codec --- packages/image-utils/src/codecs/webp.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/packages/image-utils/src/codecs/webp.cpp b/packages/image-utils/src/codecs/webp.cpp index 3c9d18e2..d5cd6718 100644 --- a/packages/image-utils/src/codecs/webp.cpp +++ b/packages/image-utils/src/codecs/webp.cpp @@ -82,7 +82,8 @@ Uint8Array webp_set_exif_data(const std::string webp_data, WebPMuxSetChunk(mux, "EXIF", &exif_chunk, /* copy_data */ 1); if (set_err != WEBP_MUX_OK) { WebPMuxDelete(mux); - throw std::runtime_error("An error occurred while setting the Exif chunk"); + throw std::runtime_error("An error (" + std::to_string(set_err) + + ") occurred while setting the Exif chunk"); } WebPData output; @@ -90,8 +91,8 @@ Uint8Array webp_set_exif_data(const std::string webp_data, WebPMuxDelete(mux); if (assemble_err != WEBP_MUX_OK) { - throw std::runtime_error( - "An error occurred while assembling the WebP data"); + throw std::runtime_error("An error (" + std::to_string(assemble_err) + + ") occurred while assembling the WebP data"); } return Uint8Array(emscripten::val(