@img/sharp-libvips-dev 0.0.1

package/include/libheif/heif_plugin.h

@@ -0,0 +1,306 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ *
+ * 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_PLUGIN_H
+#define LIBHEIF_HEIF_PLUGIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <libheif/heif.h>
+
+
+// ====================================================================================================
+//  This file is for codec plugin developers only.
+// ====================================================================================================
+
+// API versions table
+//
+// release    decoder   encoder   enc.params
+// -----------------------------------------
+//  1.0          1        N/A        N/A
+//  1.1          1         1          1
+//  1.4          1         1          2
+//  1.8          1         2          2
+//  1.13         2         3          2
+//  1.15         3         3          2
+
+
+// ====================================================================================================
+//  Decoder plugin API
+//  In order to decode images in other formats than HEVC, additional compression codecs can be
+//  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
+{
+  // API version supported by this plugin (see table above for supported versions)
+  int plugin_api_version;
+
+
+  // --- version 1 functions ---
+
+  // Human-readable name of the plugin
+  const char* (* get_plugin_name)();
+
+  // Global plugin initialization (may be NULL)
+  void (* init_plugin)();
+
+  // Global plugin deinitialization (may be NULL)
+  void (* deinit_plugin)();
+
+  // Query whether the plugin supports decoding of the given format
+  // Result is a priority value. The plugin with the largest value wins.
+  // Default priority is 100. Returning 0 indicates that the plugin cannot decode this format.
+  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);
+
+  // 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);
+
+
+  // --- 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);
+
+
+  // --- version 2 functions will follow below ... ---
+
+  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.
+  /*
+  struct heif_error (*convert_YCbCr_to_sRGB)(void* decoder,
+                                             struct heif_image* in_YCbCr_img,
+                                             struct heif_image** out_sRGB_img);
+
+  */
+
+  // Reset decoder, such that we can feed in new data for another image.
+  // void (*reset_image)(void* decoder);
+
+  // --- version 3 functions will follow below ... ---
+
+  const char* id_name;
+
+  // --- version 4 functions will follow below ... ---
+};
+
+
+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
+};
+
+
+// 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
+{
+  heif_image_input_class_normal = 1,
+  heif_image_input_class_alpha = 2,
+  heif_image_input_class_depth = 3,
+  heif_image_input_class_thumbnail = 4
+};
+
+
+struct heif_encoder_plugin
+{
+  // API version supported by this plugin (see table above for supported versions)
+  int plugin_api_version;
+
+
+  // --- version 1 functions ---
+
+  // The compression format generated by this plugin.
+  enum heif_compression_format compression_format;
+
+  // Short name of the encoder that can be used as command line parameter when selecting an encoder.
+  // Hence, it should stay stable and not contain any version numbers that will change.
+  const char* id_name;
+
+  // Default priority is 100.
+  int priority;
+
+
+  // Feature support
+  int supports_lossy_compression;
+  int supports_lossless_compression;
+
+
+  // Human-readable name of the plugin
+  const char* (* get_plugin_name)();
+
+  // Global plugin initialization (may be NULL)
+  void (* init_plugin)();
+
+  // Global plugin cleanup (may be NULL).
+  // Free data that was allocated in init_plugin()
+  void (* cleanup_plugin)();
+
+  // Create a new decoder context for decoding an image
+  struct 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);
+
+  struct heif_error (* get_parameter_quality)(void* encoder, int* quality);
+
+  struct heif_error (* set_parameter_lossless)(void* encoder, int lossless);
+
+  struct heif_error (* get_parameter_lossless)(void* encoder, int* lossless);
+
+  struct heif_error (* set_parameter_logging_level)(void* encoder, int logging);
+
+  struct heif_error (* get_parameter_logging_level)(void* encoder, int* logging);
+
+  const struct heif_encoder_parameter** (* list_parameters)(void* encoder);
+
+  struct 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);
+
+  struct 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);
+
+  struct 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);
+
+  // 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.
+  void (* query_input_colorspace)(enum heif_colorspace* inout_colorspace,
+                                  enum heif_chroma* inout_chroma);
+
+  // 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);
+
+  // 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,
+                                            enum heif_encoded_data_type* type);
+
+
+  // --- version 2 ---
+
+  void (* query_input_colorspace2)(void* encoder,
+                                   enum heif_colorspace* inout_colorspace,
+                                   enum heif_chroma* inout_chroma);
+
+  // --- version 3 ---
+
+  // The encoded image size may be different from the input frame size, e.g. because
+  // of required rounding, or a required minimum size. Use this function to return
+  // the encoded size for a given input image size.
+  // You may set this to NULL if no padding is required for any image size.
+  void (* query_encoded_size)(void* encoder, uint32_t input_width, uint32_t input_height,
+                              uint32_t* encoded_width, uint32_t* encoded_height);
+
+  // --- version 4 functions will follow below ... ---
+};
+
+
+// Names for standard parameters. These should only be used by the encoder plugins.
+#define heif_encoder_parameter_name_quality  "quality"
+#define heif_encoder_parameter_name_lossless "lossless"
+
+// For use only by the encoder plugins.
+// Application programs should use the access functions.
+// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
+struct heif_encoder_parameter
+{
+  int version; // current version: 2
+
+  // --- version 1 fields ---
+
+  const char* name;
+  enum heif_encoder_parameter_type type;
+
+  union
+  {
+    struct
+    {
+      int default_value;
+
+      uint8_t have_minimum_maximum; // bool
+      int minimum;
+      int maximum;
+
+      int* valid_values;
+      int num_valid_values;
+    } integer;
+
+    struct
+    {
+      const char* default_value;
+
+      const char* const* valid_values;
+    } string; // NOLINT
+
+    struct
+    {
+      int default_value;
+    } boolean;
+  };
+
+  // --- version 2 fields
+
+  int has_default;
+};
+
+
+extern struct heif_error heif_error_ok;
+extern struct heif_error heif_error_unsupported_parameter;
+extern struct heif_error heif_error_invalid_parameter_value;
+
+#define HEIF_WARN_OR_FAIL(strict, image, cmd, cleanupBlock) \
+{ struct heif_error e = cmd;                  \
+  if (e.code != heif_error_Ok) {              \
+    if (strict) {                             \
+      cleanupBlock                            \
+      return e;                               \
+    }                                         \
+    else {                                    \
+      heif_image_add_decoding_warning(image, e); \
+    }                                         \
+  }                                           \
+}
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/include/libheif/heif_version.h

