@img/sharp-libvips-dev 1.2.0-rc.3 → 1.2.0-rc.4

package/include/libheif/heif_plugin.h

@@ -25,7 +25,7 @@
 extern "C" {
 #endif
 
-#include <libheif/heif.h>
+#include <libheif/heif_encoding.h>
 
 
 // ====================================================================================================
@@ -42,7 +42,10 @@ extern "C" {
 //  1.8          1         2          2
 //  1.13         2         3          2
 //  1.15         3         3          2
+//  1.20         4         3          2
 
+#define heif_decoder_plugin_latest_version 4
+#define heif_encoder_plugin_latest_version 3
 
 // ====================================================================================================
 //  Decoder plugin API
@@ -50,7 +53,7 @@ extern "C" {
 //  added as plugins. A plugin has to implement the functions specified in heif_decoder_plugin
 //  and the plugin has to be registered to the libheif library using heif_register_decoder().
 
-struct heif_decoder_plugin
+typedef struct heif_decoder_plugin
 {
   // API version supported by this plugin (see table above for supported versions)
   int plugin_api_version;
@@ -59,13 +62,13 @@ struct heif_decoder_plugin
   // --- version 1 functions ---
 
   // Human-readable name of the plugin
-  const char* (* get_plugin_name)();
+  const char* (* get_plugin_name)(void);
 
   // Global plugin initialization (may be NULL)
-  void (* init_plugin)();
+  void (* init_plugin)(void);
 
   // Global plugin deinitialization (may be NULL)
-  void (* deinit_plugin)();
+  void (* deinit_plugin)(void);
 
   // Query whether the plugin supports decoding of the given format
   // Result is a priority value. The plugin with the largest value wins.
@@ -73,24 +76,24 @@ struct heif_decoder_plugin
   int (* does_support_format)(enum heif_compression_format format);
 
   // Create a new decoder context for decoding an image
-  struct heif_error (* new_decoder)(void** decoder);
+  heif_error (* new_decoder)(void** decoder);
 
   // Free the decoder context (heif_image can still be used after destruction)
   void (* free_decoder)(void* decoder);
 
   // Push more data into the decoder. This can be called multiple times.
   // This may not be called after any decode_*() function has been called.
-  struct heif_error (* push_data)(void* decoder, const void* data, size_t size);
+  heif_error (* push_data)(void* decoder, const void* data, size_t size);
 
 
   // --- After pushing the data into the decoder, the decode functions may be called only once.
 
-  struct heif_error (* decode_image)(void* decoder, struct heif_image** out_img);
+  heif_error (* decode_image)(void* decoder, heif_image** out_img);
 
 
-  // --- version 2 functions will follow below ... ---
+  // --- version 2 functions ---
 
-  void (*set_strict_decoding)(void* decoder, int flag);
+  void (* set_strict_decoding)(void* decoder, int flag);
 
   // If not NULL, this can provide a specialized function to convert YCbCr to sRGB, because
   // only the codec itself knows how to interpret the chroma samples and their locations.
@@ -104,12 +107,19 @@ struct heif_decoder_plugin
   // Reset decoder, such that we can feed in new data for another image.
   // void (*reset_image)(void* decoder);
 
-  // --- version 3 functions will follow below ... ---
+  // --- version 3 functions ---
 
   const char* id_name;
 
-  // --- version 4 functions will follow below ... ---
-};
+  // --- version 4 functions ---
+
+  heif_error (* decode_next_image)(void* decoder, heif_image** out_img,
+                                   const heif_security_limits* limits);
+
+  // --- version 5 functions will follow below ... ---
+
+  // --- Note: when adding new versions, also update `heif_decoder_plugin_latest_version`.
+} heif_decoder_plugin;
 
 
 enum heif_encoded_data_type
@@ -132,7 +142,7 @@ enum heif_image_input_class
 };
 
 
-struct heif_encoder_plugin
+typedef struct heif_encoder_plugin
 {
   // API version supported by this plugin (see table above for supported versions)
   int plugin_api_version;
@@ -157,46 +167,46 @@ struct heif_encoder_plugin
 
 
   // Human-readable name of the plugin
-  const char* (* get_plugin_name)();
+  const char* (* get_plugin_name)(void);
 
   // Global plugin initialization (may be NULL)
-  void (* init_plugin)();
+  void (* init_plugin)(void);
 
   // Global plugin cleanup (may be NULL).
   // Free data that was allocated in init_plugin()
-  void (* cleanup_plugin)();
+  void (* cleanup_plugin)(void);
 
   // Create a new decoder context for decoding an image
-  struct heif_error (* new_encoder)(void** encoder);
+  heif_error (* new_encoder)(void** encoder);
 
   // Free the decoder context (heif_image can still be used after destruction)
   void (* free_encoder)(void* encoder);
 
-  struct heif_error (* set_parameter_quality)(void* encoder, int quality);
+  heif_error (* set_parameter_quality)(void* encoder, int quality);
 
-  struct heif_error (* get_parameter_quality)(void* encoder, int* quality);
+  heif_error (* get_parameter_quality)(void* encoder, int* quality);
 
-  struct heif_error (* set_parameter_lossless)(void* encoder, int lossless);
+  heif_error (* set_parameter_lossless)(void* encoder, int lossless);
 
-  struct heif_error (* get_parameter_lossless)(void* encoder, int* lossless);
+  heif_error (* get_parameter_lossless)(void* encoder, int* lossless);
 
-  struct heif_error (* set_parameter_logging_level)(void* encoder, int logging);
+  heif_error (* set_parameter_logging_level)(void* encoder, int logging);
 
-  struct heif_error (* get_parameter_logging_level)(void* encoder, int* logging);
+  heif_error (* get_parameter_logging_level)(void* encoder, int* logging);
 
-  const struct heif_encoder_parameter** (* list_parameters)(void* encoder);
+  const heif_encoder_parameter** (* list_parameters)(void* encoder);
 
-  struct heif_error (* set_parameter_integer)(void* encoder, const char* name, int value);
+  heif_error (* set_parameter_integer)(void* encoder, const char* name, int value);
 
-  struct heif_error (* get_parameter_integer)(void* encoder, const char* name, int* value);
+  heif_error (* get_parameter_integer)(void* encoder, const char* name, int* value);
 
-  struct heif_error (* set_parameter_boolean)(void* encoder, const char* name, int value);
+  heif_error (* set_parameter_boolean)(void* encoder, const char* name, int value);
 
-  struct heif_error (* get_parameter_boolean)(void* encoder, const char* name, int* value);
+  heif_error (* get_parameter_boolean)(void* encoder, const char* name, int* value);
 
-  struct heif_error (* set_parameter_string)(void* encoder, const char* name, const char* value);
+  heif_error (* set_parameter_string)(void* encoder, const char* name, const char* value);
 
-  struct heif_error (* get_parameter_string)(void* encoder, const char* name, char* value, int value_size);
+  heif_error (* get_parameter_string)(void* encoder, const char* name, char* value, int value_size);
 
   // Replace the input colorspace/chroma with the one that is supported by the encoder and that
   // comes as close to the input colorspace/chroma as possible.
@@ -206,12 +216,12 @@ struct heif_encoder_plugin
   // Encode an image.
   // After pushing an image into the encoder, you should call get_compressed_data() to
   // get compressed data until it returns a NULL data pointer.
-  struct heif_error (* encode_image)(void* encoder, const struct heif_image* image,
-                                     enum heif_image_input_class image_class);
+  heif_error (* encode_image)(void* encoder, const heif_image* image,
+                              enum heif_image_input_class image_class);
 
   // Get a packet of decoded data. The data format depends on the codec.
   // For HEVC, each packet shall contain exactly one NAL, starting with the NAL header without startcode.
-  struct heif_error (* get_compressed_data)(void* encoder, uint8_t** data, int* size,
+  heif_error (* get_compressed_data)(void* encoder, uint8_t** data, int* size,
                                             enum heif_encoded_data_type* type);
 
 
@@ -231,7 +241,9 @@ struct heif_encoder_plugin
                               uint32_t* encoded_width, uint32_t* encoded_height);
 
   // --- version 4 functions will follow below ... ---
-};
+
+  // --- Note: when adding new versions, also update `heif_encoder_plugin_latest_version`.
+} heif_encoder_plugin;
 
 
 // Names for standard parameters. These should only be used by the encoder plugins.
