@img/sharp-libvips-dev-wasm32 1.3.0-rc.3 → 1.3.0-rc.5

package/include/expat.h

@@ -1082,7 +1082,7 @@ XML_SetReparseDeferralEnabled(XML_Parser parser, XML_Bool enabled);
 */
 #  define XML_MAJOR_VERSION 2
 #  define XML_MINOR_VERSION 7
-#  define XML_MICRO_VERSION 4
+#  define XML_MICRO_VERSION 5
 
 #  ifdef __cplusplus
 }

package/include/expat_config.h

@@ -80,7 +80,7 @@
 #define PACKAGE_NAME "expat"
 
 /* Define to the full name and version of this package. */
-#define PACKAGE_STRING "expat 2.7.4"
+#define PACKAGE_STRING "expat 2.7.5"
 
 /* Define to the one symbol short name of this package. */
 #define PACKAGE_TARNAME "expat"
@@ -89,7 +89,7 @@
 #define PACKAGE_URL ""
 
 /* Define to the version of this package. */
-#define PACKAGE_VERSION "2.7.4"
+#define PACKAGE_VERSION "2.7.5"
 
 /* Define to 1 if all of the C89 standard headers exist (not just the ones
    required in a freestanding environment). This macro is provided for
@@ -97,7 +97,7 @@
 #define STDC_HEADERS 1
 
 /* Version number of package */
-#define VERSION "2.7.4"
+#define VERSION "2.7.5"
 
 /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
    significant byte first (like Motorola and SPARC, unlike Intel). */

package/include/expat_external.h

@@ -12,7 +12,7 @@
    Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
    Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
    Copyright (c) 2016      Cristian Rodríguez <crrodriguez@opensuse.org>
-   Copyright (c) 2016-2025 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>
    Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
    Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
    Licensed under the MIT license:

package/include/glib-2.0/glib/gslice.h

@@ -45,21 +45,29 @@ GLIB_AVAILABLE_IN_ALL
 void     g_slice_free_chain_with_offset (gsize         block_size,
 					 gpointer      mem_chain,
 					 gsize         next_offset);
-#define  g_slice_new(type)      ((type*) g_slice_alloc (MAX (sizeof (type), 1)))
+
+#ifndef __GI_SCANNER__
+/* Private helper to give the allocation size for a struct — we want to
+ * guarantee non-empty allocations, so it returns a minimum of 1B. This is
+ * necessary because some compilers do allow empty (zero size) structs. */
+#define g_slice_alloc_size(type) (sizeof (type) > 0 ? sizeof (type) : 1)
+#endif
+
+#define  g_slice_new(type)      ((type*) g_slice_alloc (g_slice_alloc_size (type)))
 
 /* Allow the compiler to inline memset(). Since the size is a constant, this
  * can significantly improve performance. */
 #if defined (__GNUC__) && (__GNUC__ >= 2) && defined (__OPTIMIZE__)
 #  define g_slice_new0(type)                                    \
   (type *) (G_GNUC_EXTENSION ({                                 \
-    gsize __s = MAX (sizeof (type), 1);                         \
+    gsize __s = g_slice_alloc_size (type);                      \
     gpointer __p;                                               \
     __p = g_slice_alloc (__s);                                  \
     memset (__p, 0, __s);                                       \
     __p;                                                        \
   }))
 #else
-#  define g_slice_new0(type)    ((type*) g_slice_alloc0 (MAX (sizeof (type), 1)))
+#  define g_slice_new0(type)    ((type*) g_slice_alloc0 (g_slice_alloc_size (type)))
 #endif
 
 /* MemoryBlockType *
@@ -76,7 +84,7 @@ void     g_slice_free_chain_with_offset (gsize         block_size,
 
 /* we go through extra hoops to ensure type safety */
 #define g_slice_dup(type, mem)                                  \
