@img/sharp-libvips-dev 1.0.2 → 1.0.3

package/include/hwy/targets.h

@@ -29,7 +29,7 @@
 #include "hwy/detect_targets.h"
 #include "hwy/highway_export.h"
 
-#if !HWY_ARCH_RVV && !defined(HWY_NO_LIBCXX)
+#if !defined(HWY_NO_LIBCXX)
 #include <atomic>
 #endif
 
@@ -112,6 +112,8 @@ static inline HWY_MAYBE_UNUSED const char* TargetName(int64_t target) {
       return "SVE2";
     case HWY_SVE:
       return "SVE";
+    case HWY_NEON_BF16:
+      return "NEON_BF16";
     case HWY_NEON:
       return "NEON";
     case HWY_NEON_WITHOUT_AES:
@@ -141,7 +143,7 @@ static inline HWY_MAYBE_UNUSED const char* TargetName(int64_t target) {
       return "WASM_EMU256";
 #endif
 
-#if HWY_ARCH_RVV
+#if HWY_ARCH_RISCV
     case HWY_RVV:
       return "RVV";
 #endif
@@ -220,24 +222,24 @@ static inline HWY_MAYBE_UNUSED const char* TargetName(int64_t target) {
 // See HWY_ARCH_X86 above for details.
 #define HWY_MAX_DYNAMIC_TARGETS 15
 #define HWY_HIGHEST_TARGET_BIT HWY_HIGHEST_TARGET_BIT_ARM
-#define HWY_CHOOSE_TARGET_LIST(func_name)                       \
-  nullptr,                                   /* reserved */     \
-      nullptr,                               /* reserved */     \
-      nullptr,                               /* reserved */     \
-      nullptr,                               /* reserved */     \
-      nullptr,                               /* reserved */     \
-      nullptr,                               /* reserved */     \
-      nullptr,                               /* reserved */     \
-      nullptr,                               /* reserved */     \
-      nullptr,                               /* reserved */     \
-      HWY_CHOOSE_SVE2_128(func_name),        /* SVE2 128-bit */ \
-      HWY_CHOOSE_SVE_256(func_name),         /* SVE 256-bit */  \
-      HWY_CHOOSE_SVE2(func_name),            /* SVE2 */         \
-      HWY_CHOOSE_SVE(func_name),             /* SVE */          \
-      HWY_CHOOSE_NEON(func_name),            /* NEON */         \
+#define HWY_CHOOSE_TARGET_LIST(func_name)                              \
+  nullptr,                                   /* reserved */            \
+      nullptr,                               /* reserved */            \
+      nullptr,                               /* reserved */            \
+      HWY_CHOOSE_SVE2_128(func_name),        /* SVE2 128-bit */        \
+      HWY_CHOOSE_SVE_256(func_name),         /* SVE 256-bit */         \
+      nullptr,                               /* reserved */            \
+      nullptr,                               /* reserved */            \
+      nullptr,                               /* reserved */            \
+      HWY_CHOOSE_SVE2(func_name),            /* SVE2 */                \
+      HWY_CHOOSE_SVE(func_name),             /* SVE */                 \
+      nullptr,                               /* reserved */            \
+      HWY_CHOOSE_NEON_BF16(func_name),       /* NEON + f16/dot/bf16 */ \
+      nullptr,                               /* reserved */            \
+      HWY_CHOOSE_NEON(func_name),            /* NEON */                \
       HWY_CHOOSE_NEON_WITHOUT_AES(func_name) /* NEON without AES */
 
-#elif HWY_ARCH_RVV
+#elif HWY_ARCH_RISCV
 // See HWY_ARCH_X86 above for details.
 #define HWY_MAX_DYNAMIC_TARGETS 9
 #define HWY_HIGHEST_TARGET_BIT HWY_HIGHEST_TARGET_BIT_RVV
@@ -323,8 +325,7 @@ struct ChosenTarget {
   }
 
  private:
-  // TODO(janwas): remove RVV once <atomic> is available
-#if HWY_ARCH_RVV || defined(HWY_NO_LIBCXX)
+#if defined(HWY_NO_LIBCXX)
   int64_t LoadMask() const { return mask_; }
   void StoreMask(int64_t mask) { mask_ = mask; }
 
@@ -334,7 +335,7 @@ struct ChosenTarget {
   void StoreMask(int64_t mask) { mask_.store(mask); }
 
   std::atomic<int64_t> mask_{1};  // Initialized to 1 so GetIndex() returns 0.
-#endif  // HWY_ARCH_RVV
+#endif  // HWY_ARCH_RISCV
 };
 
 // For internal use (e.g. by FunctionCache and DisableTargets).

package/include/hwy/timer-inl.h

@@ -24,7 +24,6 @@
 #endif
 
 #include "hwy/highway.h"
-#include "hwy/timer.h"
 
 #if defined(_WIN32) || defined(_WIN64)
 #ifndef NOMINMAX
@@ -50,6 +49,7 @@
 #include <intrin.h>
 #endif
 
+#include <stdint.h>
 #include <time.h>  // clock_gettime
 
 HWY_BEFORE_NAMESPACE();
@@ -139,8 +139,8 @@ inline Ticks Start() {
       // "memory" avoids reordering. rdx = TSC >> 32.
       // "cc" = flags modified by SHL.
       : "rdx", "memory", "cc");
-#elif HWY_ARCH_RVV
-  asm volatile("rdtime %0" : "=r"(t));
+#elif HWY_ARCH_RISCV
+  asm volatile("fence; rdtime %0" : "=r"(t));
 #elif defined(_WIN32) || defined(_WIN64)
   LARGE_INTEGER counter;
   (void)QueryPerformanceCounter(&counter);

package/include/hwy/timer.h

@@ -36,7 +36,7 @@ HWY_DLLEXPORT double Now();
 
 // Returns whether it is safe to call timer::Stop without executing an illegal
 // instruction; if false, fills cpu100 (a pointer to a 100 character buffer)
-// with the CPU brand string or an empty string if unknown.
+// via GetCpuString().
 HWY_DLLEXPORT bool HaveTimerStop(char* cpu100);
 
 // Returns tick rate, useful for converting timer::Ticks to seconds. Invariant
@@ -49,6 +49,10 @@ HWY_DLLEXPORT double InvariantTicksPerSecond();
 // This call is expensive, callers should cache the result.
 HWY_DLLEXPORT uint64_t TimerResolution();
 
+// Returns false if no detailed description is available, otherwise fills
+// `cpu100` with up to 100 characters (including \0) identifying the CPU model.
+HWY_DLLEXPORT bool GetCpuString(char* cpu100);
+
 }  // namespace platform
 
 struct Timestamp {

package/include/libheif/heif.h

@@ -229,6 +229,23 @@ enum heif_suberror_code
   // Invalid specification of region item
   heif_suberror_Invalid_region_data = 136,
 
+  // Image has no ispe property
+  heif_suberror_No_ispe_property = 137,
+
+  heif_suberror_Camera_intrinsic_matrix_undefined = 138,
+
+  heif_suberror_Camera_extrinsic_matrix_undefined = 139,
+
+  // Invalid JPEG 2000 codestream - usually a missing marker
+  heif_suberror_Invalid_J2K_codestream = 140,
+
+  heif_suberror_No_vvcC_box = 141,
+
+  // icbr is only needed in some situations, this error is for those cases
+  heif_suberror_No_icbr_box = 142,
+
+  // Decompressing generic compression or header compression data failed (e.g. bitstream corruption)
+  heif_suberror_Decompression_invalid_data = 150,
 
   // --- Memory_allocation_error ---
 
@@ -237,6 +254,9 @@ enum heif_suberror_code
   // security limits further.
   heif_suberror_Security_limit_exceeded = 1000,
 
+  // There was an error from the underlying compression / decompression library.
+  // One possibility is lack of resources (e.g. memory).
+  heif_suberror_Compression_initialisation_error = 1001,
 
   // --- Usage_error ---
 
@@ -285,6 +305,8 @@ enum heif_suberror_code
 
   heif_suberror_Unsupported_header_compression_method = 3005,
 
+  // Generically compressed data used an unsupported compression method
+  heif_suberror_Unsupported_generic_compression_method = 3006,
 
   // --- Encoder_plugin_error ---
 
@@ -304,9 +326,10 @@ enum heif_suberror_code
 
   // --- Plugin loading error ---
 
-  heif_suberror_Plugin_loading_error = 6000,        // a specific plugin file cannot be loaded
-  heif_suberror_Plugin_is_not_loaded = 6001,        // trying to remove a plugin that is not loaded
-  heif_suberror_Cannot_read_plugin_directory = 6002 // error while scanning the directory for plugins
+  heif_suberror_Plugin_loading_error = 6000,         // a specific plugin file cannot be loaded
+  heif_suberror_Plugin_is_not_loaded = 6001,         // trying to remove a plugin that is not loaded
+  heif_suberror_Cannot_read_plugin_directory = 6002, // error while scanning the directory for plugins
+  heif_suberror_No_matching_decoder_installed = 6003 // no decoder found for that compression format
 };
 
 
@@ -408,7 +431,14 @@ enum heif_compression_format
    *
    * See ISO/IEC 23008-12:2022 Section 6.10.2
    */
-  heif_compression_mask = 9
+  heif_compression_mask = 9,
+  /**
+   * High Throughput JPEG 2000 (HT-J2K) compression.
+   *
+   * The encapsulation of HT-J2K is specified in ISO/IEC 15444-16:2021.
+   * The core encoding is defined in ISO/IEC 15444-15, or ITU-T T.814.
+  */
+  heif_compression_HTJ2K = 10
 };
 
 enum heif_chroma
@@ -564,6 +594,18 @@ enum heif_filetype_result
 LIBHEIF_API
 enum heif_filetype_result heif_check_filetype(const uint8_t* data, int len);
 
+/**
+ * Check the filetype box content for a supported file type.
+ *
+ * <p>The data is assumed to start from the start of the `ftyp` box.
+ *
+ * <p>This function checks the compatible brands.
+ * 
+ * @returns heif_error_ok if a supported brand is found, or other error if not.
+ */
+LIBHEIF_API
+struct heif_error heif_has_compatible_filetype(const uint8_t* data, int len);
+
 LIBHEIF_API
 int heif_check_jpeg_filetype(const uint8_t* data, int len);
 
@@ -1368,6 +1410,44 @@ struct heif_error heif_image_get_nclx_color_profile(const struct heif_image* ima
                                                     struct heif_color_profile_nclx** out_data);
 
 
+// ------------------------- intrinsic and extrinsic matrices -------------------------
+
+struct heif_camera_intrinsic_matrix
+{
+  double focal_length_x;
+  double focal_length_y;
+  double principal_point_x;
+  double principal_point_y;
+  double skew;
+};
+
+
+LIBHEIF_API
+int heif_image_handle_has_camera_intrinsic_matrix(const struct heif_image_handle* handle);
+
+LIBHEIF_API
+struct heif_error heif_image_handle_get_camera_intrinsic_matrix(const struct heif_image_handle* handle,
+                                                                struct heif_camera_intrinsic_matrix* out_matrix);
+
+
+struct heif_camera_extrinsic_matrix;
+
+LIBHEIF_API
+int heif_image_handle_has_camera_extrinsic_matrix(const struct heif_image_handle* handle);
+
+LIBHEIF_API
+struct heif_error heif_image_handle_get_camera_extrinsic_matrix(const struct heif_image_handle* handle,
+                                                                struct heif_camera_extrinsic_matrix** out_matrix);
+
+LIBHEIF_API
+void heif_camera_extrinsic_matrix_release(struct heif_camera_extrinsic_matrix*);
+
+LIBHEIF_API
+struct heif_error heif_camera_extrinsic_matrix_get_rotation_matrix(const struct heif_camera_extrinsic_matrix*,
+                                                                   double* out_matrix_row_major);
+
+
+
 // ========================= heif_image =========================
 
 // An heif_image contains a decoded pixel image in various colorspaces, chroma formats,
@@ -1711,6 +1791,10 @@ struct heif_error heif_context_write(struct heif_context*,
                                      struct heif_writer* writer,
                                      void* userdata);
 
+// Add a compatible brand that is now added automatically by libheif when encoding images (e.g. some application brands like 'geo1').
+LIBHEIF_API
+void heif_context_add_compatible_brand(struct heif_context* ctx,
+                                       heif_brand2 compatible_brand);
 
 // ----- encoder -----
 
@@ -2016,6 +2100,11 @@ struct heif_encoding_options
   // version 6 options
 
   struct heif_color_conversion_options color_conversion_options;
+
+  // version 7 options
+
+  // Set this to true to use compressed form of uncC where possible
+  uint8_t prefer_uncC_short_form;
 };
 
 LIBHEIF_API
