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

package/include/libheif/heif_regions.h

@@ -22,7 +22,9 @@
 #ifndef LIBHEIF_HEIF_REGIONS_H
 #define LIBHEIF_HEIF_REGIONS_H
 
-#include "heif.h"
+#include "heif_image_handle.h"
+#include "heif_library.h"
+#include "heif_error.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -40,7 +42,7 @@ typedef struct heif_region_item heif_region_item;
  * Each region item will contain zero or more regions, which may have different geometry or
  * mask representations.
 */
-enum heif_region_type
+typedef enum heif_region_type
 {
   /**
    * Point geometry.
@@ -119,7 +121,7 @@ enum heif_region_type
    * considered to form a closed surface. Only the edge is part of the region.
   */
   heif_region_type_polyline = 6
-};
+} heif_region_type;
 
 typedef struct heif_region heif_region;
 

package/include/libheif/heif_security.h

@@ -38,13 +38,14 @@ typedef struct heif_security_limits
 {
   uint8_t version;
 
-  // --- version 1
+  // --- version 1 (v1.19.0)
 
   // Limit on the maximum image size to avoid allocating too much memory.
   // For example, setting this to 32768^2 pixels = 1 Gigapixels results
   // in 1.5 GB memory need for YUV-4:2:0 or 4 GB for RGB32.
   uint64_t max_image_size_pixels;
   uint64_t max_number_of_tiles;
+  // Also used for polarization pattern (splz) size limit.
   uint32_t max_bayer_pattern_pixels;
   uint32_t max_items;
 
@@ -58,11 +59,32 @@ typedef struct heif_security_limits
 
   uint32_t max_children_per_box; // for all boxes that are not covered by other limits
 
-  // --- version 2
+  // --- version 2 (v1.20.0)
 
   uint64_t max_total_memory;
   uint32_t max_sample_description_box_entries;
   uint32_t max_sample_group_description_box_entries;
+
+  // --- version 3 (v1.21.0)
+
+  uint32_t max_sequence_frames;
+  uint32_t max_number_of_file_brands;
+
+  // --- version 4 (v1.22.0)
+
+  uint32_t max_bad_pixels;
+
+  // Upper bound (in bytes) on the pixel_size field of an uncompressed (ISO 23001-17)
+  // uncC box. Caps the byte stride between adjacent pixels and prevents pathological
+  // padding values from blowing up tile-size arithmetic.
+  uint32_t max_iso23001_17_pixel_size_bytes;
+
+  // Internal: when libheif derives a limits struct from another one (e.g. to
+  // tighten the maximum image size for a specific decode), this points back to
+  // the registered context whose total-memory budget the allocation should be
+  // accounted against. nullptr means "this is a root context" (the registered
+  // one). User code should leave this as nullptr; the field is set internally.
+  const struct heif_security_limits* parent;
 } heif_security_limits;
 
 

package/include/libheif/heif_sequences.h

@@ -82,7 +82,12 @@ int heif_context_number_of_sequence_tracks(const heif_context*);
 
 /**
  * Returns the IDs for each of the tracks stored in the HEIF file.
- * The output array must have heif_context_number_of_sequence_tracks() entries.
+ *
+ * The caller MUST allocate `out_track_id_array` with exactly
+ * heif_context_number_of_sequence_tracks() entries. The function writes
+ * that many IDs unconditionally. Passing a smaller array results in a
+ * buffer overflow (undefined behavior); there is no capacity parameter
+ * and no truncation.
  */
 LIBHEIF_API
 void heif_context_get_track_ids(const heif_context* ctx, uint32_t out_track_id_array[]);
@@ -111,12 +116,13 @@ heif_track* heif_context_get_track(const heif_context*, uint32_t id);
 
 typedef uint32_t heif_track_type;
 