-  (1 ? (type*) g_slice_copy (MAX (sizeof (type), 1), (mem))     \
+  (1 ? (type*) g_slice_copy (g_slice_alloc_size (type), (mem))     \
      : ((void) ((type*) 0 == (mem)), (type*) 0))
 #define g_slice_free(type, mem)                                 \
 G_STMT_START {                                                  \

package/include/libheif/heif_aux_images.h

@@ -51,12 +51,12 @@ heif_error heif_image_handle_get_depth_image_handle(const heif_image_handle* han
                                                     heif_image_handle** out_depth_handle);
 
 
-enum heif_depth_representation_type {
+typedef enum heif_depth_representation_type {
   heif_depth_representation_type_uniform_inverse_Z = 0,
   heif_depth_representation_type_uniform_disparity = 1,
   heif_depth_representation_type_uniform_Z = 2,
   heif_depth_representation_type_nonuniform_disparity = 3
-};
+} heif_depth_representation_type;
 
 typedef struct heif_depth_representation_info {
   uint8_t version;

package/include/libheif/heif_brands.h

@@ -250,6 +250,15 @@ typedef uint32_t heif_brand2;
 #define heif_brand2_avci   heif_fourcc('a','v','c','i')
 #define heif_brand2_avcs   heif_fourcc('a','v','c','s')
 
+/**
+ * Unified ID namespace (`unif`) brand.
+ *
+ * All IDs (item, track, entity group) share a single global namespace.
+ *
+ * See ISO/IEC 14496-12.
+ */
+#define heif_brand2_unif   heif_fourcc('u','n','i','f')
+
 #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')
@@ -311,13 +320,13 @@ const char* heif_get_file_mime_type(const uint8_t* data, int len);
 
 // ========================= file type check ======================
 
-enum heif_filetype_result
+typedef enum heif_filetype_result
 {
   heif_filetype_no,
   heif_filetype_yes_supported,   // it is heif and can be read by libheif
   heif_filetype_yes_unsupported, // it is heif, but cannot be read by libheif
   heif_filetype_maybe // not sure whether it is an heif, try detection with more input data
-};
+} heif_filetype_result;
 
 // input data should be at least 12 bytes
 LIBHEIF_API
@@ -342,7 +351,7 @@ int heif_check_jpeg_filetype(const uint8_t* data, int len);
 // ===================== DEPRECATED =====================
 
 // DEPRECATED, use heif_brand2 and the heif_brand2_* constants instead
-enum heif_brand
+typedef enum heif_brand
 {
   heif_unknown_brand,
   heif_heic, // HEIF image with h265
@@ -362,7 +371,7 @@ enum heif_brand
   heif_evbs, // EVC sequence
   heif_j2ki, // JPEG2000 image
   heif_j2is, // JPEG2000 image sequence
-};
+} heif_brand;
 
 // input data should be at least 12 bytes
 // DEPRECATED, use heif_read_main_brand() instead

package/include/libheif/heif_color.h

@@ -31,7 +31,7 @@ extern "C" {
 typedef struct heif_image heif_image;
 
 
-enum heif_chroma_downsampling_algorithm
+typedef enum heif_chroma_downsampling_algorithm
 {
   heif_chroma_downsampling_nearest_neighbor = 1,
   heif_chroma_downsampling_average = 2,
@@ -39,13 +39,13 @@ enum heif_chroma_downsampling_algorithm
   // Combine with 'heif_chroma_upsampling_bilinear' for best quality.
   // Makes edges look sharper when using YUV 420 with bilinear chroma upsampling.
   heif_chroma_downsampling_sharp_yuv = 3
-};
+} heif_chroma_downsampling_algorithm;
 
-enum heif_chroma_upsampling_algorithm
+typedef enum heif_chroma_upsampling_algorithm
 {
   heif_chroma_upsampling_nearest_neighbor = 1,
   heif_chroma_upsampling_bilinear = 2
-};
+} heif_chroma_upsampling_algorithm;
 
 
 typedef struct heif_color_conversion_options
@@ -71,12 +71,12 @@ typedef struct heif_color_conversion_options
 } heif_color_conversion_options;
 
 
-enum heif_alpha_composition_mode
+typedef enum heif_alpha_composition_mode
 {
   heif_alpha_composition_mode_none,
   heif_alpha_composition_mode_solid_color,
   heif_alpha_composition_mode_checkerboard,
-};
+} heif_alpha_composition_mode;
 
 
 typedef struct heif_color_conversion_options_ext
@@ -111,13 +111,13 @@ void heif_color_conversion_options_ext_free(heif_color_conversion_options_ext*);
 
 // ------------------------- color profiles -------------------------
 
