pylibheif 1.21.2__cp312-cp312-macosx_14_0_arm64.whl

include/libheif/heif_tai_timestamps.h

@@ -0,0 +1,202 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2025 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_TAI_TIMESTAMPS_H
+#define LIBHEIF_HEIF_TAI_TIMESTAMPS_H
+
+#include <libheif/heif.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct heif_tai_clock_info
+{
+  uint8_t version;
+
+  // --- version 1
+
+  // Standard deviation for timestamp generation process.
+  // May be `heif_tai_clock_info_time_uncertainty_unknown` if unknown.
+  uint64_t time_uncertainty;
+
+  // Receptor clock resolution in nanoseconds.
+  uint32_t clock_resolution;
+
+  // Clock drift rate in picoseconds/second when synchronization is stopped.
+  // Maybe `heif_tai_clock_info_clock_drift_rate_unknown` if unknown.
+  int32_t clock_drift_rate;
+
+  // Whether clock is synchronized to an atomic source,
+  // see the clock_type defines below.
+  uint8_t clock_type;
+} heif_tai_clock_info;
+
+#define heif_tai_clock_info_time_uncertainty_unknown UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define heif_tai_clock_info_clock_drift_rate_unknown INT32_C(0x7FFFFFFF)
+#define heif_tai_clock_info_clock_type_unknown 0
+#define heif_tai_clock_info_clock_type_not_synchronized_to_atomic_source 1
+#define heif_tai_clock_info_clock_type_synchronized_to_atomic_source 2
+
+
+/**
+ * Allocate a new heif_tai_clock_info object and initialize with default values.
+ */
+LIBHEIF_API
+heif_tai_clock_info* heif_tai_clock_info_alloc(void);
+
+/**
+ * Copies the source object into the destination object.
+ * Only the fields that are present in both objects are copied.
+ * The version property has to be set in both structs.
+ */
+LIBHEIF_API
+void heif_tai_clock_info_copy(heif_tai_clock_info* dst, const heif_tai_clock_info* src);
+
+LIBHEIF_API
+void heif_tai_clock_info_release(heif_tai_clock_info* clock_info);
+
+
+typedef struct heif_tai_timestamp_packet
+{
+  uint8_t version;
+
+  // --- version 1
+
+  // number of nanoseconds since TAI epoch (1958-01-01T00:00:00.0)
+  uint64_t tai_timestamp;
+
+  // whether the remote and receiptor clocks are in sync
+  uint8_t synchronization_state;         // bool
+
+  // whether the receptor clock failed to generate a timestamp
+  uint8_t timestamp_generation_failure;  // bool
+
+  // whether the original clock value has been modified
+  uint8_t timestamp_is_modified;         // bool
+} heif_tai_timestamp_packet;
+
+/**
+ * Allocate a new heif_tai_timestamp_packet object and initialize with default values.
+ */
+LIBHEIF_API
+heif_tai_timestamp_packet* heif_tai_timestamp_packet_alloc(void);
+
+/**
+ * Copies the source object into the destination object.
+ * Only the fields that are present in both objects are copied.
+ * The version property has to be set in both structs.
+ */
+LIBHEIF_API
+void heif_tai_timestamp_packet_copy(heif_tai_timestamp_packet* dst, const heif_tai_timestamp_packet* src);
+
+LIBHEIF_API
+void heif_tai_timestamp_packet_release(heif_tai_timestamp_packet*);
+
+
+
+/**
+ * Creates a new clock info property if it doesn't exist yet.
+ * You can only add one tai_clock_info to an image.
+ *
+ * @param clock_info The TAI clock info to set for the item. This object will be copied.
+ * @param out_optional_propertyId Output parameter for the property ID of the tai_clock_info.
+ *                                This parameter may be NULL if the info is not required.
+ */
+LIBHEIF_API
+heif_error heif_item_set_property_tai_clock_info(heif_context* ctx,
+                                                 heif_item_id itemId,
+                                                 const heif_tai_clock_info* clock_info,
+                                                 heif_property_id* out_optional_propertyId);
+
+/**
+ * Get the heif_tai_clock_info attached to the item.
+ * This function allocates a new heif_tai_clock_info and returns it through out_clock.
+ *
+ * @param out_clock This parameter must not be nullptr. The object returned through this parameter must
+ *                  be released with heif_tai_clock_info_release().
+ *                  If no tai_clock_info property exists for the item, out_clock is set to NULL and
+ *                  no error is returned.
+ */
+LIBHEIF_API
+heif_error heif_item_get_property_tai_clock_info(const heif_context* ctx,
+                                                 heif_item_id itemId,
+                                                 heif_tai_clock_info** out_clock);
+
+
+/**
+ * Creates a new TAI timestamp property if it doesn't exist yet.
+ * You can only add one tai_timestamp to an image.
+ *
+ * @param timestamp The TAI timestamp to set for the item. This object will be copied.
+ * @param out_optional_propertyId Output parameter for the property ID of the TAI timestamp.
+ *                                This parameter may be NULL if the info is not required.
+ */
+LIBHEIF_API
+heif_error heif_item_set_property_tai_timestamp(heif_context* ctx,
+                                                heif_item_id itemId,
+                                                const heif_tai_timestamp_packet* timestamp,
+                                                heif_property_id* out_optional_propertyId);
+
+/**
+ * Get the heif_tai_timestamp_packet attached to the item.
+ * This function allocates a new heif_tai_timestamp_packet and returns it through out_timestamp.
+ *
+ * @param out_timestamp This parameter must not be NULL. The object returned through this parameter must
+ *                  be released with heif_tai_timestamp_packet_release().
+ *                  If no tai_timestamp_packet property exists for the item, *out_timestamp is set to NULL and
+ *                  no error is returned.
+ */
+LIBHEIF_API
+heif_error heif_item_get_property_tai_timestamp(const heif_context* ctx,
+                                                heif_item_id itemId,
+                                                heif_tai_timestamp_packet** out_timestamp);
+
+/**
+ * Attach a TAI timestamp to the image.
+ * The main use of this function is for image sequences, but it can also be used for still images.
+ * If used for still images, note that you also have to set the heif_tai_clock_info to the image item
+ * through heif_item_set_property_tai_clock_info().
+ *
+ * @param timestamp The TAI timestamp to set to the image. This object will be copied.
+ */
+LIBHEIF_API
+heif_error heif_image_set_tai_timestamp(heif_image* img,
+                                        const heif_tai_timestamp_packet* timestamp);
+
+/**
+ * Get the heif_tai_timestamp_packet attached to the image.
+ * The main use of this function is for image sequences, but it can also be used for still images.
+ * This function allocates a new heif_tai_timestamp_packet and returns it through out_timestamp.
+ *
+ * @param out_timestamp This parameter must not be NULL. The object returned through this parameter must
+ *                  be released with heif_tai_timestamp_packet_release().
+ *                  If no tai_timestamp_packet property exists for the image, *out_timestamp is set to NULL and
+ *                  no error is returned.
+ */
+LIBHEIF_API
+heif_error heif_image_get_tai_timestamp(const heif_image* img,
+                                        heif_tai_timestamp_packet** out_timestamp);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //LIBHEIF_HEIF_TAI_TIMESTAMPS_H

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