@@ -2037,6 +2126,27 @@ struct heif_error heif_context_encode_image(struct heif_context*,
                                             const struct heif_encoding_options* options,
                                             struct heif_image_handle** out_image_handle);
 
+/**
+ * @brief Encodes an array of images into a grid.
+ * 
+ * @param ctx The file context
+ * @param tiles User allocated array of images that will form the grid.
+ * @param rows The number of rows in the grid.
+ * @param columns The number of columns in the grid.
+ * @param encoder Defines the encoder to use. See heif_context_get_encoder_for_format()
+ * @param input_options Optional, may be nullptr.
+ * @param out_image_handle Returns a handle to the grid. The caller is responsible for freeing it.
+ * @return Returns an error if ctx, tiles, or encoder is nullptr. If rows or columns is 0. 
+ */
+LIBHEIF_API
+struct heif_error heif_context_encode_grid(struct heif_context* ctx,
+                                           struct heif_image** tiles,
+                                           uint16_t rows,
+                                           uint16_t columns,
+                                           struct heif_encoder* encoder,
+                                           const struct heif_encoding_options* input_options,
+                                           struct heif_image_handle** out_image_handle);
+
 LIBHEIF_API
 struct heif_error heif_context_set_primary_image(struct heif_context*,
                                                  struct heif_image_handle* image_handle);