@@ -241,7 +253,7 @@ struct heif_encoder_plugin
 // For use only by the encoder plugins.
 // Application programs should use the access functions.
 // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
-struct heif_encoder_parameter
+typedef struct heif_encoder_parameter
 {
   int version; // current version: 2
 
@@ -280,15 +292,15 @@ struct heif_encoder_parameter
   // --- version 2 fields
 
   int has_default;
-};
+} heif_encoder_parameter;
 
 
-extern struct heif_error heif_error_ok;
-extern struct heif_error heif_error_unsupported_parameter;
-extern struct heif_error heif_error_invalid_parameter_value;
+extern heif_error heif_error_ok;
+extern heif_error heif_error_unsupported_parameter;
+extern heif_error heif_error_invalid_parameter_value;
 
 #define HEIF_WARN_OR_FAIL(strict, image, cmd, cleanupBlock) \
-{ struct heif_error e = cmd;                  \
+{ heif_error e = cmd;                         \
   if (e.code != heif_error_Ok) {              \
     if (strict) {                             \
       cleanupBlock                            \

package/include/libheif/heif_properties.h

@@ -49,7 +49,7 @@ enum heif_item_property_type
 // The number of properties is returned, which are not more than 'count' if (out_list != nullptr).
 // By setting out_list==nullptr, you can query the number of properties, 'count' is ignored.
 LIBHEIF_API
-int heif_item_get_properties_of_type(const struct heif_context* context,
+int heif_item_get_properties_of_type(const heif_context* context,
                                      heif_item_id id,
                                      enum heif_item_property_type type,
                                      heif_property_id* out_list,
@@ -60,18 +60,18 @@ int heif_item_get_properties_of_type(const struct heif_context* context,
 // The number of properties is returned, which are not more than 'count' if (out_list != nullptr).
 // By setting out_list==nullptr, you can query the number of properties, 'count' is ignored.
 LIBHEIF_API
-int heif_item_get_transformation_properties(const struct heif_context* context,
+int heif_item_get_transformation_properties(const heif_context* context,
                                             heif_item_id id,
                                             heif_property_id* out_list,
                                             int count);
 
 LIBHEIF_API
-enum heif_item_property_type heif_item_get_property_type(const struct heif_context* context,
+enum heif_item_property_type heif_item_get_property_type(const heif_context* context,
                                                          heif_item_id id,
                                                          heif_property_id property_id);
 
 // The strings are managed by libheif. They will be deleted in heif_property_user_description_release().
-struct heif_property_user_description
+typedef struct heif_property_user_description
 {
   int version;
 
@@ -81,28 +81,28 @@ struct heif_property_user_description
   const char* name;
   const char* description;
   const char* tags;
-};
+} heif_property_user_description;
 
 // Get the "udes" user description property content.
 // Undefined strings are returned as empty strings.
 LIBHEIF_API
-struct heif_error heif_item_get_property_user_description(const struct heif_context* context,
-                                                          heif_item_id itemId,
-                                                          heif_property_id propertyId,
-                                                          struct heif_property_user_description** out);
+heif_error heif_item_get_property_user_description(const heif_context* context,
+                                                   heif_item_id itemId,
+                                                   heif_property_id propertyId,
+                                                   heif_property_user_description** out);
 
 // Add a "udes" user description property to the item.
 // If any string pointers are NULL, an empty string will be used instead.
 LIBHEIF_API
-struct heif_error heif_item_add_property_user_description(const struct heif_context* context,
-                                                          heif_item_id itemId,
-                                                          const struct heif_property_user_description* description,
-                                                          heif_property_id* out_propertyId);
+heif_error heif_item_add_property_user_description(const heif_context* context,
+                                                   heif_item_id itemId,
+                                                   const heif_property_user_description* description,
+                                                   heif_property_id* out_propertyId);
 
 // Release all strings and the object itself.
 // Only call for objects that you received from heif_item_get_property_user_description().
 LIBHEIF_API
-void heif_property_user_description_release(struct heif_property_user_description*);
+void heif_property_user_description_release(heif_property_user_description*);
 
 enum heif_transform_mirror_direction
 {
@@ -113,14 +113,14 @@ enum heif_transform_mirror_direction
 
 // Will return 'heif_transform_mirror_direction_invalid' in case of error.
 LIBHEIF_API
-enum heif_transform_mirror_direction heif_item_get_property_transform_mirror(const struct heif_context* context,
+enum heif_transform_mirror_direction heif_item_get_property_transform_mirror(const heif_context* context,
                                                                              heif_item_id itemId,
                                                                              heif_property_id propertyId);
 
 // Returns only 0, 90, 180, or 270 angle values.
 // Returns -1 in case of error (but it will only return an error in case of wrong usage).
 LIBHEIF_API
-int heif_item_get_property_transform_rotation_ccw(const struct heif_context* context,
+int heif_item_get_property_transform_rotation_ccw(const heif_context* context,
                                                   heif_item_id itemId,
                                                   heif_property_id propertyId);
 
@@ -128,7 +128,7 @@ int heif_item_get_property_transform_rotation_ccw(const struct heif_context* con
 // Because of the way this data is stored, you have to pass the image size at the moment of the crop operation
 // to compute the cropped border sizes.
 LIBHEIF_API
-void heif_item_get_property_transform_crop_borders(const struct heif_context* context,
+void heif_item_get_property_transform_crop_borders(const heif_context* context,
                                                    heif_item_id itemId,
                                                    heif_property_id propertyId,
                                                    int image_width, int image_height,
@@ -145,28 +145,28 @@ void heif_item_get_property_transform_crop_borders(const struct heif_context* co
  * @param out_propertyId Outputs the id of the inserted property. Can be NULL.
 */
 LIBHEIF_API
-struct heif_error heif_item_add_raw_property(const struct heif_context* context,
-                                             heif_item_id itemId,
-                                             uint32_t fourcc_type,
-                                             const uint8_t* uuid_type,
-                                             const uint8_t* data, size_t size,
-                                             int is_essential,
-                                             heif_property_id* out_propertyId);
+heif_error heif_item_add_raw_property(const heif_context* context,
+                                      heif_item_id itemId,
+                                      uint32_t fourcc_type,
+                                      const uint8_t* uuid_type,
+                                      const uint8_t* data, size_t size,
+                                      int is_essential,
+                                      heif_property_id* out_propertyId);
 
 LIBHEIF_API
-struct heif_error heif_item_get_property_raw_size(const struct heif_context* context,
-                                                  heif_item_id itemId,
-                                                  heif_property_id propertyId,
-                                                  size_t* out_size);
+heif_error heif_item_get_property_raw_size(const heif_context* context,
+                                           heif_item_id itemId,
+                                           heif_property_id propertyId,
+                                           size_t* out_size);
 
 /**
  * @param out_data User-supplied array to write the property data to. The required size of the output array is given by heif_item_get_property_raw_size().
 */
 LIBHEIF_API
-struct heif_error heif_item_get_property_raw_data(const struct heif_context* context,
-                                                  heif_item_id itemId,
-                                                  heif_property_id propertyId,
-                                                  uint8_t* out_data);
+heif_error heif_item_get_property_raw_data(const heif_context* context,
+                                           heif_item_id itemId,
+                                           heif_property_id propertyId,
+                                           uint8_t* out_data);
 
 /**
  * Get the extended type for an extended "uuid" box.
@@ -182,10 +182,47 @@ struct heif_error heif_item_get_property_raw_data(const struct heif_context* con
  * @return heif_error_success or an error indicating the failure
  */
 LIBHEIF_API
-struct heif_error heif_item_get_property_uuid_type(const struct heif_context* context,
-                                                   heif_item_id itemId,
-                                                   heif_property_id propertyId,
-                                                   uint8_t out_extended_type[16]);
+heif_error heif_item_get_property_uuid_type(const heif_context* context,
+                                            heif_item_id itemId,
+                                            heif_property_id propertyId,
+                                            uint8_t out_extended_type[16]);
+
+
+// ------------------------- intrinsic and extrinsic matrices -------------------------
+
+typedef struct heif_camera_intrinsic_matrix
+{
+  double focal_length_x;
+  double focal_length_y;
+  double principal_point_x;
+  double principal_point_y;
+  double skew;
+} heif_camera_intrinsic_matrix;
+
+
+LIBHEIF_API
+int heif_image_handle_has_camera_intrinsic_matrix(const heif_image_handle* handle);
+
+LIBHEIF_API
+heif_error heif_image_handle_get_camera_intrinsic_matrix(const heif_image_handle* handle,
+                                                         heif_camera_intrinsic_matrix* out_matrix);
+
+
+typedef struct heif_camera_extrinsic_matrix heif_camera_extrinsic_matrix;
+
+LIBHEIF_API
+int heif_image_handle_has_camera_extrinsic_matrix(const heif_image_handle* handle);
+
+LIBHEIF_API
+heif_error heif_image_handle_get_camera_extrinsic_matrix(const heif_image_handle* handle,
+                                                         heif_camera_extrinsic_matrix** out_matrix);
+
+LIBHEIF_API
+void heif_camera_extrinsic_matrix_release(heif_camera_extrinsic_matrix*);
+
+LIBHEIF_API
+heif_error heif_camera_extrinsic_matrix_get_rotation_matrix(const heif_camera_extrinsic_matrix*,
+                                                            double* out_matrix_row_major);
 
 #ifdef __cplusplus
 }