@img/sharp-libvips-dev-wasm32 1.3.0-rc.6 → 1.3.0-rc.8

package/include/hwy/robust_statistics.h

@@ -123,8 +123,10 @@ T Median(T* values, const size_t num_values) {
   if (num_values % 2) {
     return values[half];
   }
+  // For integers, round rather than truncate.
+  const T bias = hwy::IsInteger<T>() ? T{1} : T{0};
   // Even count: return average of middle two.
-  return (values[half] + values[half - 1] + 1) / 2;
+  return (values[half] + values[half - 1] + bias) / 2;
 }
 
 // Returns a robust measure of variability.

package/include/hwy/timer.h

@@ -232,6 +232,50 @@ static HWY_INLINE Ticks Stop() {
 
 }  // namespace timer
 
+// Wrapper around Start/Stop that checks whether the CPU supports Stop.
+class Timer {
+ public:
+  Timer() {
+    char cpu100[100];
+    have_timer_stop_ = platform::HaveTimerStop(cpu100);
+  }
+
+  // Before/After have fences to prevent the measured code 'leaking out'.
+  timer::Ticks Before() const { return timer::Start(); }
+  timer::Ticks After() const {
+    return have_timer_stop_ ? timer::Stop() : timer::Start();
+  }
+
+ private:
+  bool have_timer_stop_;
+};
+
+static inline double Seconds(timer::Ticks ticks) {
+  return static_cast<double>(ticks) / platform::InvariantTicksPerSecond();
+}
+
+// Measures elapsed time since construction, with automatic reset.
+class Stopwatch {
+ public:
+  explicit Stopwatch(const Timer& timestamps) : timer_(timestamps) { Reset(); }
+
+  timer::Ticks Origin() const { return t0_; }
+  void Reset() { t0_ = timer_.Before(); }
+
+  // Also resets the start time to the current time to enable reuse without a
+  // second call to the timer.
+  timer::Ticks Elapsed() {
+    const timer::Ticks t1 = timer_.After();
+    const timer::Ticks elapsed = t1 - t0_;
+    t0_ = t1;
+    return elapsed;
+  }
+
+ private:
+  const Timer& timer_;
+  timer::Ticks t0_;
+};
+
 }  // namespace hwy
 
 #endif  // HIGHWAY_HWY_TIMER_H_

package/include/lcms2.h

@@ -23,7 +23,7 @@
 //
 //---------------------------------------------------------------------------------
 //
-// Version 2.18
+// Version 2.19
 //
 
 #ifndef _lcms2_H
@@ -37,6 +37,13 @@
 // "long long" type.
 // #define CMS_DONT_USE_INT64        1
 
+// Uncomment this one to enable large file support on file/stream I/O.
+// LittleCMS is still limited by ICC 32-bit offsets and sizes, so the
+// practical maximum remains 4 GiB minus profile overhead. Be careful 
+// because such huge profiles have to be loaded into memory and that's
+// usually a very bad idea.
+// #define CMS_LARGE_FILE_SUPPORT    1
+
 // Uncomment this if your compiler doesn't work with fast floor function
 // #define CMS_DONT_USE_FAST_FLOOR 1
 