include/libheif/heif_tiling.h

@@ -0,0 +1,137 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2025 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_TILING_H
+#define LIBHEIF_HEIF_TILING_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libheif/heif_library.h>
+#include <libheif/heif_error.h>
+#include <libheif/heif_image.h>
+
+// forward declaration from other headers
+typedef struct heif_encoder heif_encoder;
+typedef struct heif_encoding_options heif_encoding_options;
+
+
+typedef struct heif_image_tiling
+{
+  int version;
+
+  // --- version 1
+
+  uint32_t num_columns;
+  uint32_t num_rows;
+  uint32_t tile_width;
+  uint32_t tile_height;
+
+  uint32_t image_width;
+  uint32_t image_height;
+
+  // Position of the top left tile.
+  // Usually, this is (0;0), but if a tiled image is rotated or cropped, it may be that the top left tile should be placed at a negative position.
+  // The offsets define this negative shift.
+  uint32_t top_offset;
+  uint32_t left_offset;
+
+  uint8_t number_of_extra_dimensions;  // 0 for normal images, 1 for volumetric (3D), ...
+  uint32_t extra_dimension_size[8];    // size of extra dimensions (first 8 dimensions)
+} heif_image_tiling;
+
+
+// --- decoding ---
+
+// If 'process_image_transformations' is true, this returns modified sizes.
+// If it is false, the top_offset and left_offset will always be (0;0).
+LIBHEIF_API
+heif_error heif_image_handle_get_image_tiling(const heif_image_handle* handle, int process_image_transformations, struct heif_image_tiling* out_tiling);
+
+
+// For grid images, return the image item ID of a specific grid tile.
+// If 'process_image_transformations' is true, the tile positions are given in the transformed image coordinate system and
+// are internally mapped to the original image tile positions.
+LIBHEIF_API
+heif_error heif_image_handle_get_grid_image_tile_id(const heif_image_handle* handle,
+                                                    int process_image_transformations,
+                                                    uint32_t tile_x, uint32_t tile_y,
+                                                    heif_item_id* out_tile_item_id);
+
+
+typedef struct heif_decoding_options heif_decoding_options;
+
+// The tile position is given in tile indices, not in pixel coordinates.
+// If the image transformations are processed (option->ignore_image_transformations==false), the tile position
+// is given in the transformed coordinates.
+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,
+                                               const heif_decoding_options* options,
+                                               uint32_t tile_x, uint32_t tile_y);
+
+
+// --- encoding ---
+
+/**
+ * @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
+heif_error heif_context_encode_grid(heif_context* ctx,
+                                    heif_image** tiles,
+                                    uint16_t rows,
+                                    uint16_t columns,
+                                    heif_encoder* encoder,
+                                    const heif_encoding_options* input_options,
+                                    heif_image_handle** out_image_handle);
+
+LIBHEIF_API
+heif_error heif_context_add_grid_image(heif_context* ctx,
+                                       uint32_t image_width,
+                                       uint32_t image_height,
+                                       uint32_t tile_columns,
+                                       uint32_t tile_rows,
+                                       const heif_encoding_options* encoding_options,
+                                       heif_image_handle** out_grid_image_handle);
+
+LIBHEIF_API
+heif_error heif_context_add_image_tile(heif_context* ctx,
+                                       heif_image_handle* tiled_image,
+                                       uint32_t tile_x, uint32_t tile_y,
+                                       const heif_image* image,
+                                       heif_encoder* encoder);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/libheif/heif_uncompressed.h

@@ -0,0 +1,109 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024-2025 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_UNCOMPRESSED_H
+#define LIBHEIF_HEIF_UNCOMPRESSED_H
+
+#include "libheif/heif.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* @file heif_uncompressed.h
+ * @brief Functions for adding ISO 23001-17 (uncompressed) images to a HEIF file.
+ *        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.
+ */
+
+// --- 'unci' 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.
+typedef enum heif_unci_compression
+{
+  heif_unci_compression_off = 0,
+  //heif_unci_compression_auto = 1,
+  //heif_unci_compression_unknown = 2, // only used when reading unknown method from input file
+  heif_unci_compression_deflate = 3,
+  heif_unci_compression_zlib = 4,
+  heif_unci_compression_brotli = 5
+} heif_unci_compression;
+
+
+typedef struct heif_unci_image_parameters
+{
+  int version;
+
+  // --- version 1
+
+  uint32_t image_width;
+  uint32_t image_height;
+
+  uint32_t tile_width;
+  uint32_t tile_height;
+
+  enum heif_unci_compression compression;
+
+  // TODO: interleave type, padding
+} heif_unci_image_parameters;
+
+LIBHEIF_API
+heif_unci_image_parameters* heif_unci_image_parameters_alloc(void);
+
+LIBHEIF_API
+void heif_unci_image_parameters_copy(heif_unci_image_parameters* dst,
+                                     const heif_unci_image_parameters* src);
+
+LIBHEIF_API
+void heif_unci_image_parameters_release(heif_unci_image_parameters*);
+
+
+/*
+ * This adds an empty iso23001-17 (uncompressed) image to the HEIF file.
+ * The actual image data is added later using heif_context_add_image_tile().
+ * If you do not need tiling, you can use heif_context_encode_image() instead.
+ * However, this will by default disable any compression and any control about
+ * the data layout.
+ *
+ * @param ctx The file context
+ * @param parameters The parameters for the image, must not be NULL.
+ * @param encoding_options Optional, may be NULL.
+ * @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.
+ * @param out_unci_image_handle Returns a handle to the image. The caller is responsible for freeing it.
+ *                  Must not be NULL because this is required to fill in image data.
+ * @return Returns an error if the passed parameters are incorrect.
+ *         If ISO23001-17 images are not supported, returns heif_error_Unsupported_feature.
+ */
+LIBHEIF_API
+heif_error heif_context_add_empty_unci_image(heif_context* ctx,
+                                             const heif_unci_image_parameters* parameters,
+                                             const heif_encoding_options* encoding_options,
+                                             const heif_image* prototype,
+                                             heif_image_handle** out_unci_image_handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/libheif/heif_version.h

@@ -0,0 +1,38 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 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/>.
+ */
+
+/* heif_version.h
+ *
+ * This file was automatically generated when libheif was built.
+ *
+ * DO NOT EDIT THIS FILE.
+ */
+#ifndef LIBHEIF_HEIF_VERSION_H
+#define LIBHEIF_HEIF_VERSION_H
+
+/* Numeric representation of the version */
+#define LIBHEIF_NUMERIC_VERSION ((1<<24) | (21<<16) | (2<<8) | 0)
+
+/* Version string */
+#define LIBHEIF_VERSION "1.21.2"
+
+#define LIBHEIF_PLUGIN_DIRECTORY "/var/folders/xx/pgt1mtfn3xx3hdys7czt35bh0000gn/T/tmpcsjdgqu7/wheel/platlib/lib/libheif"
+
+#endif  // LIBHEIF_HEIF_VERSION_H

lib/cmake/libheif/libheif-config-release.cmake

@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "heif" for configuration "Release"
+set_property(TARGET heif APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(heif PROPERTIES
+  IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libheif.a"
+  )
+
+list(APPEND _cmake_import_check_targets heif )
+list(APPEND _cmake_import_check_files_for_heif "${_IMPORT_PREFIX}/lib/libheif.a" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)