-enum heif_track_type_4cc
+typedef enum heif_track_type_4cc
 {
   heif_track_type_video = heif_fourcc('v', 'i', 'd', 'e'),
   heif_track_type_image_sequence = heif_fourcc('p', 'i', 'c', 't'),
+  heif_track_type_auxiliary = heif_fourcc('a', 'u', 'x', 'v'),
   heif_track_type_metadata = heif_fourcc('m', 'e', 't', 'a')
-};
+} heif_track_type_4cc;
 
 /**
  * Get the four-cc track handler type.
@@ -128,6 +134,22 @@ enum heif_track_type_4cc
 LIBHEIF_API
 heif_track_type heif_track_get_track_handler_type(const heif_track*);
 
+
+typedef enum heif_auxiliary_track_info_type
+{
+  heif_auxiliary_track_info_type_unknown = 0,
+  heif_auxiliary_track_info_type_alpha = 1
+} heif_auxiliary_track_info_type;
+
+LIBHEIF_API
+enum heif_auxiliary_track_info_type heif_track_get_auxiliary_info_type(const heif_track*);
+
+LIBHEIF_API
+const char* heif_track_get_auxiliary_info_type_urn(const heif_track*);
+
+LIBHEIF_API
+int heif_track_has_alpha_channel(const heif_track*);
+
 /**
  * Get the timescale (clock ticks per second) for this track.
  * Note that this can be different from the timescale used at sequence level.
@@ -137,6 +159,41 @@ heif_track_type heif_track_get_track_handler_type(const heif_track*);
 LIBHEIF_API
 uint32_t heif_track_get_timescale(const heif_track*);
 
+/**
+ * Special return value of `heif_track_get_number_of_repetitions()` indicating that
+ * the editlist requests indefinite repetition (the mvhd duration is the ISOBMFF
+ * "duration unknown" sentinel and the editlist is in repeat mode).
+ */
+#define heif_sequence_track_number_of_repetitions_infinite 0xFFFFFFFFu
+
+/**
+ * How many times the media segment should be played according to the track's edit list.
+ *
+ * Returns:
+ *  - 0 if an edit list box is present but follows a pattern libheif does not interpret
+ *    as a loop count. Callers should fall back to a single playback in that case.
+ *  - 1 when no edit list is present. The media plays exactly once.
+ *  - `heif_sequence_track_number_of_repetitions_infinite` (= UINT32_MAX) when the file
+ *    signals indefinite playback (mvhd duration is the all-1s sentinel together with an
+ *    editlist in repeat mode), or when the repetition count does not fit in uint32_t.
+ *  - Otherwise the number of times the media segment is played.
+ *
+ * The reported value is informational; it does not change how
+ * `heif_track_decode_next_image()` walks samples. By default, that function applies
+ * the edit list and (for repeated playback) returns samples for every requested
+ * repetition; iterating until end-of-sequence on an infinite-loop file therefore
+ * never terminates.
+ *
+ * Clients that want to handle repetition themselves (e.g. to honor an "infinite"
+ * value with their own looping policy or to enforce an application-level cap) should
+ * set `heif_decoding_options::ignore_sequence_editlist` when calling
+ * `heif_track_decode_next_image()`. With that flag set, libheif plays the media
+ * timeline exactly once. Use the value returned by this function to decide how often
+ * to replay the track at the application level.
+ */
+LIBHEIF_API
+uint32_t heif_track_get_number_of_repetitions(const heif_track*);
+
 
 // --- reading visual tracks
 
@@ -160,8 +217,8 @@ heif_error heif_track_get_image_resolution(const heif_track*, uint16_t* out_widt
 LIBHEIF_API
 heif_error heif_track_decode_next_image(heif_track* track,
                                         heif_image** out_img,
-                                        enum heif_colorspace colorspace,
-                                        enum heif_chroma chroma,
+                                        heif_colorspace colorspace,
+                                        heif_chroma chroma,
                                         const heif_decoding_options* options);
 
 /**
@@ -189,7 +246,8 @@ uint32_t heif_track_get_sample_entry_type_of_first_cluster(const heif_track*);
  * @param out_uri A string with the URI will be returned. Free this string with `heif_string_release()`.
  */
 LIBHEIF_API
-heif_error heif_track_get_urim_sample_entry_uri_of_first_cluster(const heif_track* track, const char** out_uri);
+heif_error heif_track_get_urim_sample_entry_uri_of_first_cluster(const heif_track*,
+                                                                 const char** out_uri);
 
 
 /** Sequence sample object that can hold any raw byte data.
@@ -245,18 +303,24 @@ uint32_t heif_raw_sequence_sample_get_duration(const heif_raw_sequence_sample*);
 LIBHEIF_API
 void heif_context_set_sequence_timescale(heif_context*, uint32_t timescale);
 
+// Number of times the sequence should be played in total (default = 1).
+// Can be set to heif_sequence_maximum_number_of_repetitions.
+LIBHEIF_API
+void heif_context_set_number_of_sequence_repetitions(heif_context*, uint32_t number_of_repetitions);
+
+#define heif_sequence_maximum_number_of_repetitions 0
 
 /**
  * Specifies whether a 'sample auxiliary info' is stored with the samples.
  * The difference between `heif_sample_aux_info_presence_optional` and `heif_sample_aux_info_presence_mandatory`
  * is that `heif_sample_aux_info_presence_mandatory` will throw an error if the data is missing when writing a sample.
  */
-enum heif_sample_aux_info_presence
+typedef enum heif_sample_aux_info_presence
 {
   heif_sample_aux_info_presence_none = 0,
   heif_sample_aux_info_presence_optional = 1,
   heif_sample_aux_info_presence_mandatory = 2
-};
+} heif_sample_aux_info_presence;
 
 
 typedef struct heif_track_options heif_track_options;
@@ -288,6 +352,8 @@ void heif_track_options_set_timescale(heif_track_options*, uint32_t timescale);
  *
  * If 'false', all aux_info will be written as one block after the compressed image data.
  * This has the advantage that no aux_info offsets have to be written.
+ *
+ * Note: currently ignored. Interleaved writing is disabled.
  */
 LIBHEIF_API
 void heif_track_options_set_interleaved_sample_aux_infos(heif_track_options*, int interleaved_flag);
@@ -312,7 +378,37 @@ void heif_track_options_set_gimi_track_id(heif_track_options*,
 
 // --- writing visual tracks
 
-// This structure is for future use. It is not defined yet.
+typedef enum heif_sequence_gop_structure
+{
+  // Only independently decodable keyframes.
+  heif_sequence_gop_structure_intra_only,
+
+  // No frame reordering, usually an IPPPP structure.
+  heif_sequence_gop_structure_lowdelay,
+
+  // All frame types are allowed, including frame reordering, to achieve
+  // the best compression ratio.
+  heif_sequence_gop_structure_unrestricted
+} heif_sequence_gop_structure;
+
+
+// Describes the intent of the encoded sequence content. Encoder plugins may
+// use this to choose different default tunings (e.g. perceptual quality vs.
+// rate-distortion) for slide-show-style image sequences vs. video.
+//
+// Pass `_auto` to let libheif pick a value. Today libheif derives the kind
+// from the track's handler type (`pict` -> image_sequence, `vide` -> video);
+// in the future it may use additional input signals (e.g. frame rate or
+// frame-to-frame similarity). Plugins never see `_auto`: libheif resolves it
+// to a concrete kind before passing the options to the encoder plugin.
+typedef enum heif_sequence_content_kind
+{
+  heif_sequence_content_kind_auto = 0,
+  heif_sequence_content_kind_image_sequence = 1,
+  heif_sequence_content_kind_video = 2
+} heif_sequence_content_kind;
+
+
 typedef struct heif_sequence_encoding_options
 {
   uint8_t version;
@@ -324,11 +420,40 @@ typedef struct heif_sequence_encoding_options
   const heif_color_profile_nclx* output_nclx_profile;
 
   heif_color_conversion_options color_conversion_options;
+
+  // version 2 options
+
+  enum heif_sequence_gop_structure gop_structure;
+  int keyframe_distance_min; // 0 - undefined
+  int keyframe_distance_max; // 0 - undefined
+
+  int save_alpha_channel;
+
+  // version 3 options
+
+  // Intent of the encoded content. Encoder plugins may use this to choose
+  // different tunings for slide-show-style image sequences vs. video.
+  // Set to `_auto` (the default) to let libheif pick. libheif resolves the
+  // value to a concrete kind before passing the options to the encoder
+  // plugin, so plugins never see `_auto`.
+  enum heif_sequence_content_kind content_kind;
 } heif_sequence_encoding_options;
 
+
 LIBHEIF_API
 heif_sequence_encoding_options* heif_sequence_encoding_options_alloc(void);
 
+/**
+ * Copy fields from `src` into `dst`, respecting both structs' version numbers.
+ * Only fields present in `min(dst->version, src->version)` are copied, so this
+ * is safe when libheif and the caller were built against different header
+ * versions of `heif_sequence_encoding_options`. Pass NULL `src` to leave `dst`
+ * unchanged.
+ */
+LIBHEIF_API
+void heif_sequence_encoding_options_copy(heif_sequence_encoding_options* dst,
+                                         const heif_sequence_encoding_options* src);
+
 LIBHEIF_API
 void heif_sequence_encoding_options_release(heif_sequence_encoding_options*);
 
@@ -362,6 +487,8 @@ void heif_image_set_duration(heif_image*, uint32_t duration);
  * Encode the image into a visual track.
  * If the passed track is no visual track, an error will be returned.
  *
+ * @param image                     The input image to append to the sequence.
+ * @param encoder                   The encoder used for encoding the image.
  * @param sequence_encoding_options Options for sequence encoding. If NULL, default options will be used.
  */
 LIBHEIF_API
@@ -370,14 +497,31 @@ heif_error heif_track_encode_sequence_image(heif_track*,
                                             heif_encoder* encoder,
                                             const heif_sequence_encoding_options* sequence_encoding_options);
 
+/**
+ * When all sequence frames have been sent, you can to call this function to let the
+ * library know that no more frames will follow. This is strongly recommended, but optional
+ * for backwards compatibility.
+ * If you do not end the sequence explicitly with this function, it will be closed
+ * automatically when the HEIF file is written. Using this function has the advantage
+ * that you can free the {@link heif_encoder} afterwards (with {@link heif_encoder_release}).
+ * If you do not use call function, you have to keep the {@link heif_encoder} alive
+ * until the HEIF file is written.
+ */
+LIBHEIF_API
+heif_error heif_track_encode_end_of_sequence(heif_track*,
+                                             heif_encoder* encoder);
+
 // --- metadata tracks
 
 /**
  * Add a metadata track.
+ * The track is created as a 'urim' "URI Meta Sample Entry".
  * The track content type is specified by the 'uri' parameter.
- * This will be created as a 'urim' "URI Meta Sample Entry".
  *
- * @param options Optional track creation options. If NULL, default options will be used.
+ * @param uri       Track content type.
+ * @param options   Optional track creation options. If NULL, default options will be used.
+ * @param out_track Returns the created track object. If this is not NULL, you have to
+ *                  free the returned track with {@link heif_track_release}.
  */
 LIBHEIF_API
 heif_error heif_context_add_uri_metadata_sequence_track(heif_context*,
@@ -521,12 +665,12 @@ const heif_tai_clock_info* heif_track_get_tai_clock_info_of_first_cluster(heif_t
 
 // --- track references
 
-enum heif_track_reference_type
+typedef enum heif_track_reference_type
 {
   heif_track_reference_type_description = heif_fourcc('c', 'd', 's', 'c'), // track_description
   heif_track_reference_type_thumbnails = heif_fourcc('t', 'h', 'm', 'b'), // thumbnails
   heif_track_reference_type_auxiliary = heif_fourcc('a', 'u', 'x', 'l') // auxiliary data (e.g. depth maps or alpha channel)
-};
+} heif_track_reference_type;
 
 /**
  * Add a reference between tracks.
@@ -543,7 +687,12 @@ size_t heif_track_get_number_of_track_reference_types(const heif_track*);
 
 /**
  * List the reference types used in this track.
- * The passed array must have heif_track_get_number_of_track_reference_types() entries.
+ *
+ * The caller MUST allocate `out_reference_types` with exactly
+ * heif_track_get_number_of_track_reference_types() entries. The function
+ * writes that many values unconditionally. Passing a smaller array
+ * results in a buffer overflow (undefined behavior); there is no
+ * capacity parameter and no truncation.
  */
 LIBHEIF_API
 void heif_track_get_track_reference_types(const heif_track*, uint32_t out_reference_types[]);

package/include/libheif/heif_text.h

@@ -0,0 +1,161 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <dirk.farin@gmail.com>
+ * Copyright (c) 2025 Brad Hards <bradh@frogmouth.net>
+ *
+ * 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_TEXT_H
+#define LIBHEIF_HEIF_TEXT_H
+
+#include "heif_image_handle.h"
+#include "heif_library.h"
+#include "heif_error.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// --- text items and fonts
+
+// See ISO/IEC 23008-12:2025 Section 6.10 "Text and font items"
+
+typedef struct heif_text_item heif_text_item;
+
+/**
+ * Get the number of text items that are attached to an image.
+ *
+ * @param image_handle the image handle for the image to query.
+ * @return the number of text items, which can be zero.
+ */
+LIBHEIF_API
+int heif_image_handle_get_number_of_text_items(const heif_image_handle* image_handle);
+
+/**
+ * Get the text item identifiers for the text items attached to an image.
+ *
+ * Possible usage (in C++):
+ * @code
+ *  int numTextItems = heif_image_handle_get_number_of_text_items(handle);
+ *  if (numTextItems > 0) {
+ *      std::vector<heif_item_id> text_item_ids(numTextItems);
+ *      heif_image_handle_get_list_of_text_item_ids(handle, text_item_ids.data(), numTextItems);
+ *      // use text item ids
+ *  }
+ * @endcode
+ *
+ * @param image_handle the image handle for the parent image to query
+ * @param text_item_ids_array array to put the item identifiers into
+ * @param max_count the maximum number of text identifiers
+ * @return the number of text item identifiers that were returned.
+ */
+LIBHEIF_API
+int heif_image_handle_get_list_of_text_item_ids(const heif_image_handle* image_handle,
+                                                heif_item_id* text_item_ids_array,
+                                                int max_count);
+
+
+/**
+ * Get the text item.
+ *
+ * Caller is responsible for release of the output heif_text_item with heif_text_item_release().
+ *
+ * @param context the context to get the text item from, usually from a file operation
+ * @param text_item_id the identifier for the text item
+ * @param out pointer to pointer to the resulting text item
+ * @return heif_error_ok on success, or an error value indicating the problem
+ */
+LIBHEIF_API
+heif_error heif_context_get_text_item(const heif_context* context,
+                                      heif_item_id text_item_id,
+                                      heif_text_item** out);
+
+/**
+ * Get the item identifier for a text item.
+ *
+ * @param text_item the text item to query
+ * @return the text item identifier (or 0 if the text_item is null)
+ */
+LIBHEIF_API
+heif_item_id heif_text_item_get_id(heif_text_item* text_item);
+
+/**
+ * Get the item content for a text item.
+ *
+ * This is the payload text, in the format given by the associated content_type.
+ *
+ * @param text_item the text item to query
+ * @return the text item content (or null if the text_item is null). The returned string shall be released
+ * with heif_string_release().
+ */
+LIBHEIF_API
+const char* heif_text_item_get_content(heif_text_item* text_item);
+
+/**
+ * This function is similar to heif_item_get_property_extended_language(), but
+ * takes a `heif_text_item` as parameter.
+ *
+ * @param text_item The text item for which we are requesting the language.
+ * @param out_language Output parameter for the text language. Free with heif_string_release().
+ * @return
+ */
+LIBHEIF_API
+heif_error heif_text_item_get_property_extended_language(const heif_text_item* text_item,
+                                                         char** out_language);
+
+// --- adding text items
+
+/**
+ * Add a text item to an image.
+*/
+LIBHEIF_API
+heif_error heif_image_handle_add_text_item(heif_image_handle *image_handle,
+                                           const char *content_type,
+                                           const char *text,
+                                           heif_text_item** out_text_item);
+
+/**
+ * Release a text item.
+ *
+ * This should be called on items from heif_context_add_text_item().
+ *
+ * @param text_item the item to release.
+ */
+LIBHEIF_API
+void heif_text_item_release(heif_text_item* text_item);
+
+/**
+ * Set the extended language property to the text item.
+ *
+ * This adds an RFC 5346 (IETF BCP 47) extended language tag, such as "en-AU".
+ *
+ * @param text_item the text item to query
+ * @param language the language to set
+ * @param out_optional_propertyId Output parameter for the property ID of the language property.
+ *                                This parameter may be NULL if the info is not required.
+ * @return heif_error_ok on success, or an error value indicating the problem
+ */
+LIBHEIF_API
+heif_error heif_text_item_set_extended_language(heif_text_item* text_item,
+                                                const char *language,
+                                                heif_property_id* out_optional_propertyId);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/include/libheif/heif_tiling.h

@@ -85,8 +85,8 @@ typedef struct heif_decoding_options heif_decoding_options;
 LIBHEIF_API
 heif_error heif_image_handle_decode_image_tile(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,
                                                uint32_t tile_x, uint32_t tile_y);
 

package/include/libheif/heif_uncompressed.h

@@ -21,6 +21,8 @@
 #ifndef LIBHEIF_HEIF_UNCOMPRESSED_H
 #define LIBHEIF_HEIF_UNCOMPRESSED_H
 
+#include "libheif/heif_components.h"
+#include "libheif/heif_properties.h"
 #include "libheif/heif.h"
 
 #ifdef __cplusplus
@@ -32,13 +34,19 @@ extern "C" {
  *        Despite its name, this is not limited to uncompressed images.
  *        It is also possible to add images with lossless compression methods.
  *        See heif_metadata_compression for more information.
+ *
+ * ISO/IEC 23001-17 metadata properties (Bayer / polarization / sensor bad
+ * pixels / NUC / chroma sample location) live in heif_properties.h, which is
+ * included above for back-compat.
  */
 
+
 // --- 'unci' images
 
+// Compression methods for 'unci' (ISO 23001-17) images.
 // This is similar to heif_metadata_compression. We should try to keep the integers compatible, but each enum will just
 // contain the allowed values.
-enum heif_unci_compression
+typedef enum heif_unci_compression
 {
   heif_unci_compression_off = 0,
   //heif_unci_compression_auto = 1,
@@ -46,9 +54,11 @@ enum heif_unci_compression
   heif_unci_compression_deflate = 3,
   heif_unci_compression_zlib = 4,
   heif_unci_compression_brotli = 5
-};
+} heif_unci_compression;
 
 
+// --- 'unci' image parameters
+
 typedef struct heif_unci_image_parameters
 {
   int version;
@@ -61,11 +71,12 @@ typedef struct heif_unci_image_parameters
   uint32_t tile_width;
   uint32_t tile_height;
 
-  enum heif_unci_compression compression;
+  heif_unci_compression compression;
 
   // TODO: interleave type, padding
 } heif_unci_image_parameters;
 
+
 LIBHEIF_API
 heif_unci_image_parameters* heif_unci_image_parameters_alloc(void);
 
@@ -84,9 +95,17 @@ void heif_unci_image_parameters_release(heif_unci_image_parameters*);
  * However, this will by default disable any compression and any control about
  * the data layout.
  *
+ * The function also accepts a direct heif_unci_image_parameters argument and
+ * indirectly through encoding_options. At least one of the two must be non-null.
+ * If both are non-null and differ, the direct argument takes precedence.
+ *
  * @param ctx The file context
- * @param parameters The parameters for the image, must not be NULL.
- * @param encoding_options Optional, may be NULL.
+ * @param parameters The parameters for the image. May be NULL if
+ *                  heif_encoding_options::unci_parameters is set instead. If both this
+ *                  argument and encoding_options->unci_parameters are non-null and
+ *                  differ, this argument takes precedence.
+ * @param encoding_options Optional, may be NULL. If non-null and unci_parameters is set,
+ *                  it may carry the unci parameters in place of the direct argument.
  * @param prototype An image with the same channel configuration as the image data
  *                  that will be later inserted. The image size need not match this.
  *                  Must not be NULL.
@@ -102,6 +121,11 @@ heif_error heif_context_add_empty_unci_image(heif_context* ctx,
                                              const heif_image* prototype,
                                              heif_image_handle** out_unci_image_handle);
 
+// Multi-component access functions (heif_image_get/add_component_*,
+// heif_image_handle_get_component_*, heif_image_set_gimi_component_content_id)
+// live in heif_components.h, which is included above.
+
+
 #ifdef __cplusplus
 }
 #endif

package/include/libheif/heif_version.h

@@ -28,10 +28,10 @@
 #define LIBHEIF_HEIF_VERSION_H
 
 /* Numeric representation of the version */
-#define LIBHEIF_NUMERIC_VERSION ((1<<24) | (20<<16) | (2<<8) | 0)
+#define LIBHEIF_NUMERIC_VERSION ((1<<24) | (23<<16) | (0<<8) | 0)
 
 /* Version string */
-#define LIBHEIF_VERSION "1.20.2"
+#define LIBHEIF_VERSION "1.23.0"
 
 #define LIBHEIF_PLUGIN_DIRECTORY "/src/build/target/lib/libheif"