@@ -87,7 +94,7 @@ extern "C" {
 #endif
 
 // Version/release
-#define LCMS_VERSION        2180
+#define LCMS_VERSION        2190
 
 // I will give the chance of redefining basic types for compilers that are not fully C99 compliant
 #ifndef CMS_BASIC_TYPES_ALREADY_DEFINED
@@ -168,6 +175,9 @@ typedef double               cmsFloat64Number;
 #ifdef CMS_DONT_USE_INT64
     typedef cmsUInt32Number      cmsUInt64Number[2];
     typedef cmsInt32Number       cmsInt64Number[2];
+#   if defined(CMS_LARGE_FILE_SUPPORT) 
+#      error "You need int64 for large file support"
+#   endif
 #endif
 
 // Derivative types
@@ -504,7 +514,13 @@ typedef enum {
     cmsSigLinkClass                         = 0x6C696E6B,  // 'link'
     cmsSigAbstractClass                     = 0x61627374,  // 'abst'
     cmsSigColorSpaceClass                   = 0x73706163,  // 'spac'
-    cmsSigNamedColorClass                   = 0x6e6d636c   // 'nmcl'
+    cmsSigNamedColorClass                   = 0x6e6d636c,  // 'nmcl'
+
+                                                            // iccMAX only
+    cmsSigColorEncodingSpaceClass           = 0x63656E63,  // 'cenc' 
+    cmsSigMultiplexIdentificationClass      = 0x6D696420,  // 'mid '
+    cmsSigMultiplexLinkClass                = 0x6d6c6e6b,  // 'mlnk'
+    cmsSigMultiplexVisualizationClass       = 0x6d766973   // 'mvis'    
 
 } cmsProfileClassSignature;
 
@@ -1078,8 +1094,12 @@ CMSAPI int               CMSEXPORT cmsGetEncodedCMMversion(void);
 // Support of non-standard functions --------------------------------------------------------------------------------------
 
 CMSAPI int               CMSEXPORT cmsstrcasecmp(const char* s1, const char* s2);
-CMSAPI long int          CMSEXPORT cmsfilelength(FILE* f);
 
+#ifdef CMS_LARGE_FILE_SUPPORT
+CMSAPI long long int     CMSEXPORT cmsfilelength(FILE* f);
+#else
+CMSAPI long int          CMSEXPORT cmsfilelength(FILE* f);
+#endif
 
 // Context handling --------------------------------------------------------------------------------------------------------
 
@@ -1502,6 +1522,7 @@ CMSAPI cmsHPROFILE       CMSEXPORT cmsCreateProfilePlaceholder(cmsContext Contex
 CMSAPI cmsContext        CMSEXPORT cmsGetProfileContextID(cmsHPROFILE hProfile);
 CMSAPI cmsInt32Number    CMSEXPORT cmsGetTagCount(cmsHPROFILE hProfile);
 CMSAPI cmsTagSignature   CMSEXPORT cmsGetTagSignature(cmsHPROFILE hProfile, cmsUInt32Number n);
+CMSAPI cmsBool           CMSEXPORT cmsGetTagOffsetAndSize(cmsHPROFILE hProfile, cmsUInt32Number n, cmsUInt32Number* offset, cmsUInt32Number* size);
 CMSAPI cmsBool           CMSEXPORT cmsIsTag(cmsHPROFILE hProfile, cmsTagSignature sig);
 
 // Read and write pre-formatted data
@@ -1525,6 +1546,8 @@ CMSAPI void              CMSEXPORT cmsGetHeaderAttributes(cmsHPROFILE hProfile,
 CMSAPI void              CMSEXPORT cmsGetHeaderProfileID(cmsHPROFILE hProfile, cmsUInt8Number* ProfileID);
 CMSAPI cmsBool           CMSEXPORT cmsGetHeaderCreationDateTime(cmsHPROFILE hProfile, struct tm *Dest);
 CMSAPI cmsUInt32Number   CMSEXPORT cmsGetHeaderRenderingIntent(cmsHPROFILE hProfile);
+CMSAPI cmsUInt32Number   CMSEXPORT cmsGetHeaderCMM(cmsHPROFILE hProfile);
+
 
 CMSAPI void              CMSEXPORT cmsSetHeaderFlags(cmsHPROFILE hProfile, cmsUInt32Number Flags);
 CMSAPI cmsUInt32Number   CMSEXPORT cmsGetHeaderManufacturer(cmsHPROFILE hProfile);
@@ -1867,6 +1890,13 @@ CMSAPI cmsContext       CMSEXPORT cmsGetTransformContextID(cmsHTRANSFORM hTransf
 CMSAPI cmsUInt32Number CMSEXPORT cmsGetTransformInputFormat(cmsHTRANSFORM hTransform);
 CMSAPI cmsUInt32Number CMSEXPORT cmsGetTransformOutputFormat(cmsHTRANSFORM hTransform);
 
+// Access the optimized pipeline and gamut-check pipeline inside a transform.
+CMSAPI cmsPipeline*    CMSEXPORT cmsGetTransformPipeline(cmsHTRANSFORM hTransform);
+CMSAPI cmsPipeline*    CMSEXPORT cmsGetTransformGamutCheckPipeline(cmsHTRANSFORM hTransform);
+// Grab colorants
+CMSAPI cmsNAMEDCOLORLIST* CMSEXPORT cmsGetTransformInputColorants(cmsHTRANSFORM hTransform);
+CMSAPI cmsNAMEDCOLORLIST* CMSEXPORT cmsGetTransformOutputColorants(cmsHTRANSFORM hTransform);
+
 // For backwards compatibility
 CMSAPI cmsBool          CMSEXPORT cmsChangeBuffersFormat(cmsHTRANSFORM hTransform,
                                                          cmsUInt32Number InputFormat,

package/include/libexif/exif-utils.h

@@ -170,7 +170,7 @@ void exif_set_srational (unsigned char *b, ExifByteOrder order,
 			 ExifSRational value);
 
 /*! \internal */
-void exif_convert_utf16_to_utf8 (char *out, const unsigned char *in, int maxlen);
+void exif_convert_utf16_to_utf8 (char *out, unsigned int outlen, const unsigned char *in, unsigned int inlen);
 
 /* Please do not use this function outside of the library. */
 

package/include/libheif/heif.h

@@ -37,5 +37,7 @@
 #include <libheif/heif_context.h>
 #include <libheif/heif_image_handle.h>
 #include <libheif/heif_tiling.h>
+#include <libheif/heif_components.h>
+#include <libheif/heif_omaf.h>
 
 #endif

package/include/libheif/heif_color.h

@@ -55,8 +55,8 @@ typedef struct heif_color_conversion_options
 
   // --- version 1 options
 
-  enum heif_chroma_downsampling_algorithm preferred_chroma_downsampling_algorithm;
-  enum heif_chroma_upsampling_algorithm preferred_chroma_upsampling_algorithm;
+  heif_chroma_downsampling_algorithm preferred_chroma_downsampling_algorithm;
+  heif_chroma_upsampling_algorithm preferred_chroma_upsampling_algorithm;
 
   // When set to 'false' libheif may also use a different algorithm if the preferred one is not available
   // or using a different algorithm is computationally less complex. Note that currently (v1.17.0) this
@@ -85,7 +85,7 @@ typedef struct heif_color_conversion_options_ext
 
   // --- version 1 options
 
-  enum heif_alpha_composition_mode alpha_composition_mode;
+  heif_alpha_composition_mode alpha_composition_mode;
 
   // color values should be specified in the range [0, 65535]
   uint16_t background_red, background_green, background_blue;
@@ -126,7 +126,7 @@ typedef enum heif_color_profile_type
 //       However, you can still use heif_image_handle_get_raw_color_profile() and
 //       heif_image_handle_get_nclx_color_profile() to access both profiles.
 LIBHEIF_API
-enum heif_color_profile_type heif_image_handle_get_color_profile_type(const heif_image_handle* handle);
+heif_color_profile_type heif_image_handle_get_color_profile_type(const heif_image_handle* handle);
 
 LIBHEIF_API
 size_t heif_image_handle_get_raw_color_profile_size(const heif_image_handle* handle);
@@ -198,9 +198,9 @@ typedef struct heif_color_profile_nclx
 
   uint8_t version;
 
-  enum heif_color_primaries color_primaries;
-  enum heif_transfer_characteristics transfer_characteristics;
-  enum heif_matrix_coefficients matrix_coefficients;
+  heif_color_primaries color_primaries;
+  heif_transfer_characteristics transfer_characteristics;
+  heif_matrix_coefficients matrix_coefficients;
   uint8_t full_range_flag;
 
   // --- decoded values (not used when saving nclx)
@@ -240,7 +240,7 @@ void heif_nclx_color_profile_free(heif_color_profile_nclx* nclx_profile);
 // This function will now return ICC if one is present and NCLX only if there is no ICC.
 // You may better avoid this function and simply query for NCLX and ICC directly.
 LIBHEIF_API
-enum heif_color_profile_type heif_image_get_color_profile_type(const heif_image* image);
+heif_color_profile_type heif_image_get_color_profile_type(const heif_image* image);
 
 // Returns the size of the ICC profile if one is assigned to the image. Otherwise, it returns 0.
 LIBHEIF_API
@@ -276,17 +276,34 @@ heif_error heif_image_set_nclx_color_profile(heif_image* image,
 
 // --- content light level ---
 
-// Note: a value of 0 for any of these values indicates that the value is undefined.
-// The unit of these values is Candelas per square meter.
+// Semantics follow the H.265 'Content light level information' SEI message
+// (ITU-T H.265 Annex D.3.35). Identifies upper bounds for the nominal
+// target brightness light level of the pictures. The bounds are defined
+// against samples in a 4:4:4 RGB representation in the linear light domain,
+// in units of candelas per square metre (cd/m^2 = nits). A field value
+// of 0 means "no upper bound indicated" (i.e. undefined).
 typedef struct heif_content_light_level
 {
+  // Upper bound on the maximum light level among all individual linear-light
+  // 4:4:4 RGB samples across the sequence, in cd/m^2 (= field).
+  // Also called MaxCLL.
   uint16_t max_content_light_level;
+
+  // Upper bound on the maximum per-picture average light level among the
+  // linear-light 4:4:4 RGB samples (averaged over any individual picture),
+  // in cd/m^2 (= field). Also called MaxFALL (or MaxPALL).
+  // For letterboxed content the average is expected to be taken only over
+  // the visually relevant region (H.265 D.3.35 NOTE 3).
   uint16_t max_pic_average_light_level;
 } heif_content_light_level;
 
 LIBHEIF_API
 int heif_image_has_content_light_level(const heif_image*);
 
+LIBHEIF_API
+int heif_image_handle_has_content_light_level(const heif_image_handle*);
+
+// TODO: this function should also return 'int' to be consistent to heif_image_handle_get_content_light_level.
 LIBHEIF_API
 void heif_image_get_content_light_level(const heif_image*, heif_content_light_level* out);
 
@@ -303,13 +320,43 @@ void heif_image_handle_set_content_light_level(const heif_image_handle*, const h
 
 // --- mastering display colour volume ---
 
-// Note: color coordinates are defined according to the CIE 1931 definition of x as specified in ISO 11664-1 (see also ISO 11664-3 and CIE 15).
+// Semantics follow the H.265 'Mastering display colour volume' SEI message
+// (ITU-T H.265 Annex D.3.28) and SMPTE ST 2086. Identifies the colour
+// volume (primaries, white point, luminance range) of the mastering display
+// for the associated content. CIE 1931 chromaticity coordinates are defined
+// by ISO 11664-1 (see also ISO 11664-3 and CIE 15).
+//
+// For RGB mastering displays, H.265 suggests the index order
+//   [0]=green, [1]=blue, [2]=red
+// (see H.265 Annex E, Table E.3).
 typedef struct heif_mastering_display_colour_volume
 {
+  // CIE 1931 chromaticity coordinates of the three colour primaries, in
+  // normalized increments of 0.00002 (CIE value = field / 50000).
+  // Valid ranges per H.265: x in 5..37000, y in 5..42000 inclusive; values
+  // outside indicate "unknown / unspecified".
+  // Note: SMPTE ST 2086 uses four-decimal-place coordinates, i.e. multiples
+  // of 5 in this encoding.
   uint16_t display_primaries_x[3];
   uint16_t display_primaries_y[3];
+
+  // CIE 1931 chromaticity coordinates of the mastering display's white
+  // point, in normalized increments of 0.00002. Valid ranges as for the
+  // primaries (x in 5..37000, y in 5..42000).
+  // Note: ANSI/CTA 861-G uses (0,0) to indicate that the white point
+  // chromaticity is unknown.
   uint16_t white_point_x;
   uint16_t white_point_y;
+
+  // Nominal maximum / minimum display luminance of the mastering display,
+  // in units of 0.0001 candelas per square metre (cd/m^2 = field / 10000).
+  // Valid ranges per H.265:
+  //   max in 50000..100000000  (5..10000 cd/m^2)
+  //   min in     1..50000      (0.0001..5 cd/m^2)
+  // When max == 50000, min shall not equal 50000.
+  // Note: ANSI/CTA 861-G uses 0 to indicate "unknown".
+  // Note: SMPTE ST 2086 (2018) specifies max as a multiple of 1 cd/m^2, i.e.
+  // a multiple of 10000 in this encoding.
   uint32_t max_display_mastering_luminance;
   uint32_t min_display_mastering_luminance;
 } heif_mastering_display_colour_volume;
@@ -325,9 +372,24 @@ typedef struct heif_decoded_mastering_display_colour_volume
   double min_display_mastering_luminance;
 } heif_decoded_mastering_display_colour_volume;
 
+// Semantics follow the H.265 'Ambient viewing environment' SEI message
+// (ITU-T H.265 Annex D.3.39). Identifies the nominal ambient viewing
+// environment intended for display of the associated content.
 typedef struct heif_ambient_viewing_environment
 {
+  // Environmental illuminance of the ambient viewing environment, in units
+  // of 0.0001 lux (i.e. lux = value / 10000). In H.265 this field is called
+  // 'ambient_illuminance' and is required to be non-zero; 0 is treated here
+  // as "undefined".
   uint32_t ambient_illumination;
+
+  // Normalized CIE 1931 chromaticity coordinates of the environmental
+  // ambient light, in units of 0.00002 (i.e. CIE x = value / 50000).
+  // Valid range per H.265 is 0..50000 inclusive. CIE 1931 x/y are defined
+  // by ISO 11664-1 (see also ISO 11664-3 and CIE 15).
+  //
+  // Example (Rec. ITU-R BT.2035, D65 background): ambient_illumination=100000,
+  // ambient_light_x=15635, ambient_light_y=16450.
   uint16_t ambient_light_x;
   uint16_t ambient_light_y;
 } heif_ambient_viewing_environment;
@@ -335,6 +397,9 @@ typedef struct heif_ambient_viewing_environment
 LIBHEIF_API
 int heif_image_has_mastering_display_colour_volume(const heif_image*);
 
+LIBHEIF_API
+int heif_image_handle_has_mastering_display_colour_volume(const heif_image_handle*);
+
 LIBHEIF_API
 void heif_image_get_mastering_display_colour_volume(const heif_image*, heif_mastering_display_colour_volume* out);
 
@@ -349,6 +414,57 @@ LIBHEIF_API
 void heif_image_handle_set_mastering_display_colour_volume(const heif_image_handle*, const heif_mastering_display_colour_volume* in);
 
 
+// --- ambient viewing environment ---
+
+LIBHEIF_API
+int heif_image_has_ambient_viewing_environment(const heif_image*);
+
+LIBHEIF_API
+int heif_image_handle_has_ambient_viewing_environment(const heif_image_handle*);
+
+// Returns whether the image has 'ambient viewing environment' information. If 0 is returned, the output is not filled.
+LIBHEIF_API
+int heif_image_get_ambient_viewing_environment(const heif_image*, heif_ambient_viewing_environment* out);
+
+// Returns whether the image has 'ambient viewing environment' information. If 0 is returned, the output is not filled.
+LIBHEIF_API
+int heif_image_handle_get_ambient_viewing_environment(const heif_image_handle*, heif_ambient_viewing_environment* out);
+
+LIBHEIF_API
+void heif_image_set_ambient_viewing_environment(const heif_image*, const heif_ambient_viewing_environment* in);
+
+LIBHEIF_API
+void heif_image_handle_set_ambient_viewing_environment(const heif_image_handle*, const heif_ambient_viewing_environment* in);
+
+
+// --- nominal diffuse white ---
+
+// Nominal diffuse white luminance (ISO/IEC 23008-12 'ndwt' box). The luminance
+// is given in units of 0.0001 candelas per square metre. A value of 0 is valid
+// and selects the default definition of ISO/TS 22028-5.
+
+// If the image has no 'nominal diffuse white' information, the getter returns 0,
+// which is indistinguishable from a stored luminance of 0. Use the has_ function
+// to disambiguate.
+LIBHEIF_API
+int heif_image_has_nominal_diffuse_white_luminance(const heif_image*);
+
+LIBHEIF_API
+uint32_t heif_image_get_nominal_diffuse_white_luminance(const heif_image*);
+
+LIBHEIF_API
+void heif_image_set_nominal_diffuse_white_luminance(const heif_image*, uint32_t luminance);
+
+LIBHEIF_API
+int heif_image_handle_has_nominal_diffuse_white_luminance(const heif_image_handle*);
+
+LIBHEIF_API
+uint32_t heif_image_handle_get_nominal_diffuse_white_luminance(const heif_image_handle*);
+
+LIBHEIF_API
+void heif_image_handle_set_nominal_diffuse_white_luminance(const heif_image_handle*, uint32_t luminance);
+
+
 // Converts the internal numeric representation of heif_mastering_display_colour_volume to the
 // normalized values, collected in heif_decoded_mastering_display_colour_volume.
 // Values that are out-of-range are decoded to 0, indicating an undefined value (as specified in ISO/IEC 23008-2).

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

@@ -302,7 +302,8 @@ void heif_context_debug_dump_boxes_to_file(heif_context* ctx, int fd);
 // 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.
-// Requires ENABLE_EXPERIMENTAL_MINI_FORMAT to be enabled at compile time.
+// 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);