@@ -0,0 +1,38 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2017 struktur AG, Dirk Farin <farin@struktur.de>
+ *
+ * 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) | (16<<16) | (2<<8) | 0)
+
+/* Version string */
+#define LIBHEIF_VERSION "1.16.2"
+
+#define LIBHEIF_PLUGIN_DIRECTORY "/target/lib/libheif"
+
+#endif  // LIBHEIF_HEIF_VERSION_H

package/include/libimagequant.h

@@ -0,0 +1,111 @@
+/*
+ * http://pngquant.org
+ */
+
+#ifndef LIBIMAGEQUANT_H
+#define LIBIMAGEQUANT_H
+
+#ifndef LIQ_EXPORT
+#define LIQ_EXPORT extern
+#endif
+
+#define LIQ_VERSION 20401
+#define LIQ_VERSION_STRING "2.4.1"
+
+#ifndef LIQ_PRIVATE
+#if defined(__GNUC__) || defined (__llvm__)
+#define LIQ_PRIVATE __attribute__((visibility("hidden")))
+#else
+#define LIQ_PRIVATE
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+typedef struct liq_attr liq_attr;
+typedef struct liq_image liq_image;
+typedef struct liq_result liq_result;
+
+typedef struct liq_color {
+    unsigned char r, g, b, a;
+} liq_color;
+
+typedef struct liq_palette {
+    unsigned int count;
+    liq_color entries[256];
+} liq_palette;
+
+typedef enum liq_error {
+    LIQ_OK = 0,
+    LIQ_QUALITY_TOO_LOW = 99,
+    LIQ_VALUE_OUT_OF_RANGE = 100,
+    LIQ_OUT_OF_MEMORY,
+    LIQ_NOT_READY,
+    LIQ_BITMAP_NOT_AVAILABLE,
+    LIQ_BUFFER_TOO_SMALL,
+    LIQ_INVALID_POINTER,
+} liq_error;
+
+enum liq_ownership {LIQ_OWN_ROWS=4, LIQ_OWN_PIXELS=8};
+
+LIQ_EXPORT liq_attr* liq_attr_create(void);
+LIQ_EXPORT liq_attr* liq_attr_create_with_allocator(void* (*malloc)(size_t), void (*free)(void*));
+LIQ_EXPORT liq_attr* liq_attr_copy(liq_attr *orig);
+LIQ_EXPORT void liq_attr_destroy(liq_attr *attr);
+
+LIQ_EXPORT liq_error liq_set_max_colors(liq_attr* attr, int colors);
+LIQ_EXPORT int liq_get_max_colors(const liq_attr* attr);
+LIQ_EXPORT liq_error liq_set_speed(liq_attr* attr, int speed);
+LIQ_EXPORT int liq_get_speed(const liq_attr* attr);
+LIQ_EXPORT liq_error liq_set_min_opacity(liq_attr* attr, int min);
+LIQ_EXPORT int liq_get_min_opacity(const liq_attr* attr);
+LIQ_EXPORT liq_error liq_set_min_posterization(liq_attr* attr, int bits);
+LIQ_EXPORT int liq_get_min_posterization(const liq_attr* attr);
+LIQ_EXPORT liq_error liq_set_quality(liq_attr* attr, int minimum, int maximum);
+LIQ_EXPORT int liq_get_min_quality(const liq_attr* attr);
+LIQ_EXPORT int liq_get_max_quality(const liq_attr* attr);
+LIQ_EXPORT void liq_set_last_index_transparent(liq_attr* attr, int is_last);
+
+typedef void liq_log_callback_function(const liq_attr*, const char *message, void* user_info);
+typedef void liq_log_flush_callback_function(const liq_attr*, void* user_info);
+LIQ_EXPORT void liq_set_log_callback(liq_attr*, liq_log_callback_function*, void* user_info);
+LIQ_EXPORT void liq_set_log_flush_callback(liq_attr*, liq_log_flush_callback_function*, void* user_info);
+
+LIQ_EXPORT liq_image *liq_image_create_rgba_rows(liq_attr *attr, void* rows[], int width, int height, double gamma);
+LIQ_EXPORT liq_image *liq_image_create_rgba(liq_attr *attr, void* bitmap, int width, int height, double gamma);
+
+typedef void liq_image_get_rgba_row_callback(liq_color row_out[], int row, int width, void* user_info);
+LIQ_EXPORT liq_image *liq_image_create_custom(liq_attr *attr, liq_image_get_rgba_row_callback *row_callback, void* user_info, int width, int height, double gamma);
+
+LIQ_EXPORT liq_error liq_image_set_memory_ownership(liq_image *image, int ownership_flags);
+LIQ_EXPORT liq_error liq_image_add_fixed_color(liq_image *img, liq_color color);
+LIQ_EXPORT int liq_image_get_width(const liq_image *img);
+LIQ_EXPORT int liq_image_get_height(const liq_image *img);
+LIQ_EXPORT void liq_image_destroy(liq_image *img);
+
+LIQ_EXPORT liq_result *liq_quantize_image(liq_attr *options, liq_image *input_image);
+LIQ_EXPORT liq_error liq_image_quantize(liq_image *const input_image, liq_attr *const options, liq_result **result);
+
+LIQ_EXPORT liq_error liq_set_dithering_level(liq_result *res, float dither_level);
+LIQ_EXPORT liq_error liq_set_output_gamma(liq_result* res, double gamma);
+LIQ_EXPORT double liq_get_output_gamma(const liq_result *result);
+
+LIQ_EXPORT const liq_palette *liq_get_palette(liq_result *result);
+
+LIQ_EXPORT liq_error liq_write_remapped_image(liq_result *result, liq_image *input_image, void *buffer, size_t buffer_size);
+LIQ_EXPORT liq_error liq_write_remapped_image_rows(liq_result *result, liq_image *input_image, unsigned char **row_pointers);
+
+LIQ_EXPORT double liq_get_quantization_error(liq_result *result);
+LIQ_EXPORT int liq_get_quantization_quality(liq_result *result);
+
+LIQ_EXPORT void liq_result_destroy(liq_result *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif