@img/sharp-libvips-dev-wasm32 1.3.0-rc.6 → 1.3.0-rc.8

package/include/libheif/heif_cxx.h

@@ -323,8 +323,8 @@ namespace heif {
 
     // throws Error
     void create(int width, int height,
-                enum heif_colorspace colorspace,
-                enum heif_chroma chroma);
+                heif_colorspace colorspace,
+                heif_chroma chroma);
 
     // throws Error
     void add_plane(enum heif_channel channel,
@@ -391,14 +391,14 @@ namespace heif {
   {
   public:
     static std::vector<EncoderDescriptor>
-    get_encoder_descriptors(enum heif_compression_format format_filter,
+    get_encoder_descriptors(heif_compression_format format_filter,
                             const char* name_filter) noexcept;
 
     std::string get_name() const noexcept;
 
     std::string get_id_name() const noexcept;
 
-    enum heif_compression_format get_compression_format() const noexcept;
+    heif_compression_format get_compression_format() const noexcept;
 
     // DEPRECATED: typo in function name
     bool supportes_lossy_compression() const noexcept;
@@ -453,7 +453,7 @@ namespace heif {
   {
   public:
     // throws Error
-    Encoder(enum heif_compression_format format);
+    Encoder(heif_compression_format format);
 
     // throws Error
     void set_lossy_quality(int quality);
@@ -859,8 +859,8 @@ namespace heif {
 
 
   inline void Image::create(int width, int height,
-                            enum heif_colorspace colorspace,
-                            enum heif_chroma chroma)
+                            heif_colorspace colorspace,
+                            heif_chroma chroma)
   {
     heif_image* image;
     Error err = Error(heif_image_create(width, height, colorspace, chroma, &image));
@@ -1023,7 +1023,7 @@ namespace heif {
 
 
   inline std::vector<EncoderDescriptor>
-  EncoderDescriptor::get_encoder_descriptors(enum heif_compression_format format_filter,
+  EncoderDescriptor::get_encoder_descriptors(heif_compression_format format_filter,
                                              const char* name_filter) noexcept
   {
     int maxDescriptors = 10;
@@ -1066,7 +1066,7 @@ namespace heif {
     return heif_encoder_descriptor_get_id_name(m_descriptor);
   }
 
-  inline enum heif_compression_format EncoderDescriptor::get_compression_format() const noexcept
+  inline heif_compression_format EncoderDescriptor::get_compression_format() const noexcept
   {
     return heif_encoder_descriptor_get_compression_format(m_descriptor);
   }
@@ -1103,7 +1103,7 @@ namespace heif {
   }
 
 
-  inline Encoder::Encoder(enum heif_compression_format format)
+  inline Encoder::Encoder(heif_compression_format format)
   {
     heif_encoder* encoder;
     Error err = Error(heif_context_get_encoder_for_format(nullptr, format, &encoder));

package/include/libheif/heif_decoding.h

@@ -39,11 +39,18 @@ extern "C" {
 LIBHEIF_API
 void heif_context_set_max_decoding_threads(heif_context* ctx, int max_threads);
 
+// Returns the current maximum number of background threads used for parallel tile decoding.
+// This reflects either the library default or the value last passed to
+// heif_context_set_max_decoding_threads().
+// If 'ctx' is NULL, the library default is returned.
+LIBHEIF_API
+int heif_context_get_max_decoding_threads(const heif_context* ctx);
+
 // Quick check whether there is a decoder available for the given format.
 // Note that the decoder still may not be able to decode all variants of that format.
 // You will have to query that further (todo) or just try to decode and check the returned error.
 LIBHEIF_API
-int heif_have_decoder_for_format(enum heif_compression_format format);
+int heif_have_decoder_for_format(heif_compression_format format);
 
 
 typedef enum heif_progress_step
@@ -64,11 +71,11 @@ typedef struct heif_decoding_options
   uint8_t ignore_transformations;
 
   // Any of the progress functions may be called from background threads.
-  void (* start_progress)(enum heif_progress_step step, int max_progress, void* progress_user_data);
+  void (* start_progress)(heif_progress_step step, int max_progress, void* progress_user_data);
 
-  void (* on_progress)(enum heif_progress_step step, int progress, void* progress_user_data);
+  void (* on_progress)(heif_progress_step step, int progress, void* progress_user_data);
 
-  void (* end_progress)(enum heif_progress_step step, void* progress_user_data);
+  void (* end_progress)(heif_progress_step step, void* progress_user_data);
 
   void* progress_user_data;
 
@@ -107,10 +114,47 @@ typedef struct heif_decoding_options
   // If enabled, it will decode the media timeline, ignoring the sequence tracks edit-list.
   int ignore_sequence_editlist; // bool
 
+  // Requested NCLX color profile of the decoded output image. If the input
+  // image's NCLX differs, libheif will color-convert the pixels accordingly
+  // (e.g. YCbCr matrix, primaries, range) so the result matches what is
+  // requested here.
+  //
+  // When set to NULL, the behavior depends on the flag
+  // output_image_nclx_profile_passthrough below: by default NULL means
+  // "convert to sRGB"; with the passthrough flag enabled, NULL means
+  // "keep the input image's NCLX".
   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
+
+  // version 9 options
+
+  // If enabled, libheif will attempt to work around known broken-input quirks
+  // (e.g. Sony HIF files where the NCLX `colr` box disagrees with the HEVC VUI
+  // on the YCbCr range flag). Default: false (strict spec-conformant behavior).
+  uint8_t autocorrect_broken_input;
+
+  // version 10 options
+
+  // Controls the meaning of output_image_nclx_profile == NULL.
+  //
+  // When false (default), a NULL output_image_nclx_profile means "convert the
+  // decoded image to sRGB" (BT.709 primaries, sRGB transfer, BT.601 matrix,
+  // full-range). For HDR inputs (e.g. BT.2100 PQ) this silently discards the
+  // original color volume.
+  //
+  // When true, a NULL output_image_nclx_profile means "keep the input image's
+  // NCLX". The decoded image carries the input file's primaries / transfer /
+  // matrix / range, and no extra color-space conversion is performed solely
+  // because the output NCLX was unspecified. If a YCbCr<->RGB colorspace
+  // conversion fires for another reason, the input NCLX is used to drive that
+  // conversion (so the result is tagged consistently with the source).
+  //
+  // Although this flag is off by default to preserve historical behavior, new
+  // code that wants to preserve HDR through decode should generally enable it.
+  // Setting output_image_nclx_profile to a non-NULL value overrides this flag.
+  uint8_t output_image_nclx_profile_passthrough;
 } heif_decoding_options;
 
 
@@ -136,7 +180,7 @@ typedef struct heif_decoder_descriptor heif_decoder_descriptor;
 // The number of decoders is returned, which are not more than 'count' if (out_decoders != nullptr).
 // By setting out_decoders==nullptr, you can query the number of decoders, 'count' is ignored.
 LIBHEIF_API
-int heif_get_decoder_descriptors(enum heif_compression_format format_filter,
+int heif_get_decoder_descriptors(heif_compression_format format_filter,
                                  const heif_decoder_descriptor** out_decoders,
                                  int count);
 
@@ -161,8 +205,8 @@ const char* heif_decoder_descriptor_get_id_name(const heif_decoder_descriptor*);
 LIBHEIF_API
 heif_error heif_decode_image(const heif_image_handle* in_handle,
                              heif_image** out_img,
-                             enum heif_colorspace colorspace,
-                             enum heif_chroma chroma,
+                             heif_colorspace colorspace,
+                             heif_chroma chroma,
                              const heif_decoding_options* options);
 
 #ifdef __cplusplus

package/include/libheif/heif_encoding.h

@@ -33,7 +33,11 @@ extern "C" {
 #include <libheif/heif_context.h>
 #include <libheif/heif_brands.h>
 #include <libheif/heif_color.h>
-#include <libheif/heif_uncompressed_types.h>
+
+// Forward declaration. The full definition lives in heif_uncompressed.h.
+// heif_encoding_options only stores a pointer, so a forward typedef is enough here
+// and avoids a circular include (heif_uncompressed.h pulls in heif.h, which pulls in this header).
+typedef struct heif_unci_image_parameters heif_unci_image_parameters;
 
 
 // ----- encoder -----
@@ -56,7 +60,7 @@ typedef struct heif_encoder_parameter heif_encoder_parameter;
 // Note that the encoder may be limited to a certain subset of features (e.g. only 8 bit, only lossy).
 // You will have to query the specific capabilities further.
 LIBHEIF_API
-int heif_have_encoder_for_format(enum heif_compression_format format);
+int heif_have_encoder_for_format(heif_compression_format format);
 
 // Get a list of available encoders. You can filter the encoders by compression format and name.
 // Use format_filter==heif_compression_undefined and name_filter==NULL as wildcards.
@@ -65,7 +69,7 @@ int heif_have_encoder_for_format(enum heif_compression_format format);
 // By setting out_encoders==nullptr, you can query the number of encoders, 'count' is ignored.
 // Note: to get the actual encoder from the descriptors returned here, use heif_context_get_encoder().
 LIBHEIF_API
-int heif_get_encoder_descriptors(enum heif_compression_format format_filter,
+int heif_get_encoder_descriptors(heif_compression_format format_filter,
                                  const char* name_filter,
                                  const heif_encoder_descriptor** out_encoders,
                                  int count);
@@ -80,7 +84,7 @@ LIBHEIF_API
 const char* heif_encoder_descriptor_get_id_name(const heif_encoder_descriptor*);
 
 LIBHEIF_API
-enum heif_compression_format
+heif_compression_format
 heif_encoder_descriptor_get_compression_format(const heif_encoder_descriptor*);
 
 LIBHEIF_API
@@ -100,7 +104,7 @@ heif_error heif_context_get_encoder(heif_context* context,
 // for this format, the encoder with the highest plugin priority will be returned.
 LIBHEIF_API
 heif_error heif_context_get_encoder_for_format(heif_context* context,
-                                               enum heif_compression_format format,
+                                               heif_compression_format format,
                                                heif_encoder**);
 
 /**
@@ -315,9 +319,11 @@ typedef struct heif_encoding_options
 
   // 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;
+  // Optional 'unci'-specific encoding parameters (compression method, and future fields
+  // such as interleave type and padding).
+  //
+  // Default: nullptr
+  const heif_unci_image_parameters* unci_parameters;
 
   // 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.
@@ -407,7 +413,7 @@ int heif_encoder_descriptor_supportes_lossless_compression(const heif_encoder_de
 // Note: to get the actual encoder from the descriptors returned here, use heif_context_get_encoder().
 LIBHEIF_API
 int heif_context_get_encoder_descriptors(heif_context*, // TODO: why do we need this parameter?
-                                         enum heif_compression_format format_filter,
+                                         heif_compression_format format_filter,
                                          const char* name_filter,
                                          const heif_encoder_descriptor** out_encoders,
                                          int count);

package/include/libheif/heif_error.h

@@ -28,6 +28,8 @@ extern "C" {
 #include <stddef.h>
 #include <stdint.h>
 
+#include <libheif/heif_export.h>
+
 
 typedef enum heif_error_code
 {
@@ -191,6 +193,11 @@ typedef enum heif_suberror_code
 
   heif_suberror_No_moov_box = 151,
 
+  // The colr (NCLX) box and the codec bitstream VUI/color signalling disagree.
+  // Per ISO/IEC 14496-12 and ISO/IEC 23000-22 (MIAF) the colr box takes precedence,
+  // but the conflict is reported as a warning.
+  heif_suberror_NCLX_colr_VUI_mismatch = 152,
+
   // --- Memory_allocation_error ---
 
   // A security limit preventing unreasonable memory allocations was exceeded by the input file.
@@ -284,10 +291,10 @@ typedef enum heif_suberror_code
 typedef struct heif_error
 {
   // main error category
-  enum heif_error_code code;
+  heif_error_code code;
 
   // more detailed error code
-  enum heif_suberror_code subcode;
+  heif_suberror_code subcode;
 
   // textual error message (is always defined, you do not have to check for NULL)
   const char* message;

package/include/libheif/heif_export.h

@@ -0,0 +1,48 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017-2026 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_EXPORT_H
+#define LIBHEIF_HEIF_EXPORT_H
+
+// LIBHEIF_API marks the symbols that are exported from the shared library.
+//
+// This macro lives in its own tiny, dependency-free header so that every
+// public header can pull it in without creating include cycles. In particular,
+// heif_library.h and heif_error.h are mutually dependent (heif_library.h needs
+// the heif_error type while heif_error.h needs LIBHEIF_API), so the macro
+// cannot live in either of them if both are to compile standalone.
+
+#if (defined(_WIN32) || defined __CYGWIN__) && !defined(LIBHEIF_STATIC_BUILD)
+#ifdef LIBHEIF_EXPORTS
+#define LIBHEIF_API __declspec(dllexport)
+#else
+#define LIBHEIF_API __declspec(dllimport)
+#endif
+#elif defined(HAVE_VISIBILITY) && HAVE_VISIBILITY
+#ifdef LIBHEIF_EXPORTS
+#define LIBHEIF_API __attribute__((__visibility__("default")))
+#else
+#define LIBHEIF_API
+#endif
+#else
+#define LIBHEIF_API
+#endif
+
+#endif  // LIBHEIF_HEIF_EXPORT_H

package/include/libheif/heif_image.h

@@ -31,10 +31,29 @@ extern "C" {
 #include <stdint.h>
 
 
+// The heif_chroma enum describes pixel layout (planar vs interleaved, and any
+// YUV chroma subsampling). It does NOT describe pixel semantics; the semantic
+// interpretation of the planes comes from heif_colorspace.
+//
+// heif_chroma_planar covers "one or more planar components, no subsampling".
+// It is used for:
+//   - heif_colorspace_monochrome (single luma plane)
+//   - heif_colorspace_filter_array (single CFA mosaic plane)
+//   - heif_colorspace_custom (any number of planar components)
+// For heif_colorspace_RGB the historical name heif_chroma_444 is the
+// canonical form for planar RGB. heif_chroma_planar is accepted as a
+// synonym at the C API boundary and is internally canonicalized to
+// heif_chroma_444 so existing callers and internal code paths keep seeing
+// heif_chroma_444 on read-back. Callers should also accept a returned
+// heif_chroma_planar as a synonym. We might switch to this as the
+// canonical name in the future.
+//
+// The YUV subsampling names (heif_chroma_420 / _422 / _444) are kept for
+// heif_colorspace_YCbCr.
 typedef enum heif_chroma
 {
   heif_chroma_undefined = 99,
-  heif_chroma_monochrome = 0,
+  heif_chroma_planar = 0,
   heif_chroma_420 = 1,
   heif_chroma_422 = 2,
   heif_chroma_444 = 3,
@@ -50,6 +69,11 @@ typedef enum heif_chroma
 #define heif_chroma_interleaved_24bit  heif_chroma_interleaved_RGB
 #define heif_chroma_interleaved_32bit  heif_chroma_interleaved_RGBA
 
+// Legacy alias for heif_chroma_planar. The name "monochrome" was misleading
+// for non-grayscale planar layouts (filter_array, custom); use
+// heif_chroma_planar in new code.
+#define heif_chroma_monochrome heif_chroma_planar
+
 
 typedef enum heif_colorspace
 {
@@ -63,6 +87,8 @@ typedef enum heif_colorspace
 
   // heif_colorspace_RGB should be used with one of these heif_chroma values:
   // * heif_chroma_444 (for planar RGB)
+  // * heif_chroma_planar is accepted as a synonym and is internally canonicalized to heif_chroma_444.
+  //                      It is the preferred, future-proof value.
   // * heif_chroma_interleaved_RGB
   // * heif_chroma_interleaved_RGBA
   // * heif_chroma_interleaved_RRGGBB_BE
@@ -71,15 +97,21 @@ typedef enum heif_colorspace
   // * heif_chroma_interleaved_RRGGBBAA_LE
   heif_colorspace_RGB = 1,
 
-  // heif_colorspace_monochrome should only be used with heif_chroma = heif_chroma_monochrome
+  // heif_colorspace_monochrome should only be used with heif_chroma = heif_chroma_planar.
   heif_colorspace_monochrome = 2,
 
-  // Indicates that this image has no visual channels.
-  heif_colorspace_nonvisual = 3,
+  // Indicates that this image has a special, custom arrangement of components.
+  // For example, it can have several monochrome channels or just a depth component with no color image.
+  // Images of this type are always planar and use heif_chroma_planar.
+  heif_colorspace_custom = 3,
 
+  // Images of this type are filter-array (CFA / Bayer) mosaics. The single
+  // mosaicked plane is described as heif_chroma_planar.
   heif_colorspace_filter_array = 4
 } heif_colorspace;
 
+#define heif_colorspace_nonvisual heif_colorspace_custom
+
 typedef enum heif_channel
 {
   heif_channel_Y = 0,
@@ -96,41 +128,6 @@ typedef enum heif_channel
   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.
 
@@ -139,6 +136,9 @@ typedef enum heif_omaf_image_projection
 // containing the interleaved R,G,B values.
 
 // Planar RGB images are specified as heif_colorspace_RGB / heif_chroma_444.
+// heif_chroma_planar is accepted as a synonym and is internally canonicalized
+// to heif_chroma_444 so heif_image_get_chroma_format() always returns
+// heif_chroma_444 for planar RGB.
 
 typedef struct heif_image heif_image;
 typedef struct heif_image_handle heif_image_handle;
@@ -147,11 +147,11 @@ typedef struct heif_security_limits heif_security_limits;
 
 // Get the colorspace format of the image.
 LIBHEIF_API
-enum heif_colorspace heif_image_get_colorspace(const heif_image*);
+heif_colorspace heif_image_get_colorspace(const heif_image*);
 
 // Get the chroma format of the image.
 LIBHEIF_API
-enum heif_chroma heif_image_get_chroma_format(const heif_image*);
+heif_chroma heif_image_get_chroma_format(const heif_image*);
 
 /**
  * Get the width of a specified image channel.
@@ -161,7 +161,7 @@ enum heif_chroma heif_image_get_chroma_format(const heif_image*);
  * @return the width of the channel in pixels, or -1 the channel does not exist in the image
  */
 LIBHEIF_API
-int heif_image_get_width(const heif_image* img, enum heif_channel channel);
+int heif_image_get_width(const heif_image* img, heif_channel channel);
 
 /**
  * Get the height of a specified image channel.
@@ -171,12 +171,13 @@ int heif_image_get_width(const heif_image* img, enum heif_channel channel);
  * @return the height of the channel in pixels, or -1 the channel does not exist in the image
  */
 LIBHEIF_API
-int heif_image_get_height(const heif_image* img, enum heif_channel channel);
+int heif_image_get_height(const heif_image* img, heif_channel channel);
 
 /**
- * Get the width of the main channel.
+ * Get the logical width of the image.
  *
- * This is the Y channel in YCbCr or mono, or any in RGB.
+ * For well-formed images this equals the size of the main channel (the Y channel
+ * in YCbCr or mono, or the RGB channels). Subsampled chroma channels may be smaller.
  *
  * @param img the image to get the primary width for
  * @return the width in pixels
@@ -185,9 +186,10 @@ LIBHEIF_API
 int heif_image_get_primary_width(const heif_image* img);
 
 /**
- * Get the height of the main channel.
+ * Get the logical height of the image.
  *
- * This is the Y channel in YCbCr or mono, or any in RGB.
+ * For well-formed images this equals the size of the main channel (the Y channel
+ * in YCbCr or mono, or the RGB channels). Subsampled chroma channels may be smaller.
  *
  * @param img the image to get the primary height for
  * @return the height in pixels
@@ -195,6 +197,27 @@ int heif_image_get_primary_width(const heif_image* img);
 LIBHEIF_API
 int heif_image_get_primary_height(const heif_image* img);
 
+/**
+ * Crop the image in place by removing margins from each edge.
+ *
+ * The four parameters specify the number of pixels to remove from each side,
+ * not absolute pixel coordinates. For example, to crop a 100x100 image down
+ * to its central 80x80 region, pass `left=10, right=10, top=10, bottom=10`.
+ * Passing all zeros leaves the image unchanged.
+ *
+ * The resulting image has dimensions `(w - left - right) x (h - top - bottom)`,
+ * which must be at least 1x1. All four values must be non-negative and the
+ * sums `left + right` and `top + bottom` must each be strictly less than the
+ * corresponding image dimension; otherwise `heif_error_Usage_error` /
+ * `heif_suberror_Invalid_parameter_value` is returned and the image is left
+ * unchanged.
+ *
+ * @param img    the image to crop (modified in place on success)
+ * @param left   number of pixels to remove from the left edge
+ * @param right  number of pixels to remove from the right edge
+ * @param top    number of pixels to remove from the top edge
+ * @param bottom number of pixels to remove from the bottom edge
+ */
 LIBHEIF_API
 heif_error heif_image_crop(heif_image* img,
                            int left, int right, int top, int bottom);
@@ -212,7 +235,7 @@ heif_error heif_image_extract_area(const heif_image*,
 // Especially for HDR images, this is probably not what you want. Have a look at
 // heif_image_get_bits_per_pixel_range() instead.
 LIBHEIF_API
-int heif_image_get_bits_per_pixel(const heif_image*, enum heif_channel channel);
+int heif_image_get_bits_per_pixel(const heif_image*, heif_channel channel);
 
 // Get the number of bits per pixel in the given image channel. This function returns
 // the number of bits used for representing the pixel value, which might be smaller
@@ -221,10 +244,10 @@ int heif_image_get_bits_per_pixel(const heif_image*, enum heif_channel channel);
 // are reserved for storage. For interleaved RGBA with 12 bit, this function also returns
 // '12', not '48' or '64' (heif_image_get_bits_per_pixel returns 64 in this case).
 LIBHEIF_API
-int heif_image_get_bits_per_pixel_range(const heif_image*, enum heif_channel channel);
+int heif_image_get_bits_per_pixel_range(const heif_image*, heif_channel channel);
 
 LIBHEIF_API
-int heif_image_has_channel(const heif_image*, enum heif_channel channel);
+int heif_image_has_channel(const heif_image*, heif_channel channel);
 
 // Get a pointer to the actual pixel data.
 // The 'out_stride' is returned as "bytes per line".
@@ -233,13 +256,13 @@ int heif_image_has_channel(const heif_image*, enum heif_channel channel);
 // Deprecated, use the safer version heif_image_get_plane_readonly2() instead.
 LIBHEIF_API
 const uint8_t* heif_image_get_plane_readonly(const heif_image*,
-                                             enum heif_channel channel,
+                                             heif_channel channel,
                                              int* out_stride);
 
 // Deprecated, use the safer version heif_image_get_plane2() instead.
 LIBHEIF_API
 uint8_t* heif_image_get_plane(heif_image*,
-                              enum heif_channel channel,
+                              heif_channel channel,
                               int* out_stride);
 
 // These are safer variants of the two functions above.
@@ -248,12 +271,12 @@ uint8_t* heif_image_get_plane(heif_image*,
 // 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,
+                                              heif_channel channel,
                                               size_t* out_stride);
 
 LIBHEIF_API
 uint8_t* heif_image_get_plane2(heif_image*,
-                               enum heif_channel channel,
+                               heif_channel channel,
                                size_t* out_stride);
 
 
@@ -302,14 +325,6 @@ 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
 
 /**
@@ -327,8 +342,8 @@ void heif_image_set_omaf_image_projection(const heif_image*, heif_omaf_image_pro
 */
 LIBHEIF_API
 heif_error heif_image_create(int width, int height,
-                             enum heif_colorspace colorspace,
-                             enum heif_chroma chroma,
+                             heif_colorspace colorspace,
+                             heif_chroma chroma,
                              heif_image** out_image);
 
 /**
@@ -361,7 +376,7 @@ heif_error heif_image_create(int width, int height,
  */
 LIBHEIF_API
 heif_error heif_image_add_plane(heif_image* image,
-                                enum heif_channel channel,
+                                heif_channel channel,
                                 int width, int height, int bit_depth);
 
 /*
@@ -370,7 +385,7 @@ heif_error heif_image_add_plane(heif_image* image,
  */
 LIBHEIF_API
 heif_error heif_image_add_plane_safe(heif_image* image,
-                                     enum heif_channel channel,
+                                     heif_channel channel,
                                      int width, int height, int bit_depth,
                                      const heif_security_limits* limits);
 

package/include/libheif/heif_image_handle.h

@@ -91,8 +91,8 @@ int heif_image_handle_get_chroma_bits_per_pixel(const heif_image_handle*);
 // You can still request the output in your preferred colorspace, but this may involve an internal conversion.
 LIBHEIF_API
 heif_error heif_image_handle_get_preferred_decoding_colorspace(const heif_image_handle* image_handle,
-                                                               enum heif_colorspace* out_colorspace,
-                                                               enum heif_chroma* out_chroma);
+                                                               heif_colorspace* out_colorspace,
+                                                               heif_chroma* out_chroma);
 
 // Get the image width from the 'ispe' box. This is the original image size without
 // any transformations applied to it. Do not use this unless you know exactly what

package/include/libheif/heif_items.h

@@ -61,7 +61,7 @@ int heif_context_get_list_of_item_IDs(const heif_context* ctx,
  * 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
+ * any 4-byte number. Thus, the type is returned as an integer. You can use #heif_fourcc to map
  * between the two representations.
  *
  * @param ctx the file context