@@ -2059,9 +2169,12 @@ struct heif_error heif_context_encode_thumbnail(struct heif_context*,
 
 enum heif_metadata_compression
 {
-  heif_metadata_compression_off,
-  heif_metadata_compression_auto,
-  heif_metadata_compression_deflate
+  heif_metadata_compression_off = 0,
+  heif_metadata_compression_auto = 1,
+  heif_metadata_compression_unknown = 2, // only used when reading unknown method from input file
+  heif_metadata_compression_deflate = 3,
+  heif_metadata_compression_zlib = 4,    // do not use for header data
+  heif_metadata_compression_brotli = 5
 };
 
 // Assign 'thumbnail_image' as the thumbnail image of 'master_image'.
@@ -2099,22 +2212,64 @@ struct heif_error heif_context_add_generic_metadata(struct heif_context* ctx,
                                                     const void* data, int size,
                                                     const char* item_type, const char* content_type);
 
+// Add generic metadata with item_type "uri ". Items with this type do not have a content_type, but
+// an item_uri_type and they have no content_encoding (they are always stored uncompressed).
+LIBHEIF_API
+struct heif_error heif_context_add_generic_uri_metadata(struct heif_context* ctx,
+                                                    const struct heif_image_handle* image_handle,
+                                                    const void* data, int size,
+                                                    const char* item_uri_type,
+                                                    heif_item_id* out_item_id);
+
 // --- heif_image allocation
 
-// Create a new image of the specified resolution and colorspace.
-// Note: no memory for the actual image data is reserved yet. You have to use
-// heif_image_add_plane() to add the image planes required by your colorspace/chroma.
+/**
+ * Create a new image of the specified resolution and colorspace.
+ *
+ * <p>This does not allocate memory for the image data. Use {@link heif_image_add_plane} to
+ * add the corresponding planes to match the specified {@code colorspace} and {@code chroma}.
+ *
+ * @param width the width of the image in pixels
+ * @param height the height of the image in pixels
+ * @param colorspace the colorspace of the image
+ * @param chroma the chroma of the image
+ * @param out_image pointer to pointer of the resulting image
+ * @return whether the creation succeeded or there was an error
+*/
 LIBHEIF_API
 struct heif_error heif_image_create(int width, int height,
                                     enum heif_colorspace colorspace,
                                     enum heif_chroma chroma,
                                     struct heif_image** out_image);
 
-// The indicated bit_depth corresponds to the bit depth per channel.
-// I.e. for interleaved formats like RRGGBB, the bit_depth would be, e.g., 10 bit instead
-// of 30 bits or 3*16=48 bits.
-// For backward compatibility, one can also specify 24bits for RGB and 32bits for RGBA,
-// instead of the preferred 8 bits.
+/**
+ * Add an image plane to the image.
+ *
+ * <p>The image plane needs to match the colorspace and chroma of the image. Note
+ * that this does not need to be a single "planar" format - interleaved pixel channels
+ * can also be used if the chroma is interleaved.
+ *
+ * <p>The indicated bit_depth corresponds to the bit depth per channel. For example,
+ * with an interleaved format like RRGGBB where each color is represented by 10 bits,
+ * the {@code bit_depth} would be {@code 10} rather than {@code 30}.
+ *
+ * <p>For backward compatibility, one can also specify 24bits for RGB and 32bits for RGBA,
+ * instead of the preferred 8 bits. However, this use is deprecated.
+ *
+ * @param image the parent image to add the channel plane to
+ * @param channel the channel of the plane to add
+ * @param width the width of the plane
+ * @param height the height of the plane
+ * @param bit_depth the bit depth per color channel
+ * @return whether the addition succeeded or there was an error
+ *
+ * @note The width and height are usually the same as the parent image, but can be
+ * less for subsampling.
+ *
+ * @note The specified width can differ from the row stride of the resulting image plane.
+ * Always use the result of {@link heif_image_get_plane} or {@link heif_image_get_plane_readonly}
+ * to determine row stride.
+ */
 LIBHEIF_API
 struct heif_error heif_image_add_plane(struct heif_image* image,
                                        enum heif_channel channel,

package/include/libheif/heif_items.h

@@ -0,0 +1,237 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 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_ITEMS_H
+#define LIBHEIF_HEIF_ITEMS_H
+
+#include "libheif/heif.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * Gets the number of items.
+ *
+ * This is not the same as the number of images, since there can be other types of items,
+ * such as metadata.
+ *
+ * @param ctx the file context
+ * @return the number of items
+ */
+LIBHEIF_API
+int heif_context_get_number_of_items(const struct heif_context* ctx);
+
+/**
+ * Get the item identifiers.
+ *
+ * Fills in the item IDs into the user-supplied array {@code ID_array}, preallocated with {@code count} entries.
+ *
+ * @param ctx the file context
+ * @param ID_array the output array.
+ * @param count the number of items allocated within {@code ID_array}.
+ * @return the total number of IDs filled into the array, which may be less than {@code count}.
+ */
+LIBHEIF_API
+int heif_context_get_list_of_item_IDs(const struct heif_context* ctx,
+                                      heif_item_id* ID_array,
+                                      int count);
+
+/**
+ * Gets the item type.
+ *
+ * Usually, this is a four character code (e.g. `mime` or `uri `), but it can theoretically be
+ * any 4-byte number. Thus, the type is returned as an integer. You can use {@link heif_fourcc} to map
+ * between the two representations.
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @return the item type
+ */
+LIBHEIF_API
+uint32_t heif_item_get_item_type(const struct heif_context* ctx, heif_item_id item_id);
+
+#define heif_item_type_mime   heif_fourcc('m','i','m','e')
+#define heif_item_type_uri    heif_fourcc('u','r','i',' ')
+
+LIBHEIF_API
+int heif_item_is_item_hidden(const struct heif_context* ctx, heif_item_id item_id);
+
+
+/**
+ * Gets the MIME content_type for an item.
+ *
+ * Only valid if the item type is `mime`.
+ * If the item does not exist, or if it is not a `mime` item, NULL is returned.
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @return the item content_type
+ */
+LIBHEIF_API
+const char* heif_item_get_mime_item_content_type(const struct heif_context* ctx, heif_item_id item_id);
+
+/**
+ * Gets the content_encoding for a MIME item.
+ *
+ * Only valid if the item type is `mime`.
+ * If the item does not exist, or if it is not a `mime` item, NULL is returned.
+ *
+ * If the item is not encoded, the returned value will be an empty string (not null).
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @return the item content_type
+ */
+LIBHEIF_API
+const char* heif_item_get_mime_item_content_encoding(const struct heif_context* ctx, heif_item_id item_id);
+
+/**
+ * Gets the item_uri_type for an item.
+ *
+ * Only valid if the item type is `uri `.
+ * If the item does not exist, or if it is not a `uri ` item, NULL is returned.
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @return the item item_uri_type
+ */
+LIBHEIF_API
+const char* heif_item_get_uri_item_uri_type(const struct heif_context* ctx, heif_item_id item_id);
+
+LIBHEIF_API
+const char* heif_item_get_item_name(const struct heif_context* ctx, heif_item_id item_id);
+
+LIBHEIF_API
+struct heif_error heif_item_set_item_name(struct heif_context* ctx,
+                                          heif_item_id item,
+                                          const char* item_name);
+
+
+/**
+ * Gets the raw metadata, as stored in the HEIF file.
+ *
+ * Data in a "mime" item with "content_encoding" can be compressed.
+ * When `out_compression_format` is NULL, the decompressed data will be returned.
+ * Otherwise, the compressed data is returned and `out_compression_format` will be filled with the
+ * compression format.
+ * If the compression method is not supported, an error will be returned.
+ *
+ * It is valid to set `out_data` to NULL. In that case, only the `out_data_size` is filled.
+ * Note that it is inefficient to use `out_data=NULL` just to get the size of compressed data.
+ * In general, this should be avoided.
+ *
+ * If there is no data assigned to the item or there is an error, `out_data_size` is set to zero.
+ *
+ * @param ctx the file context
+ * @param item_id the item identifier for the item
+ * @param out_compression_format how the data is compressed. If the pointer is NULL, the decompressed data will be returned.
+ * @param out_data the corresponding raw metadata
+ * @param out_data_size the size of the metadata in bytes
+ * @return whether the call succeeded, or there was an error
+ */
+LIBHEIF_API
+struct heif_error heif_item_get_item_data(const struct heif_context* ctx,
+                                          heif_item_id item_id,
+                                          heif_metadata_compression* out_compression_format,
+                                          uint8_t** out_data, size_t* out_data_size);
+
+/**
+ * Free the item data.
+ *
+ * This is used to free memory associated with the data returned by
+ * {@link heif_item_get_item_data} in 'out_data' and set the pointer to NULL.
+ *
+ * @param ctx the file context
+ * @param item_data the data to free
+ */
+LIBHEIF_API
+void heif_release_item_data(const struct heif_context* ctx, uint8_t** item_data);
+
+
+// ------------------------- item references -------------------------
+
+/**
+ * Get the item ids that reference the given item.
+ *
+ * @param ctx the file context.
+ * @param from_item_id the item identifier for the item.
+ * @param index the index of the reference to get.
+ * @param out_reference_type_4cc The 4cc of the reference. (e.g dimg, thmb, cdsc, or auxl)
+ * @param out_references_to the item references. Use {@link heif_release_item_references} to free the memory.
+ * @return the number of items that reference the given item. Returns 0 if the index exceeds the number of references.
+ */
+LIBHEIF_API
+size_t heif_context_get_item_references(const struct heif_context* ctx,
+                                        heif_item_id from_item_id,
+                                        int index,
+                                        uint32_t* out_reference_type_4cc,
+                                        heif_item_id** out_references_to);
+
+LIBHEIF_API
+void heif_release_item_references(const struct heif_context* ctx, heif_item_id** references);
+
+LIBHEIF_API
+struct heif_error heif_context_add_item_reference(struct heif_context* ctx,
+                                                  uint32_t reference_type,
+                                                  heif_item_id from_item,
+                                                  heif_item_id to_item);
+
+LIBHEIF_API
+struct heif_error heif_context_add_item_references(struct heif_context* ctx,
+                                                   uint32_t reference_type,
+                                                   heif_item_id from_item,
+                                                   const heif_item_id* to_item,
+                                                   int num_to_items);
+
+// ------------------------- adding new items -------------------------
+
+LIBHEIF_API
+struct heif_error heif_context_add_item(struct heif_context* ctx,
+                                        const char* item_type,
+                                        const void* data, int size,
+                                        heif_item_id* out_item_id);
+
+LIBHEIF_API
+struct heif_error heif_context_add_mime_item(struct heif_context* ctx,
+                                             const char* content_type,
+                                             heif_metadata_compression content_encoding,
+                                             const void* data, int size,
+                                             heif_item_id* out_item_id);
+
+LIBHEIF_API
+struct heif_error heif_context_add_precompressed_mime_item(struct heif_context* ctx,
+                                                           const char* content_type,
+                                                           const char* content_encoding,
+                                                           const void* data, int size,
+                                                           heif_item_id* out_item_id);
+
+LIBHEIF_API
+struct heif_error heif_context_add_uri_item(struct heif_context* ctx,
+                                            const char* item_uri_type,
+                                            const void* data, int size,
+                                            heif_item_id* out_item_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif