@img/sharp-libvips-dev 1.3.0-rc.0 → 1.3.0-rc.2

package/include/harfbuzz/hb-version.h

@@ -47,7 +47,7 @@ HB_BEGIN_DECLS
  *
  * The minor component of the library version available at compile-time.
  */
-#define HB_VERSION_MINOR 2
+#define HB_VERSION_MINOR 3
 /**
  * HB_VERSION_MICRO:
  *
@@ -60,7 +60,7 @@ HB_BEGIN_DECLS
  *
  * A string literal containing the library version available at compile-time.
  */
-#define HB_VERSION_STRING "12.2.0"
+#define HB_VERSION_STRING "12.3.0"
 
 /**
  * HB_VERSION_ATLEAST:

package/include/libheif/heif_brands.h

@@ -251,6 +251,9 @@ typedef uint32_t heif_brand2;
 #define heif_brand2_avcs   heif_fourcc('a','v','c','s')
 
 #define heif_brand2_iso8   heif_fourcc('i','s','o','8')
+#define heif_brand2_isom   heif_fourcc('i','s','o','m')
+#define heif_brand2_mp41   heif_fourcc('m','p','4','1')
+#define heif_brand2_mp42   heif_fourcc('m','p','4','2')
 
 // input data should be at least 12 bytes
 LIBHEIF_API

package/include/libheif/heif_color.h

@@ -297,6 +297,9 @@ int heif_image_handle_get_content_light_level(const heif_image_handle*, heif_con
 LIBHEIF_API
 void heif_image_set_content_light_level(const heif_image*, const heif_content_light_level* in);
 
+LIBHEIF_API
+void heif_image_handle_set_content_light_level(const heif_image_handle*, const heif_content_light_level* in);
+
 
 // --- mastering display colour volume ---
 
@@ -342,6 +345,9 @@ int heif_image_handle_get_mastering_display_colour_volume(const heif_image_handl
 LIBHEIF_API
 void heif_image_set_mastering_display_colour_volume(const heif_image*, const heif_mastering_display_colour_volume* in);
 
+LIBHEIF_API
+void heif_image_handle_set_mastering_display_colour_volume(const heif_image_handle*, const heif_mastering_display_colour_volume* in);
+
 
 // Converts the internal numeric representation of heif_mastering_display_colour_volume to the
 // normalized values, collected in heif_decoded_mastering_display_colour_volume.

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;
   };
@@ -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
@@ -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;
     }

package/include/libheif/heif_decoding.h

@@ -101,6 +101,16 @@ 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
+
+  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
 } heif_decoding_options;
 
 

package/include/libheif/heif_encoding.h

@@ -37,7 +37,9 @@ extern "C" {
 
 // ----- encoder -----
 
-// The encoder used for actually encoding an image.
+/**
+ * Opaque object that represents the encoder used to code the images.
+ */
 typedef struct heif_encoder heif_encoder;
 
 // A description of the encoder's capabilities and name.
@@ -100,7 +102,9 @@ heif_error heif_context_get_encoder_for_format(heif_context* context,
                                                enum heif_compression_format format,
                                                heif_encoder**);
 
-// You have to release the encoder after use.
+/**
+ * Release the encoder object after use.
+ */
 LIBHEIF_API
 void heif_encoder_release(heif_encoder*);
 

package/include/libheif/heif_error.h

@@ -254,6 +254,8 @@ enum heif_suberror_code
 
   heif_suberror_Unsupported_essential_property = 3007,
 
+  heif_suberror_Unsupported_track_type = 3008,
+
   // --- Encoder_plugin_error ---
 
   heif_suberror_Unsupported_bit_depth = 4000,

package/include/libheif/heif_image.h

@@ -208,7 +208,7 @@ uint8_t* heif_image_get_plane(heif_image*,
 // These are safer variants of the two functions above.
 // The 'stride' parameter is often multiplied by the image height in the client application.
 // For very large images, this can lead to integer overflows and, consequently, illegal memory accesses.
-// The changed 'stride' parameter types eliminates this common error.
+// The changed 'stride' parameter type eliminates this common error.
 LIBHEIF_API
 const uint8_t* heif_image_get_plane_readonly2(const heif_image*,
                                               enum heif_channel channel,
@@ -262,6 +262,9 @@ void heif_image_get_pixel_aspect_ratio(const heif_image*, uint32_t* aspect_h, ui
 LIBHEIF_API
 void heif_image_set_pixel_aspect_ratio(heif_image*, uint32_t aspect_h, uint32_t aspect_v);
 
+LIBHEIF_API
+void heif_image_handle_set_pixel_aspect_ratio(heif_image_handle*, uint32_t aspect_h, uint32_t aspect_v);
+
 
 // --- heif_image allocation
 

package/include/libheif/heif_image_handle.h

@@ -53,10 +53,17 @@ int heif_image_handle_is_primary_image(const heif_image_handle* handle);
 LIBHEIF_API
 heif_item_id heif_image_handle_get_item_id(const heif_image_handle* handle);
 
-// Get the resolution of an image.
+/** Get the image width.
+ *
+ * If 'handle' is invalid (NULL) or if the image size exceeds the range of `int`, 0 is returned.
+ */
 LIBHEIF_API
 int heif_image_handle_get_width(const heif_image_handle* handle);
 
+/** Get the image height.
+ *
+ * If 'handle' is invalid (NULL) or if the image size exceeds the range of `int`, 0 is returned.
+ */
 LIBHEIF_API
 int heif_image_handle_get_height(const heif_image_handle* handle);
 
@@ -112,6 +119,8 @@ int heif_image_handle_get_pixel_aspect_ratio(const heif_image_handle*, uint32_t*
 LIBHEIF_API
 heif_context* heif_image_handle_get_context(const heif_image_handle* handle);
 
+LIBHEIF_API
+const char* heif_image_handle_get_gimi_content_id(const heif_image_handle* handle);
 
 #ifdef __cplusplus
 }

package/include/libheif/heif_items.h

@@ -21,7 +21,9 @@
 #ifndef LIBHEIF_HEIF_ITEMS_H
 #define LIBHEIF_HEIF_ITEMS_H
 
-#include "libheif/heif.h"
+#include "heif_library.h"
+#include "heif_error.h"
+#include "heif_metadata.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -167,6 +169,27 @@ LIBHEIF_API
 void heif_release_item_data(const heif_context* ctx, uint8_t** item_data);
 
 
+// ------------------------- item language -------------------------
+
+/**
+ * Get the extended language associated with the item.
+ * The item is usually a text item.
+ *
+ * @param context the heif file context containg the item.
+ * @param itemId the identifier for the item
+ * @param out_language output parameter with the item's language. Free with heif_string_release().
+ * @return heif_error_ok on success, or an error value indicating the problem
+ */
+LIBHEIF_API
+heif_error heif_item_get_property_extended_language(const heif_context* context,
+                                                    heif_item_id itemId,
+                                                    char** out_language);
+
+LIBHEIF_API
+heif_error heif_item_set_property_extended_language(heif_context* context,
+                                                    heif_item_id item_id,
+                                                    const char* language, heif_property_id* out_optional_propertyId);
+
 // ------------------------- item references -------------------------
 
 /**

package/include/libheif/heif_library.h

@@ -65,6 +65,9 @@ extern "C" {
 #define LIBHEIF_API
 #endif
 
+/**
+ * Build a 32 bit integer from a 4-character code.
+ */
 #define heif_fourcc(a, b, c, d) ((uint32_t)((a<<24) | (b<<16) | (c<<8) | d))
 
 #include <libheif/heif_version.h>

package/include/libheif/heif_metadata.h

@@ -38,6 +38,9 @@ enum heif_metadata_compression
   heif_metadata_compression_brotli = 5
 };
 
+LIBHEIF_API
+int heif_metadata_compression_method_supported(enum heif_metadata_compression method);
+
 // ------------------------- metadata (Exif / XMP) -------------------------
 
 // How many metadata blocks are attached to an image. If you only want to get EXIF data,

package/include/libheif/heif_plugin.h

@@ -20,6 +20,7 @@
 
 #ifndef LIBHEIF_HEIF_PLUGIN_H
 #define LIBHEIF_HEIF_PLUGIN_H
+#include "heif_sequences.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -43,9 +44,14 @@ extern "C" {
 //  1.13         2         3          2
 //  1.15         3         3          2
 //  1.20         4         3          2
+//  1.21         5         4          2
 
-#define heif_decoder_plugin_latest_version 4
-#define heif_encoder_plugin_latest_version 3
+#define heif_decoder_plugin_latest_version 5
+#define heif_encoder_plugin_latest_version 4
+
+// The minimum plugin versions that can be used with this libheif version.
+#define heif_decoder_plugin_minimum_version 5
+#define heif_encoder_plugin_minimum_version 4
 
 // ====================================================================================================
 //  Decoder plugin API
@@ -53,6 +59,22 @@ extern "C" {
 //  added as plugins. A plugin has to implement the functions specified in heif_decoder_plugin
 //  and the plugin has to be registered to the libheif library using heif_register_decoder().
 
+typedef struct heif_decoder_plugin_compressed_format_description
+{
+  enum heif_compression_format format;
+
+} heif_decoder_plugin_compressed_format_description;
+
+
+typedef struct heif_decoder_plugin_options
+{
+  enum heif_compression_format format;
+  int strict_decoding; // bool
+  int num_threads; // 0 - undefined, use decoder default
+
+} heif_decoder_plugin_options;
+
+
 typedef struct heif_decoder_plugin
 {
   // API version supported by this plugin (see table above for supported versions)
@@ -118,6 +140,24 @@ typedef struct heif_decoder_plugin
 
   // --- version 5 functions will follow below ... ---
 
+  uint32_t minimum_required_libheif_version;
+
+  // Query whether the plugin supports decoding of the given format
+  // Result is a priority value. The plugin with the largest value wins.
+  // Default priority is 100. Returning 0 indicates that the plugin cannot decode this format.
+  int (* does_support_format2)(const heif_decoder_plugin_compressed_format_description* format);
+
+  // Create a new decoder context for decoding an image
+  heif_error (* new_decoder2)(void** decoder, const heif_decoder_plugin_options*);
+
+  heif_error (* push_data2)(void* decoder, const void* data, size_t size, uintptr_t user_data);
+
+  heif_error (* flush_data)(void* decoder);
+
+  heif_error (* decode_next_image2)(void* decoder, heif_image** out_img,
+                                    uintptr_t* out_user_data,
+                                    const heif_security_limits* limits);
+
   // --- Note: when adding new versions, also update `heif_decoder_plugin_latest_version`.
 } heif_decoder_plugin;
 
@@ -240,7 +280,27 @@ typedef struct heif_encoder_plugin
   void (* query_encoded_size)(void* encoder, uint32_t input_width, uint32_t input_height,
                               uint32_t* encoded_width, uint32_t* encoded_height);
 
-  // --- version 4 functions will follow below ... ---
+  // --- version 4 ---
+
+  uint32_t minimum_required_libheif_version;
+
+  heif_error (* start_sequence_encoding)(void* encoder, const heif_image* image,
+                                         enum heif_image_input_class image_class,
+                                         uint32_t framerate_num, uint32_t framerate_denom,
+                                         const heif_sequence_encoding_options* options);
+  // TODO: is heif_sequence_encoding_options a good choice here?
+
+  heif_error (* encode_sequence_frame)(void* encoder, const heif_image* image, uintptr_t frame_nr);
+
+  heif_error (* end_sequence_encoding)(void* encoder);
+
+  heif_error (* get_compressed_data2)(void* encoder, uint8_t** data, int* size,
+                                      uintptr_t* frame_nr,
+                                      int* is_keyframe, int* more_frame_packets);
+
+  int does_indicate_keyframes;
+
+  // --- version 5 functions will follow below ... ---
 
   // --- Note: when adding new versions, also update `heif_encoder_plugin_latest_version`.
 } heif_encoder_plugin;

package/include/libheif/heif_properties.h

@@ -40,7 +40,8 @@ enum heif_item_property_type
   heif_item_property_type_image_size = heif_fourcc('i', 's', 'p', 'e'),
   heif_item_property_type_uuid = heif_fourcc('u', 'u', 'i', 'd'),
   heif_item_property_type_tai_clock_info = heif_fourcc('t', 'a', 'i', 'c'),
-  heif_item_property_type_tai_timestamp = heif_fourcc('i', 't', 'a', 'i')
+  heif_item_property_type_tai_timestamp = heif_fourcc('i', 't', 'a', 'i'),
+  heif_item_property_type_extended_language = heif_fourcc('e', 'l', 'n', 'g')
 };
 
 // Get the heif_property_id for a heif_item_id.
@@ -112,6 +113,7 @@ enum heif_transform_mirror_direction
 };
 
 // Will return 'heif_transform_mirror_direction_invalid' in case of error.
+// If 'propertyId==0', it returns the first imir property found.
 LIBHEIF_API
 enum heif_transform_mirror_direction heif_item_get_property_transform_mirror(const heif_context* context,
                                                                              heif_item_id itemId,
@@ -119,6 +121,7 @@ enum heif_transform_mirror_direction heif_item_get_property_transform_mirror(con
 
 // Returns only 0, 90, 180, or 270 angle values.
 // Returns -1 in case of error (but it will only return an error in case of wrong usage).
+// If 'propertyId==0', it returns the first irot property found.
 LIBHEIF_API
 int heif_item_get_property_transform_rotation_ccw(const heif_context* context,
                                                   heif_item_id itemId,
@@ -127,6 +130,7 @@ int heif_item_get_property_transform_rotation_ccw(const heif_context* context,
 // Returns the number of pixels that should be removed from the four edges.
 // Because of the way this data is stored, you have to pass the image size at the moment of the crop operation
 // to compute the cropped border sizes.
+// If 'propertyId==0', it returns the first clap property found.
 LIBHEIF_API
 void heif_item_get_property_transform_crop_borders(const heif_context* context,
                                                    heif_item_id itemId,

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" {

package/include/libheif/heif_security.h

@@ -63,6 +63,11 @@ typedef struct heif_security_limits
   uint64_t max_total_memory;
   uint32_t max_sample_description_box_entries;
   uint32_t max_sample_group_description_box_entries;
+
+  // --- version 3
+
+  uint32_t max_sequence_frames;
+  uint32_t max_number_of_file_brands;
 } heif_security_limits;
 
 

package/include/libheif/heif_sequences.h

@@ -115,6 +115,7 @@ 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')
 };
 
@@ -128,6 +129,22 @@ enum heif_track_type_4cc
 LIBHEIF_API
 heif_track_type heif_track_get_track_handler_type(const heif_track*);
 
+
+enum heif_auxiliary_track_info_type
+{
+  heif_auxiliary_track_info_type_unknown = 0,
+  heif_auxiliary_track_info_type_alpha = 1
+};
+
+LIBHEIF_API
+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.
@@ -189,7 +206,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,6 +263,12 @@ 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.
@@ -288,6 +312,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 +338,20 @@ 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.
+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
+};
+
+
 typedef struct heif_sequence_encoding_options
 {
   uint8_t version;
@@ -324,8 +363,17 @@ 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;
 } heif_sequence_encoding_options;
 
+
 LIBHEIF_API
 heif_sequence_encoding_options* heif_sequence_encoding_options_alloc(void);
 
@@ -362,6 +410,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 +420,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*,

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_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) | (21<<16) | (1<<8) | 0)
 
 /* Version string */
-#define LIBHEIF_VERSION "1.20.2"
+#define LIBHEIF_VERSION "1.21.1"
 
 #define LIBHEIF_PLUGIN_DIRECTORY "/target/lib/libheif"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@img/sharp-libvips-dev",
-  "version": "1.3.0-rc.0",
+  "version": "1.3.0-rc.2",
   "description": "Header files and C++ sources for libvips and dependencies required when compiling sharp from source",
   "author": "Lovell Fuller <npm@lovell.info>",
   "homepage": "https://sharp.pixelplumbing.com",

package/versions.json

@@ -9,9 +9,9 @@
   "fontconfig": "2.17.1",
   "freetype": "2.14.1",
   "fribidi": "1.0.16",
-  "glib": "2.87.0",
-  "harfbuzz": "12.2.0",
-  "heif": "1.20.2",
+  "glib": "2.87.1",
+  "harfbuzz": "12.3.0",
+  "heif": "1.21.1",
   "highway": "1.3.0",
   "imagequant": "2.4.1",
   "lcms": "2.17",
@@ -23,7 +23,7 @@
   "rsvg": "2.61.3",
   "tiff": "4.7.1",
   "uhdr": "1.4.0",
-  "vips": "8.18.0-rc2",
+  "vips": "8.18.0",
   "webp": "1.6.0",
   "xml2": "2.15.1",
   "zlib-ng": "2.3.2"