-enum heif_color_profile_type
+typedef enum heif_color_profile_type
 {
   heif_color_profile_type_not_present = 0,
   heif_color_profile_type_nclx = heif_fourcc('n', 'c', 'l', 'x'),
   heif_color_profile_type_rICC = heif_fourcc('r', 'I', 'C', 'C'),
   heif_color_profile_type_prof = heif_fourcc('p', 'r', 'o', 'f')
-};
+} heif_color_profile_type;
 
 
 // Returns 'heif_color_profile_type_not_present' if there is no color profile.
@@ -137,7 +137,7 @@ struct heif_error heif_image_handle_get_raw_color_profile(const heif_image_handl
                                                           void* out_data);
 
 
-enum heif_color_primaries
+typedef enum heif_color_primaries
 {
   heif_color_primaries_ITU_R_BT_709_5 = 1, // g=0.3;0.6, b=0.15;0.06, r=0.64;0.33, w=0.3127,0.3290
   heif_color_primaries_unspecified = 2,
@@ -151,9 +151,9 @@ enum heif_color_primaries
   heif_color_primaries_SMPTE_RP_431_2 = 11,
   heif_color_primaries_SMPTE_EG_432_1 = 12,
   heif_color_primaries_EBU_Tech_3213_E = 22
-};
+} heif_color_primaries;
 
-enum heif_transfer_characteristics
+typedef enum heif_transfer_characteristics
 {
   heif_transfer_characteristic_ITU_R_BT_709_5 = 1,
   heif_transfer_characteristic_unspecified = 2,
@@ -172,9 +172,9 @@ enum heif_transfer_characteristics
   heif_transfer_characteristic_ITU_R_BT_2100_0_PQ = 16,
   heif_transfer_characteristic_SMPTE_ST_428_1 = 17,
   heif_transfer_characteristic_ITU_R_BT_2100_0_HLG = 18
-};
+} heif_transfer_characteristics;
 
-enum heif_matrix_coefficients
+typedef enum heif_matrix_coefficients
 {
   heif_matrix_coefficients_RGB_GBR = 0,
   heif_matrix_coefficients_ITU_R_BT_709_5 = 1,  // TODO: or 709-6 according to h.273
@@ -190,7 +190,7 @@ enum heif_matrix_coefficients
   heif_matrix_coefficients_chromaticity_derived_non_constant_luminance = 12,
   heif_matrix_coefficients_chromaticity_derived_constant_luminance = 13,
   heif_matrix_coefficients_ICtCp = 14
-};
+} heif_matrix_coefficients;
 
 typedef struct heif_color_profile_nclx
 {

package/include/libheif/heif_context.h

@@ -35,7 +35,7 @@ extern "C" {
 /**
  * libheif known compression formats.
  */
-enum heif_compression_format
+typedef enum heif_compression_format
 {
   /**
    * Unspecified / undefined compression format.
@@ -115,7 +115,7 @@ enum heif_compression_format
    * The core encoding is defined in ISO/IEC 15444-15, or ITU-T T.814.
   */
   heif_compression_HTJ2K = 10
-};
+} heif_compression_format;
 
 
 // ========================= heif_context =========================
@@ -136,13 +136,13 @@ void heif_context_free(heif_context*);
 
 typedef struct heif_reading_options heif_reading_options;
 
-enum heif_reader_grow_status
+typedef enum heif_reader_grow_status
 {
   heif_reader_grow_status_size_reached,    // requested size has been reached, we can read until this point
   heif_reader_grow_status_timeout,         // size has not been reached yet, but it may still grow further (deprecated)
   heif_reader_grow_status_size_beyond_eof, // size has not been reached and never will. The file has grown to its full size
   heif_reader_grow_status_error            // an error has occurred
-};
+} heif_reader_grow_status;
 
 
 typedef struct heif_reader_range_request_result
@@ -295,6 +295,19 @@ heif_error heif_context_get_image_handle(heif_context* ctx,
 LIBHEIF_API
 void heif_context_debug_dump_boxes_to_file(heif_context* ctx, int fd);
 
+// ====================================================================================================
+//   Mini format (experimental)
+
+// Enable writing in the compact 'mini' box format (ISO/IEC 23008-12 DAmd2).
+// When enabled, the output file will use a single 'mini' box instead of the standard
+// meta+mdat box structure, if the file content is compatible with the mini format.
+// If the content cannot be represented as a mini box, the standard format is used as fallback.
+// Requires ENABLE_EXPERIMENTAL_MINI_FORMAT to be enabled at compile time.
+// Default: disabled.
+LIBHEIF_API
+void heif_context_set_write_mini_format(heif_context*, int enable);
+
+
 // ====================================================================================================
 //   Write the heif_context to a HEIF file
 

package/include/libheif/heif_decoding.h

@@ -46,11 +46,11 @@ LIBHEIF_API
 int heif_have_decoder_for_format(enum heif_compression_format format);
 
 
-enum heif_progress_step
+typedef enum heif_progress_step
 {
   heif_progress_step_total = 0,
   heif_progress_step_load_tile = 1
-};
+} heif_progress_step;
 
 
 typedef struct heif_decoding_options

package/include/libheif/heif_encoding.h

@@ -33,6 +33,7 @@ extern "C" {
 #include <libheif/heif_context.h>
 #include <libheif/heif_brands.h>
 #include <libheif/heif_color.h>
+#include <libheif/heif_uncompressed_types.h>
 
 
 // ----- encoder -----
@@ -146,12 +147,12 @@ LIBHEIF_API
 const char* heif_encoder_parameter_get_name(const heif_encoder_parameter*);
 
 
-enum heif_encoder_parameter_type
+typedef enum heif_encoder_parameter_type
 {
   heif_encoder_parameter_type_integer = 1,
   heif_encoder_parameter_type_boolean = 2,
   heif_encoder_parameter_type_string = 3
-};
+} heif_encoder_parameter_type;
 
 // Return the parameter type.
 LIBHEIF_API
@@ -256,7 +257,7 @@ int heif_encoder_has_default(heif_encoder*,
 
 
 // The orientation values are defined equal to the EXIF Orientation tag.
-enum heif_orientation
+typedef enum heif_orientation
 {
   heif_orientation_normal = 1,
   heif_orientation_flip_horizontally = 2,
@@ -266,7 +267,11 @@ enum heif_orientation
   heif_orientation_rotate_90_cw = 6,
   heif_orientation_rotate_90_cw_then_flip_vertically = 7,
   heif_orientation_rotate_270_cw = 8
-};
+} heif_orientation;
+
+
+LIBHEIF_API
+heif_orientation heif_orientation_concat(heif_orientation first, heif_orientation second);
 
 
 typedef struct heif_encoding_options
@@ -297,7 +302,7 @@ typedef struct heif_encoding_options
   // version 5 options
 
   // libheif will generate irot/imir boxes to match these orientations
-  enum heif_orientation image_orientation;
+  heif_orientation image_orientation;
 
   // version 6 options
 
@@ -308,6 +313,12 @@ typedef struct heif_encoding_options
   // Set this to true to use compressed form of uncC where possible.
   uint8_t prefer_uncC_short_form;
 
+  // version 8 options
+
+  // Set this to enable compression for 'unci' images encoded through heif_context_encode_image().
+  // Default: heif_unci_compression_off
+  heif_unci_compression unci_compression;
+
   // TODO: we should add a flag to force MIAF compatible outputs. E.g. this will put restrictions on grid tile sizes and
   //       might add a clap box when the grid output size does not match the color subsampling factors.
   //       Since some of these constraints have to be known before actually encoding the image, "forcing MIAF compatibility"
@@ -364,6 +375,19 @@ LIBHEIF_API
 void heif_context_add_compatible_brand(heif_context* ctx,
                                        heif_brand2 compatible_brand);
 
+/**
+ * Enable the unified ID namespace ('unif' brand).
+ *
+ * When enabled, item IDs, track IDs, and entity group IDs share a single
+ * global counter so no ID value is reused across categories. The 'unif'
+ * compatible brand is automatically added to the output file.
+ *
+ * @param ctx the encoding context
+ * @param flag non-zero to enable, zero to disable
+ */
+LIBHEIF_API
+void heif_context_set_unif(heif_context* ctx, int flag);
+
 // --- deprecated functions ---
 
 // DEPRECATED, typo in function name

package/include/libheif/heif_error.h

@@ -29,7 +29,7 @@ extern "C" {
 #include <stdint.h>
 
 
-enum heif_error_code
+typedef enum heif_error_code
 {
   // Everything ok, no error occurred.
   heif_error_Ok = 0,
@@ -71,10 +71,10 @@ enum heif_error_code
   heif_error_Canceled = 12,
 
   heif_error_End_of_sequence = 13
-};
+} heif_error_code;
 
 
-enum heif_suberror_code
+typedef enum heif_suberror_code
 {
   // no further information available
   heif_suberror_Unspecified = 0,
@@ -278,7 +278,7 @@ enum heif_suberror_code
   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
-};
+} heif_suberror_code;
 
 
 typedef struct heif_error

package/include/libheif/heif_image.h

@@ -31,7 +31,7 @@ extern "C" {
 #include <stdint.h>
 
 
-enum heif_chroma
+typedef enum heif_chroma
 {
   heif_chroma_undefined = 99,
   heif_chroma_monochrome = 0,
@@ -44,14 +44,14 @@ enum heif_chroma
   heif_chroma_interleaved_RRGGBBAA_BE = 13, // HDR, big endian.
   heif_chroma_interleaved_RRGGBB_LE = 14,   // HDR, little endian.
   heif_chroma_interleaved_RRGGBBAA_LE = 15  // HDR, little endian.
-};
+} heif_chroma;
 
 // DEPRECATED ENUM NAMES
 #define heif_chroma_interleaved_24bit  heif_chroma_interleaved_RGB
 #define heif_chroma_interleaved_32bit  heif_chroma_interleaved_RGBA
 
 
-enum heif_colorspace
+typedef enum heif_colorspace
 {
   heif_colorspace_undefined = 99,
 
@@ -75,10 +75,12 @@ enum heif_colorspace
   heif_colorspace_monochrome = 2,
 
   // Indicates that this image has no visual channels.
-  heif_colorspace_nonvisual = 3
-};
+  heif_colorspace_nonvisual = 3,
 
-enum heif_channel
+  heif_colorspace_filter_array = 4
+} heif_colorspace;
+
+typedef enum heif_channel
 {
   heif_channel_Y = 0,
   heif_channel_Cb = 1,
@@ -90,9 +92,44 @@ enum heif_channel
   heif_channel_interleaved = 10,
   heif_channel_filter_array = 11,
   heif_channel_depth = 12,
-  heif_channel_disparity = 13
-};
+  heif_channel_disparity = 13,
+  heif_channel_unknown = 65535
+} heif_channel;
 
+#if HEIF_WITH_OMAF
+/**
+ * OMAF Image projection.
+ *
+ * The image projection for most images is flat - it is projected as intended to be shown on
+ * a flat screen or print. For immersive or omnidirectional media (e.g. VR headsets, or
+ * equivalent), there are alternatives such as an equirectangular projection or cubemap projection.
+ *
+ * See ISO/IEC 23090-2 "Omnidirectional media format" for more information.
+ */
+typedef enum heif_omaf_image_projection
+{
+  /**
+   * Equirectangular projection.
+   */
+  heif_omaf_image_projection_equirectangular = 0x00,
+
+  /**
+   * Cube map.
+   */
+  heif_omaf_image_projection_cube_map = 0x01,
+
+  /* Values 2 through 31 are reserved in ISO/IEC 23090-2:2023 Table 10. */
+  /**
+   * Projection is specified, but not recognised.
+   */
+  heif_omaf_image_projection_unknown = 0xFE,
+
+  /**
+   * Flat projection, assumed if no projection information provided.
+   */
+  heif_omaf_image_projection_flat = 0xFF,
+} heif_omaf_image_projection;
+#endif
 
 // An heif_image contains a decoded pixel image in various colorspaces, chroma formats,
 // and bit depths.
@@ -265,6 +302,13 @@ void heif_image_set_pixel_aspect_ratio(heif_image*, uint32_t aspect_h, uint32_t
 LIBHEIF_API
 void heif_image_handle_set_pixel_aspect_ratio(heif_image_handle*, uint32_t aspect_h, uint32_t aspect_v);
 
+#if HEIF_WITH_OMAF
+LIBHEIF_API
+heif_omaf_image_projection heif_image_get_omaf_image_projection(const heif_image*);
+
+LIBHEIF_API
+void heif_image_set_omaf_image_projection(const heif_image*, heif_omaf_image_projection image_projection);
+#endif
 
 // --- heif_image allocation
 

package/include/libheif/heif_image_handle.h

@@ -122,6 +122,48 @@ 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);
 
+LIBHEIF_API
+void heif_image_handle_set_gimi_content_id(heif_image_handle* handle, const char* content_id);
+
+
+// --- cmpd component queries
+
+// Returns the number of components in the cmpd box, or 0 if no cmpd property exists.
+LIBHEIF_API
+uint32_t heif_image_handle_get_number_of_cmpd_components(const heif_image_handle*);
+
+// Returns the component_type for the given cmpd component index.
+// Returns 0 if out of range or no cmpd property.
+LIBHEIF_API
+uint16_t heif_image_handle_get_cmpd_component_type(const heif_image_handle*, uint32_t component_idx);
+
+// Returns the component_type_uri for the given cmpd component index (component_type >= 0x8000).
+// Returns NULL if the component does not have a URI.
+// The returned string must be freed with heif_string_release().
+LIBHEIF_API
+const char* heif_image_handle_get_cmpd_component_type_uri(const heif_image_handle*, uint32_t component_idx);
+
+
+// --- GIMI component content IDs (handle-level)
+
+// Returns non-zero (count of content IDs) if an ItemComponentContentIDProperty is set, 0 otherwise.
+LIBHEIF_API
+int heif_image_handle_has_gimi_component_content_ids(const heif_image_handle*);
+
+// Returns the GIMI component content ID for the given component index.
+// Returns NULL if no ItemComponentContentIDProperty is set or index is out of range.
+// The returned string must be freed with heif_string_release().
+LIBHEIF_API
+const char* heif_image_handle_get_gimi_component_content_id(const heif_image_handle*, uint32_t component_idx);
+
+// Set a GIMI component content ID for a single component.
+// If an ItemComponentContentIDProperty does not yet exist, one will be created.
+// The content IDs array is resized as needed (new entries default to empty).
+LIBHEIF_API
+void heif_image_handle_set_gimi_component_content_id(heif_image_handle*,
+                                                     uint32_t component_idx,
+                                                     const char* content_id);
+
 #ifdef __cplusplus
 }
 #endif

package/include/libheif/heif_library.h

@@ -160,11 +160,11 @@ void heif_deinit(void);
 
 // --- Plugins are currently only supported on Unix platforms.
 
-enum heif_plugin_type
+typedef enum heif_plugin_type
 {
   heif_plugin_type_encoder,
   heif_plugin_type_decoder
-};
+} heif_plugin_type;
 
 typedef struct heif_plugin_info
 {

package/include/libheif/heif_metadata.h

@@ -28,7 +28,7 @@ extern "C" {
 #include <libheif/heif_library.h>
 
 
-enum heif_metadata_compression
+typedef enum heif_metadata_compression
 {
   heif_metadata_compression_off = 0,
   heif_metadata_compression_auto = 1,
@@ -36,7 +36,7 @@ enum heif_metadata_compression
   heif_metadata_compression_deflate = 3,
   heif_metadata_compression_zlib = 4,    // do not use for header data
   heif_metadata_compression_brotli = 5
-};
+} heif_metadata_compression;
 
 LIBHEIF_API
 int heif_metadata_compression_method_supported(enum heif_metadata_compression method);

package/include/libheif/heif_plugin.h

@@ -162,24 +162,24 @@ typedef struct heif_decoder_plugin
 } heif_decoder_plugin;
 
 
-enum heif_encoded_data_type
+typedef enum heif_encoded_data_type
 {
   heif_encoded_data_type_HEVC_header = 1,
   heif_encoded_data_type_HEVC_image = 2,
   heif_encoded_data_type_HEVC_depth_SEI = 3
-};
+} heif_encoded_data_type;
 
 
 // Specifies the class of the input image content.
 // The encoder may want to encode different classes with different parameters
 // (e.g. always encode alpha lossless)
-enum heif_image_input_class
+typedef enum heif_image_input_class
 {
   heif_image_input_class_normal = 1,
   heif_image_input_class_alpha = 2,
   heif_image_input_class_depth = 3,
   heif_image_input_class_thumbnail = 4
-};
+} heif_image_input_class;
 
 
 typedef struct heif_encoder_plugin