@img/sharp-libvips-dev-wasm32 1.3.0-rc.1 → 1.3.0-rc.10

package/include/libheif/heif_components.h

@@ -0,0 +1,264 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2026 Dirk Farin <dirk.farin@gmail.com>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBHEIF_HEIF_COMPONENTS_H
+#define LIBHEIF_HEIF_COMPONENTS_H
+
+#include "libheif/heif_library.h"
+#include "libheif/heif_image.h"
+#include "libheif/heif_image_handle.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* @file heif_components.h
+ * @brief Multi-component image API.
+ *
+ * The component model (id-addressed pixel planes with per-component type,
+ * datatype and bit-depth) is codec-agnostic. It was introduced for ISO 23001-17
+ * (uncompressed) images but is also expected to be reused by other codecs that
+ * carry multiple typed components (e.g. JPEG-2000).
+ */
+
+
+// --- pixel datatype support
+//
+// The numeric values are aligned with the ISO/IEC 23001-17 Table 2
+// component_format byte (used by the uncC box of the uncompressed codec).
+// This is an internal convenience and should not be relied upon.
+
+typedef enum heif_component_datatype
+{
+  heif_component_datatype_unsigned_integer = 0,
+  heif_component_datatype_floating_point   = 1,
+  heif_component_datatype_complex_number   = 2,
+  heif_component_datatype_signed_integer   = 3,
+  heif_component_datatype_undefined        = 0xFF
+} heif_component_datatype;
+
+typedef struct heif_complex32
+{
+  float real, imaginary;
+} heif_complex32;
+
+typedef struct heif_complex64
+{
+  double real, imaginary;
+} heif_complex64;
+
+
+// --- component types (ISO/IEC 23001-17 Table 1, used in the cmpd box)
+
+typedef enum heif_cmpd_component_type
+{
+  heif_cmpd_component_type_monochrome = 0,
+  heif_cmpd_component_type_Y = 1,
+  heif_cmpd_component_type_Cb = 2,
+  heif_cmpd_component_type_Cr = 3,
+  heif_cmpd_component_type_red = 4,
+  heif_cmpd_component_type_green = 5,
+  heif_cmpd_component_type_blue = 6,
+  heif_cmpd_component_type_alpha = 7,
+  heif_cmpd_component_type_depth = 8,
+  heif_cmpd_component_type_disparity = 9,
+  heif_cmpd_component_type_palette = 10,
+  heif_cmpd_component_type_filter_array = 11,
+  heif_cmpd_component_type_padded = 12,
+  heif_cmpd_component_type_cyan = 13,
+  heif_cmpd_component_type_magenta = 14,
+  heif_cmpd_component_type_yellow = 15,
+  heif_cmpd_component_type_key_black = 16
+} heif_cmpd_component_type;
+
+
+// --- ID-based component access (operates on a decoded heif_image)
+
+// Returns the number of components that have pixel data (planes) in this image.
+LIBHEIF_API
+uint32_t heif_image_get_number_of_used_components(const heif_image*);
+
+// Fills `out_component_ids` with the valid component IDs.
+// The caller must allocate an array of at least heif_image_get_number_of_used_components() elements.
+LIBHEIF_API
+void heif_image_get_used_component_ids(const heif_image*, uint32_t* out_component_ids);
+
+LIBHEIF_API
+heif_channel heif_image_get_component_channel(const heif_image*, uint32_t component_id);
+
+LIBHEIF_API
+uint32_t heif_image_get_component_width(const heif_image*, uint32_t component_id);
+
+LIBHEIF_API
+uint32_t heif_image_get_component_height(const heif_image*, uint32_t component_id);
+
+LIBHEIF_API
+int heif_image_get_component_bits_per_pixel(const heif_image*, uint32_t component_id);
+
+LIBHEIF_API
+uint16_t heif_image_get_component_type(const heif_image*, uint32_t component_id);
+
+// Returns the datatype (unsigned/signed integer, floating point, or complex
+// number) of the given component.
+LIBHEIF_API
+heif_component_datatype heif_image_get_component_datatype(const heif_image*, uint32_t component_id);
+
+
+// --- ID-based component access via heif_image_handle (before decoding)
+//
+// These let the caller introspect a multi-component image's components without
+// decoding any tile. They return 0 / -1 / heif_component_datatype_undefined for
+// images that do not expose a component model or for unknown component IDs.
+//
+// The component IDs returned here match the IDs that
+// heif_image_get_used_component_ids() will report after the same image is
+// decoded, so the same numerical id can be used to address a component on
+// either side of the API.
+
+LIBHEIF_API
+uint32_t heif_image_handle_get_number_of_components(const heif_image_handle*);
+
+// Fills `out_component_ids` with the valid component IDs.
+// The caller must allocate an array of at least
+// heif_image_handle_get_number_of_components() elements.
+LIBHEIF_API
+void heif_image_handle_get_used_component_ids(const heif_image_handle*, uint32_t* out_component_ids);
+
+LIBHEIF_API
+uint16_t heif_image_handle_get_component_type(const heif_image_handle*, uint32_t component_id);
+
+LIBHEIF_API
+int heif_image_handle_get_component_bits_per_pixel(const heif_image_handle*, uint32_t component_id);
+
+LIBHEIF_API
+heif_component_datatype heif_image_handle_get_component_datatype(const heif_image_handle*, uint32_t component_id);
+
+
+// --- adding components to a heif_image (encoder path)
+
+LIBHEIF_API
+heif_error heif_image_add_component(heif_image* image,
+                                    int width, int height,
+                                    uint16_t component_type,
+                                    heif_component_datatype datatype,
+                                    int bit_depth,
+                                    uint32_t* out_component_id);
+
+
+// --- untyped uint8 component data getters: stride is in BYTES per row.
+
+LIBHEIF_API
+const uint8_t* heif_image_get_component_readonly(const heif_image*, uint32_t component_id, size_t* out_stride);
+
+LIBHEIF_API
+uint8_t* heif_image_get_component(heif_image*, uint32_t component_id, size_t* out_stride);
+
+
+// --- typed component data getters: `out_row_elements` is the number of T
+// elements per row, not bytes. Index with `data[y * row_elements + x]` (no
+// casts, no sizeof). libheif allocates rows with element-aligned padding, so
+// this count is always exact for the named type T.
+
+LIBHEIF_API
+const uint16_t* heif_image_get_component_uint16_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+uint16_t* heif_image_get_component_uint16(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const uint32_t* heif_image_get_component_uint32_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+uint32_t* heif_image_get_component_uint32(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const uint64_t* heif_image_get_component_uint64_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+uint64_t* heif_image_get_component_uint64(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const int8_t* heif_image_get_component_int8_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+int8_t* heif_image_get_component_int8(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const int16_t* heif_image_get_component_int16_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+int16_t* heif_image_get_component_int16(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const int32_t* heif_image_get_component_int32_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+int32_t* heif_image_get_component_int32(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const int64_t* heif_image_get_component_int64_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+int64_t* heif_image_get_component_int64(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const float* heif_image_get_component_float32_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+float* heif_image_get_component_float32(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const double* heif_image_get_component_float64_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+double* heif_image_get_component_float64(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const heif_complex32* heif_image_get_component_complex32_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+heif_complex32* heif_image_get_component_complex32(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+const heif_complex64* heif_image_get_component_complex64_readonly(const heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+LIBHEIF_API
+heif_complex64* heif_image_get_component_complex64(heif_image*, uint32_t component_id, size_t* out_row_elements);
+
+
+// --- GIMI component content IDs (set before encoding)
+
+// Set a GIMI component content ID for the component with the given
+// component_id (as minted by heif_image_add_component / returned via the
+// component access API). Pass an empty string to clear a previously set id.
+// Returns an error if no component with this id exists on the image.
+// The collected ids are written into an ItemComponentContentIDProperty box
+// during encoding.
+LIBHEIF_API
+heif_error heif_image_set_gimi_component_content_id(heif_image*,
+                                                    uint32_t component_id,
+                                                    const char* content_id);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/include/libheif/heif_context.h

@@ -35,7 +35,7 @@ extern "C" {
 /**
  * libheif known compression formats.
  */
-enum heif_compression_format
+typedef enum heif_compression_format
 {
   /**
    * Unspecified / undefined compression format.
@@ -115,7 +115,7 @@ enum heif_compression_format
    * The core encoding is defined in ISO/IEC 15444-15, or ITU-T T.814.
   */
   heif_compression_HTJ2K = 10
-};
+} heif_compression_format;
 
 
 // ========================= heif_context =========================
@@ -136,13 +136,13 @@ void heif_context_free(heif_context*);
 
 typedef struct heif_reading_options heif_reading_options;
 
-enum heif_reader_grow_status
+typedef enum heif_reader_grow_status
 {
   heif_reader_grow_status_size_reached,    // requested size has been reached, we can read until this point
   heif_reader_grow_status_timeout,         // size has not been reached yet, but it may still grow further (deprecated)
   heif_reader_grow_status_size_beyond_eof, // size has not been reached and never will. The file has grown to its full size
   heif_reader_grow_status_error            // an error has occurred
-};
+} heif_reader_grow_status;
 
 
 typedef struct heif_reader_range_request_result
@@ -295,6 +295,20 @@ heif_error heif_context_get_image_handle(heif_context* ctx,
 LIBHEIF_API
 void heif_context_debug_dump_boxes_to_file(heif_context* ctx, int fd);
 
+// ====================================================================================================
+//   Mini format (experimental)
+
+// Enable writing in the compact 'mini' box format (ISO/IEC 23008-12 DAmd2).
+// When enabled, the output file will use a single 'mini' box instead of the standard
+// meta+mdat box structure, if the file content is compatible with the mini format.
+// If the content cannot be represented as a mini box, the standard format is used as fallback.
+// Note: the mini box format is defined by a draft amendment to ISO/IEC 23008-12
+// and may have reduced interoperability with other readers.
+// Default: disabled.
+LIBHEIF_API
+void heif_context_set_write_mini_format(heif_context*, int enable);
+
+
 // ====================================================================================================
 //   Write the heif_context to a HEIF file
 

package/include/libheif/heif_cxx.h

@@ -283,7 +283,7 @@ namespace heif {
   public:
     ColorProfile_nclx();
 
-    ~ColorProfile_nclx();
+    ~ColorProfile_nclx() = default;
 
     heif_color_primaries get_color_primaries() const;
 
@@ -305,10 +305,9 @@ namespace heif {
     void set_full_range_flag(bool is_full_range);
 
   private:
-    ColorProfile_nclx(heif_color_profile_nclx* nclx)
-    { mProfile = nclx; }
+    ColorProfile_nclx(heif_color_profile_nclx* nclx);
 
-    heif_color_profile_nclx* mProfile;
+    std::shared_ptr<heif_color_profile_nclx> mProfile;
 
     friend class Image;
   };
@@ -324,8 +323,8 @@ namespace heif {
 
     // throws Error
     void create(int width, int height,
-                enum heif_colorspace colorspace,
-                enum heif_chroma chroma);
+                heif_colorspace colorspace,
+                heif_chroma chroma);
 
     // throws Error
     void add_plane(enum heif_channel channel,
@@ -392,14 +391,14 @@ namespace heif {
   {
   public:
     static std::vector<EncoderDescriptor>
-    get_encoder_descriptors(enum heif_compression_format format_filter,
+    get_encoder_descriptors(heif_compression_format format_filter,
                             const char* name_filter) noexcept;
 
     std::string get_name() const noexcept;
 
     std::string get_id_name() const noexcept;
 
-    enum heif_compression_format get_compression_format() const noexcept;
+    heif_compression_format get_compression_format() const noexcept;
 
     // DEPRECATED: typo in function name
     bool supportes_lossy_compression() const noexcept;
@@ -454,7 +453,7 @@ namespace heif {
   {
   public:
     // throws Error
-    Encoder(enum heif_compression_format format);
+    Encoder(heif_compression_format format);
 
     // throws Error
     void set_lossy_quality(int quality);
@@ -813,12 +812,15 @@ namespace heif {
 
   inline ColorProfile_nclx::ColorProfile_nclx()
   {
-    mProfile = heif_nclx_color_profile_alloc();
+    auto profile = heif_nclx_color_profile_alloc();
+    mProfile = std::shared_ptr<heif_color_profile_nclx>(profile,
+                                                        [](heif_color_profile_nclx* p) { heif_nclx_color_profile_free(p); });
   }
 
-  inline ColorProfile_nclx::~ColorProfile_nclx()
+  inline ColorProfile_nclx::ColorProfile_nclx(heif_color_profile_nclx* nclx)
   {
-    heif_nclx_color_profile_free(mProfile);
+    mProfile = std::shared_ptr<heif_color_profile_nclx>(nclx,
+                                                        [](heif_color_profile_nclx* p) { heif_nclx_color_profile_free(p); });
   }
 
   inline heif_color_primaries ColorProfile_nclx::get_color_primaries() const
@@ -857,8 +859,8 @@ namespace heif {
 
 
   inline void Image::create(int width, int height,
-                            enum heif_colorspace colorspace,
-                            enum heif_chroma chroma)
+                            heif_colorspace colorspace,
+                            heif_chroma chroma)
   {
     heif_image* image;
     Error err = Error(heif_image_create(width, height, colorspace, chroma, &image));
@@ -938,7 +940,7 @@ namespace heif {
 
   inline void Image::set_nclx_color_profile(const ColorProfile_nclx& nclx)
   {
-    Error err = Error(heif_image_set_nclx_color_profile(m_image.get(), nclx.mProfile));
+    Error err = Error(heif_image_set_nclx_color_profile(m_image.get(), nclx.mProfile.get()));
     if (err) {
       throw err;
     }
@@ -1021,7 +1023,7 @@ namespace heif {
 
 
   inline std::vector<EncoderDescriptor>
-  EncoderDescriptor::get_encoder_descriptors(enum heif_compression_format format_filter,
+  EncoderDescriptor::get_encoder_descriptors(heif_compression_format format_filter,
                                              const char* name_filter) noexcept
   {
     int maxDescriptors = 10;
@@ -1064,7 +1066,7 @@ namespace heif {
     return heif_encoder_descriptor_get_id_name(m_descriptor);
   }
 
-  inline enum heif_compression_format EncoderDescriptor::get_compression_format() const noexcept
+  inline heif_compression_format EncoderDescriptor::get_compression_format() const noexcept
   {
     return heif_encoder_descriptor_get_compression_format(m_descriptor);
   }
@@ -1101,7 +1103,7 @@ namespace heif {
   }
 
 
-  inline Encoder::Encoder(enum heif_compression_format format)
+  inline Encoder::Encoder(heif_compression_format format)
   {
     heif_encoder* encoder;
     Error err = Error(heif_context_get_encoder_for_format(nullptr, format, &encoder));

package/include/libheif/heif_decoding.h

@@ -39,18 +39,25 @@ extern "C" {
 LIBHEIF_API
 void heif_context_set_max_decoding_threads(heif_context* ctx, int max_threads);
 
+// Returns the current maximum number of background threads used for parallel tile decoding.
+// This reflects either the library default or the value last passed to
+// heif_context_set_max_decoding_threads().
+// If 'ctx' is NULL, the library default is returned.
+LIBHEIF_API
+int heif_context_get_max_decoding_threads(const heif_context* ctx);
+
 // Quick check whether there is a decoder available for the given format.
 // Note that the decoder still may not be able to decode all variants of that format.
 // You will have to query that further (todo) or just try to decode and check the returned error.
 LIBHEIF_API
-int heif_have_decoder_for_format(enum heif_compression_format format);
+int heif_have_decoder_for_format(heif_compression_format format);
 
 
-enum heif_progress_step
+typedef enum heif_progress_step
 {
   heif_progress_step_total = 0,
   heif_progress_step_load_tile = 1
-};
+} heif_progress_step;
 
 
 typedef struct heif_decoding_options
@@ -64,11 +71,11 @@ typedef struct heif_decoding_options
   uint8_t ignore_transformations;
 
   // Any of the progress functions may be called from background threads.
-  void (* start_progress)(enum heif_progress_step step, int max_progress, void* progress_user_data);
+  void (* start_progress)(heif_progress_step step, int max_progress, void* progress_user_data);
 
-  void (* on_progress)(enum heif_progress_step step, int progress, void* progress_user_data);
+  void (* on_progress)(heif_progress_step step, int progress, void* progress_user_data);
 
-  void (* end_progress)(enum heif_progress_step step, void* progress_user_data);
+  void (* end_progress)(heif_progress_step step, void* progress_user_data);
 
   void* progress_user_data;
 
@@ -101,6 +108,53 @@ typedef struct heif_decoding_options
 
   // When set to NULL, default options will be used
   heif_color_conversion_options_ext* color_conversion_options_ext;
+
+  // version 8 options (v1.21.0)
+
+  // If enabled, it will decode the media timeline, ignoring the sequence tracks edit-list.
+  int ignore_sequence_editlist; // bool
+
+  // Requested NCLX color profile of the decoded output image. If the input
+  // image's NCLX differs, libheif will color-convert the pixels accordingly
+  // (e.g. YCbCr matrix, primaries, range) so the result matches what is
+  // requested here.
+  //
+  // When set to NULL, the behavior depends on the flag
+  // output_image_nclx_profile_passthrough below: by default NULL means
+  // "convert to sRGB"; with the passthrough flag enabled, NULL means
+  // "keep the input image's NCLX".
+  heif_color_profile_nclx* output_image_nclx_profile;
+
+  int num_library_threads; // 0 = let libheif decide (TODO, currently ignored)
+  int num_codec_threads; // 0 = use decoder default
+
+  // version 9 options
+
+  // If enabled, libheif will attempt to work around known broken-input quirks
+  // (e.g. Sony HIF files where the NCLX `colr` box disagrees with the HEVC VUI
+  // on the YCbCr range flag). Default: false (strict spec-conformant behavior).
+  uint8_t autocorrect_broken_input;
+
+  // version 10 options
+
+  // Controls the meaning of output_image_nclx_profile == NULL.
+  //
+  // When false (default), a NULL output_image_nclx_profile means "convert the
+  // decoded image to sRGB" (BT.709 primaries, sRGB transfer, BT.601 matrix,
+  // full-range). For HDR inputs (e.g. BT.2100 PQ) this silently discards the
+  // original color volume.
+  //
+  // When true, a NULL output_image_nclx_profile means "keep the input image's
+  // NCLX". The decoded image carries the input file's primaries / transfer /
+  // matrix / range, and no extra color-space conversion is performed solely
+  // because the output NCLX was unspecified. If a YCbCr<->RGB colorspace
+  // conversion fires for another reason, the input NCLX is used to drive that
+  // conversion (so the result is tagged consistently with the source).
+  //
+  // Although this flag is off by default to preserve historical behavior, new
+  // code that wants to preserve HDR through decode should generally enable it.
+  // Setting output_image_nclx_profile to a non-NULL value overrides this flag.
+  uint8_t output_image_nclx_profile_passthrough;
 } heif_decoding_options;
 
 
@@ -126,7 +180,7 @@ typedef struct heif_decoder_descriptor heif_decoder_descriptor;
 // The number of decoders is returned, which are not more than 'count' if (out_decoders != nullptr).
 // By setting out_decoders==nullptr, you can query the number of decoders, 'count' is ignored.
 LIBHEIF_API
-int heif_get_decoder_descriptors(enum heif_compression_format format_filter,
+int heif_get_decoder_descriptors(heif_compression_format format_filter,
                                  const heif_decoder_descriptor** out_decoders,
                                  int count);
 
@@ -151,8 +205,8 @@ const char* heif_decoder_descriptor_get_id_name(const heif_decoder_descriptor*);
 LIBHEIF_API
 heif_error heif_decode_image(const heif_image_handle* in_handle,
                              heif_image** out_img,
-                             enum heif_colorspace colorspace,
-                             enum heif_chroma chroma,
+                             heif_colorspace colorspace,
+                             heif_chroma chroma,
                              const heif_decoding_options* options);
 
 #ifdef __cplusplus