image.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "tinyimg/tinyimg.h"
#include "tinyimg/util.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#pragma region image handling

typedef enum TinyImageFormat
{
    TINYIMG_FORMAT_UNKNOWN = 0,
    TINYIMG_FORMAT_PNG = 1,
    TINYIMG_FORMAT_JPEG = 2,
    TINYIMG_FORMAT_BMP = 3,
    TINYIMG_FORMAT_GIF = 4,
    TINYIMG_FORMAT_TIFF = 5,
    TINYIMG_FORMAT_WEBP = 6,
    TINYIMG_FORMAT_AVIF = 7,
    TINYIMG_FORMAT_HEIF = 8,
} TinyImageFormat;

typedef enum TinyImagePixelType
{
    TINYIMG_PIXEL_GRAY = 0,
    TINYIMG_PIXEL_GRAY_ALPHA = 1,
    TINYIMG_PIXEL_RGB = 2,
    TINYIMG_PIXEL_RGBA = 3,
} TinyImagePixelType;

typedef struct TinyImageMeta TinyImageMeta;

typedef struct {
    uint32_t width;
    uint32_t height;
    uint8_t channels;
    uint8_t quality;
    TinyImageFormat format;
    uint8_t* data;
    TinyImageMeta* meta;
} TinyImage;

typedef struct {
    uint32_t width;
    uint32_t height;
    uint32_t frames;
    TinyImageFormat format;
    uint8_t channels;
    uint8_t bit_depth;
    uint8_t has_alpha;
    uint8_t progressive;
} TinyImageInfo;

typedef struct {
    uint32_t x;
    uint32_t y;
    uint32_t width;
    uint32_t height;
    uint8_t scale_den;
    uint8_t channels;
    uint8_t effort;
} TinyDecodeOpts;

typedef enum TinyEffort
{
    TINYIMG_EFFORT_FANCY = 0,
    TINYIMG_EFFORT_FAST = 1,
} TinyEffort;

typedef struct {
    uint8_t quality;
    uint8_t lossless;
    uint8_t progressive;
    uint8_t strip_metadata;
    uint8_t effort;
} TinyEncodeOpts;

int tiny_image_create(
    TinyImage* image, uint32_t width, uint32_t height, uint8_t channels
);

int tiny_image_probe(
    const uint8_t* buffer, size_t buffer_size, TinyImageInfo* info
);

int tiny_image_load(
    TinyImage* image, const uint8_t* buffer, size_t buffer_size
);

int tiny_image_load_scaled(
    TinyImage* image, const uint8_t* buffer, size_t buffer_size,
    uint32_t max_width, uint32_t max_height
);

int tiny_image_load_region(
    TinyImage* image, const uint8_t* buffer, size_t buffer_size, uint32_t x,
    uint32_t y, uint32_t width, uint32_t height
);

int tiny_image_decode(
    TinyImage* image, const uint8_t* buffer, size_t buffer_size,
    const TinyDecodeOpts* opts
);

int tiny_image_encode(
    const TinyImage* image, TinyImageFormat format, const TinyEncodeOpts* opts,
    TinyWriter* writer
);

int tiny_image_destroy(TinyImage* image);

int tiny_image_gettype(const TinyImage* image, TinyImagePixelType* type);

const char* tiny_format_name(TinyImageFormat format);

const char* tiny_format_extension(TinyImageFormat format);

TinyImageFormat tiny_format_sniff(const uint8_t* buffer, size_t buffer_size);

int tiny_image_getextension(
    const TinyImage* image, char* extension, size_t max_length
);

int tiny_image_getpixel(
    const TinyImage* image, uint32_t x, uint32_t y, uint8_t* pixel
);

int tiny_image_setpixel(
    TinyImage* image, uint32_t x, uint32_t y, const uint8_t* pixel
);

uint32_t tiny_image_info_sizeof(void);

uint32_t tiny_image_sizeof(void);

uint32_t tiny_image_getwidth(const TinyImage* image);

uint32_t tiny_image_getheight(const TinyImage* image);

uint32_t tiny_image_getchannels(const TinyImage* image);

uint8_t* tiny_image_getdata(const TinyImage* image);

uint32_t tiny_image_getsize(const TinyImage* image);
 
#pragma endregion
 
#pragma region image drawing

typedef enum TinyBlendMode
{
    TINYIMG_BLEND_NORMAL = 0,
    TINYIMG_BLEND_REPLACE = 1,
    TINYIMG_BLEND_MULTIPLY = 2,
    TINYIMG_BLEND_SCREEN = 3,
    TINYIMG_BLEND_OVERLAY = 4,
    TINYIMG_BLEND_DARKEN = 5,
    TINYIMG_BLEND_LIGHTEN = 6,
    TINYIMG_BLEND_DIFFERENCE = 7,
    TINYIMG_BLEND_EXCLUSION = 8,
    TINYIMG_BLEND_HARD_LIGHT = 9,
    TINYIMG_BLEND_SOFT_LIGHT = 10,
    TINYIMG_BLEND_ADD = 11,
    TINYIMG_BLEND_SUBTRACT = 12,
} TinyBlendMode;

typedef enum TinyFillRule
{
    TINYIMG_FILL_EVEN_ODD = 0,
    TINYIMG_FILL_NONZERO = 1,
} TinyFillRule;

typedef enum TinyDrawMode
{
    TINYIMG_DRAW_ONCE = 0,
    TINYIMG_DRAW_TILE = 1,
    TINYIMG_DRAW_CENTER = 2,
} TinyDrawMode;

int tiny_image_hline(
    TinyImage* image, int32_t x1, int32_t y1, int32_t x2, int32_t y2,
    const uint8_t* pixel
);

int tiny_image_vline(
    TinyImage* image, int32_t x1, int32_t y1, int32_t x2, int32_t y2,
    const uint8_t* pixel
);

int tiny_image_rectangle(
    TinyImage* image, int32_t x, int32_t y, uint32_t width, uint32_t height,
    const uint8_t* pixel
);

int tiny_image_fill_rectangle(
    TinyImage* image, int32_t x, int32_t y, uint32_t width, uint32_t height,
    const uint8_t* pixel
);

int tiny_image_fill_rounded_rectangle(
    TinyImage* image, int32_t x, int32_t y, uint32_t width, uint32_t height,
    uint32_t radius, const uint8_t* pixel
);

int tiny_image_draw_line(
    TinyImage* image, int32_t x1, int32_t y1, int32_t x2, int32_t y2,
    uint32_t thickness, const uint8_t* pixel
);

int tiny_image_draw_circle(
    TinyImage* image, int32_t center_x, int32_t center_y, uint32_t radius,
    const uint8_t* pixel
);

int tiny_image_fill_circle(
    TinyImage* image, int32_t center_x, int32_t center_y, uint32_t radius,
    const uint8_t* pixel
);

int tiny_image_draw_ellipse(
    TinyImage* image, int32_t center_x, int32_t center_y, uint32_t radius_x,
    uint32_t radius_y, const uint8_t* pixel
);

int tiny_image_fill_ellipse(
    TinyImage* image, int32_t center_x, int32_t center_y, uint32_t radius_x,
    uint32_t radius_y, const uint8_t* pixel
);

int tiny_image_polygon(
    TinyImage* image, const int32_t* x_points, const int32_t* y_points,
    size_t num_points, const uint8_t* pixel
);

int tiny_image_fill_polygon(
    TinyImage* image, const int32_t* x_points, const int32_t* y_points,
    size_t num_points, const uint8_t* pixel
);

int tiny_image_fill_polygon_with(
    TinyImage* image, const int32_t* x_points, const int32_t* y_points,
    size_t num_points, const uint8_t* pixel, TinyFillRule rule,
    TinyBlendMode blend
);

int tiny_image_replace_color(
    TinyImage* image, const uint8_t* old_color, const uint8_t* new_color,
    const uint8_t* tolerance
);

int tiny_image_draw_image(
    TinyImage* dest_image, const TinyImage* src_image, int32_t x, int32_t y
);

int tiny_image_draw_image_ex(
    TinyImage* dest_image, const TinyImage* src_image, int32_t x, int32_t y,
    float opacity, TinyDrawMode mode, TinyBlendMode blend
);

int tiny_image_composite(
    TinyImage* dest_image, const TinyImage* src_image, TinyBlendMode blend
);

int tiny_image_premultiply(TinyImage* image);

int tiny_image_unpremultiply(TinyImage* image);

int tiny_image_gradient_linear(
    TinyImage* image, int32_t x0, int32_t y0, int32_t x1, int32_t y1,
    const uint8_t* from, const uint8_t* to
);

int tiny_image_gradient_radial(
    TinyImage* image, int32_t center_x, int32_t center_y, uint32_t radius,
    const uint8_t* inner, const uint8_t* outer
);

int tiny_image_gradient_fade(
    TinyImage* image, float angle, float start, float end
);

int tiny_image_border(
    TinyImage* image, uint32_t border_width, const uint8_t* pixel
);

int tiny_image_expand(
    TinyImage* image, uint32_t left, uint32_t top, uint32_t right,
    uint32_t bottom, const uint8_t* pixel
);

int tiny_draw_coverage(
    TinyImage* image, int32_t x, int32_t y, const uint8_t* mask, uint32_t width,
    uint32_t height, const uint8_t* color, TinyBlendMode blend
);
 
#pragma endregion
 
#pragma region image display list

#define TINYIMG_DISPLAY_MAX_SHAPES 64

#define TINYIMG_DISPLAY_MAX_POINTS 256

#define TINYIMG_DISPLAY_MAX_DEPTH 8

typedef enum TinyShapeKind
{
    TINYIMG_SHAPE_NONE = 0,
    TINYIMG_SHAPE_RECT = 1,
    TINYIMG_SHAPE_ROUND_RECT = 2,
    TINYIMG_SHAPE_ELLIPSE = 3,
    TINYIMG_SHAPE_LINE = 4,
    TINYIMG_SHAPE_POLYGON = 5,
} TinyShapeKind;

typedef struct {
    TinyShapeKind kind;
    float geometry[5];
    uint32_t point_first;
    uint32_t point_count;
    uint8_t color[4];
    TinyBlendMode blend;
    TinyFillRule rule;
    float transform[6];
} TinyShape;

typedef struct {
    uint32_t count;
    TinyShape shapes[TINYIMG_DISPLAY_MAX_SHAPES];

    uint32_t points;
    float point[TINYIMG_DISPLAY_MAX_POINTS * 2];

    float transform[6];
    uint32_t depth;
    float stack[TINYIMG_DISPLAY_MAX_DEPTH][6];

    TinyBlendMode blend;

    uint32_t culled;
    uint32_t covered;
} TinyDisplayList;

uint32_t tiny_display_sizeof(void);

int tiny_display_init(TinyDisplayList* list);

int tiny_display_save(TinyDisplayList* list);

int tiny_display_restore(TinyDisplayList* list);

int tiny_display_translate(TinyDisplayList* list, float x, float y);

int tiny_display_scale(TinyDisplayList* list, float x, float y);

int tiny_display_rotate(TinyDisplayList* list, float degrees);

int tiny_display_set_transform(TinyDisplayList* list, const float* matrix);

int tiny_display_rect(
    TinyDisplayList* list, float x, float y, float width, float height,
    const uint8_t* color
);

int tiny_display_round_rect(
    TinyDisplayList* list, float x, float y, float width, float height,
    float radius, const uint8_t* color
);

int tiny_display_ellipse(
    TinyDisplayList* list, float center_x, float center_y, float radius_x,
    float radius_y, const uint8_t* color
);

int tiny_display_line(
    TinyDisplayList* list, float x1, float y1, float x2, float y2,
    float thickness, const uint8_t* color
);

int tiny_display_polygon(
    TinyDisplayList* list, const float* x_points, const float* y_points,
    size_t num_points, const uint8_t* color, TinyFillRule rule
);

int tiny_display_blend(TinyDisplayList* list, TinyBlendMode blend);

int tiny_display_render(TinyDisplayList* list, TinyImage* image);

uint32_t tiny_display_culled(const TinyDisplayList* list);

uint32_t tiny_display_covered(const TinyDisplayList* list);

int tiny_display_bounds(
    const TinyDisplayList* list, int32_t* x, int32_t* y, uint32_t* width,
    uint32_t* height
);
 
#pragma endregion
 
#pragma region image manipulation

int tiny_image_resize(
    TinyImage* image, uint32_t new_width, uint32_t new_height
);

int tiny_image_crop(
    TinyImage* image, uint32_t x, uint32_t y, uint32_t crop_width,
    uint32_t crop_height
);

int tiny_image_crop_circle(
    TinyImage* image, uint32_t center_x, uint32_t center_y, uint32_t radius
);

int tiny_image_crop_ellipse(
    TinyImage* image, uint32_t center_x, uint32_t center_y, uint32_t radius_x,
    uint32_t radius_y
);

int tiny_image_crop_polygon(
    TinyImage* image, const uint32_t* x_points, const uint32_t* y_points,
    size_t num_points
);

int tiny_image_flip_horizontal(TinyImage* image);

int tiny_image_flip_vertical(TinyImage* image);

int tiny_image_rotate_90(TinyImage* image);

int tiny_image_rotate_180(TinyImage* image);

int tiny_image_rotate_270(TinyImage* image);

int tiny_image_opacity(TinyImage* image, float opacity);

int tiny_image_trim(TinyImage* image, uint8_t tolerance);
 
#pragma endregion
 
#pragma region image transformations

int tiny_image_invert(TinyImage* image);

int tiny_image_quality(TinyImage* image, int quality);

int tiny_image_blur(TinyImage* image, float radius);

int tiny_image_sharpen(TinyImage* image, float amount);

int tiny_image_brightness(TinyImage* image, float factor);

int tiny_image_contrast(TinyImage* image, float factor);

int tiny_image_dpr(TinyImage* image, float dpr);

int tiny_image_saturation(TinyImage* image, float factor);

int tiny_image_hue(TinyImage* image, float angle);

typedef enum TinyImageFit
{
    TINYIMG_FIT_SCALE_DOWN = 0,
    TINYIMG_FIT_CONTAIN = 1,
    TINYIMG_FIT_COVER = 2,
    TINYIMG_FIT_CROP = 3,
    TINYIMG_FIT_ASPECT_CROP = 4,
    TINYIMG_FIT_ASPECT_CONTAIN = 5,
    TINYIMG_FIT_ASPECT_COVER = 6,
    TINYIMG_FIT_PAD = 7,
    TINYIMG_FIT_STRETCH = 8,
    TINYIMG_FIT_FILL = 9,
    TINYIMG_FIT_SCALE_UP = 10,
} TinyImageFit;

typedef enum TinyImageGravity
{
    TINYIMG_GRAVITY_CENTER = 0,
    TINYIMG_GRAVITY_NORTH = 1,
    TINYIMG_GRAVITY_SOUTH = 2,
    TINYIMG_GRAVITY_WEST = 3,
    TINYIMG_GRAVITY_EAST = 4,
    TINYIMG_GRAVITY_NORTH_WEST = 5,
    TINYIMG_GRAVITY_NORTH_EAST = 6,
    TINYIMG_GRAVITY_SOUTH_WEST = 7,
    TINYIMG_GRAVITY_SOUTH_EAST = 8,
    TINYIMG_GRAVITY_AUTO = 9,
    TINYIMG_GRAVITY_FACE = 10,
} TinyImageGravity;

int tiny_image_fit(
    TinyImage* image, uint32_t target_width, uint32_t target_height,
    TinyImageFit fit_mode
);

int tiny_image_fit_with_padding(
    TinyImage* image, uint32_t target_width, uint32_t target_height,
    TinyImageFit fit_mode, const uint8_t* padding_color
);

int tiny_image_fit_with_padding_and_background(
    TinyImage* image, uint32_t target_width, uint32_t target_height,
    TinyImageFit fit_mode, const uint8_t* padding_color,
    const uint8_t* background_color
);

int tiny_image_fit_with_gravity(
    TinyImage* image, uint32_t target_width, uint32_t target_height,
    TinyImageFit fit_mode, TinyImageGravity gravity, const uint8_t* background
);

int tiny_image_gamma_correction(TinyImage* image, float gamma);

int tiny_image_apply_sepia(TinyImage* image);

int tiny_image_remove_background(TinyImage* image, uint8_t tolerance);

int tiny_image_zoom(TinyImage* image, float zoom_factor);

int tiny_image_darken(
    TinyImage* image, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
    float factor
);

int tiny_image_lighten(
    TinyImage* image, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
    float factor
);

int tiny_image_gaussian_blur(TinyImage* image, float sigma);

int tiny_image_vignette(
    TinyImage* image, float radius, float strength, const uint8_t* color
);

int tiny_image_color_overlay(
    TinyImage* image, const uint8_t* color, float opacity
);

int tiny_image_color_overlay_rect(
    TinyImage* image, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
    const uint8_t* color, float opacity
);
 
#pragma endregion
 
#pragma region image effects

typedef enum TinyColorblindKind
{
    TINYIMG_COLORBLIND_PROTANOPIA = 0,
    TINYIMG_COLORBLIND_DEUTERANOPIA = 1,
    TINYIMG_COLORBLIND_TRITANOPIA = 2,
    TINYIMG_COLORBLIND_ACHROMATOPSIA = 3,
} TinyColorblindKind;

typedef enum TinyImagePreset
{
    TINYIMG_PRESET_NOIR = 0,
    TINYIMG_PRESET_CHROME = 1,
    TINYIMG_PRESET_MONO = 2,
    TINYIMG_PRESET_FADE = 3,
    TINYIMG_PRESET_VIVID = 4,
    TINYIMG_PRESET_WARM = 5,
    TINYIMG_PRESET_COOL = 6,
    TINYIMG_PRESET_INSTANT = 7,
    TINYIMG_PRESET_TONAL = 8,
} TinyImagePreset;

int tiny_image_apply_matrix(TinyImage* image, const float* matrix);

int tiny_image_apply_lut(TinyImage* image, const uint8_t* lut);

int tiny_image_apply_luts(
    TinyImage* image, const uint8_t* red, const uint8_t* green,
    const uint8_t* blue
);

int tiny_image_curves(
    TinyImage* image, const uint8_t* x_points, const uint8_t* y_points,
    size_t num_points
);

int tiny_image_negate(TinyImage* image);

int tiny_image_blackwhite(TinyImage* image);

int tiny_image_colorize(TinyImage* image, const uint8_t* color, float strength);

int tiny_image_tint(TinyImage* image, const uint8_t* color, float strength);

int tiny_image_posterize(TinyImage* image, uint32_t levels);

int tiny_image_threshold(TinyImage* image, uint8_t level);

int tiny_image_solarize(TinyImage* image, uint8_t level);

int tiny_image_duotone(
    TinyImage* image, const uint8_t* shadow, const uint8_t* highlight
);

int tiny_image_split_tone(
    TinyImage* image, const uint8_t* shadow, const uint8_t* highlight,
    float balance
);

int tiny_image_exposure(TinyImage* image, float stops);

int tiny_image_fill_light(TinyImage* image, float amount);

int tiny_image_temperature(TinyImage* image, float amount);

int tiny_image_white_balance(TinyImage* image, float temperature, float tint);

int tiny_image_vibrance(TinyImage* image, float amount);

int tiny_image_levels(
    TinyImage* image, float in_black, float in_white, float gamma,
    float out_black, float out_white
);

int tiny_image_levels_channel(
    TinyImage* image, uint8_t channel, float in_black, float in_white,
    float gamma, float out_black, float out_white
);

int tiny_image_color_balance(
    TinyImage* image, const float* shadows, const float* midtones,
    const float* highlights
);

int tiny_image_channel_mixer(TinyImage* image, const float* matrix);

int tiny_image_channel_gain(
    TinyImage* image, float red, float green, float blue
);

int tiny_image_colorblind_simulate(TinyImage* image, TinyColorblindKind kind);

int tiny_image_colorblind_assist(TinyImage* image, TinyColorblindKind kind);

int tiny_image_preset(TinyImage* image, TinyImagePreset preset);
 
#pragma endregion
 
#pragma region image spatial effects

int tiny_image_unsharp_mask(
    TinyImage* image, float sigma, float amount, float threshold
);

int tiny_image_clarity(TinyImage* image, float amount);

int tiny_image_sobel(TinyImage* image);

int tiny_image_emboss(TinyImage* image, float strength);

int tiny_image_pixelate(TinyImage* image, uint32_t size);

int tiny_image_pixelate_region(
    TinyImage* image, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
    uint32_t size
);

int tiny_image_despeckle(TinyImage* image);

int tiny_image_dilate(TinyImage* image, uint32_t radius);

int tiny_image_erode(TinyImage* image, uint32_t radius);

int tiny_image_morphology_open(TinyImage* image, uint32_t radius);

int tiny_image_morphology_close(TinyImage* image, uint32_t radius);

int tiny_image_outline(TinyImage* image, uint32_t radius);

int tiny_image_motion_blur(TinyImage* image, float length, float angle);

int tiny_image_radial_blur(TinyImage* image, float degrees);

int tiny_image_zoom_blur(TinyImage* image, float strength);

int tiny_image_tilt_shift(TinyImage* image, float sigma, float band);

int tiny_image_blur_region(
    TinyImage* image, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
    float sigma
);

int tiny_image_drop_shadow(
    TinyImage* image, int32_t offset_x, int32_t offset_y, float sigma,
    const uint8_t* color
);

int tiny_image_glow(TinyImage* image, float sigma, float strength);

int tiny_image_noise(TinyImage* image, float amount, int monochrome);

int tiny_image_film_grain(TinyImage* image, float amount);

int tiny_image_dither(TinyImage* image, uint32_t levels);

int tiny_image_halftone(TinyImage* image, uint32_t cell);

int tiny_image_chromatic_aberration(TinyImage* image, float amount);

int tiny_image_scanlines(TinyImage* image, uint32_t period, float strength);
 
#pragma endregion
 
#pragma region image auto correction

int tiny_image_auto_brightness(TinyImage* image);

int tiny_image_auto_contrast(TinyImage* image);

int tiny_image_auto_color(TinyImage* image);

int tiny_image_auto_levels(TinyImage* image);

int tiny_image_auto_gamma(TinyImage* image);

int tiny_image_improve(TinyImage* image);

int tiny_image_shadows_highlights(
    TinyImage* image, float shadows, float highlights
);

int tiny_image_dehaze(TinyImage* image, float strength);
 
#pragma endregion
 
#pragma region image warps

int tiny_image_shear(
    TinyImage* image, float shear_x, float shear_y, const uint8_t* background
);

int tiny_image_rotate(
    TinyImage* image, float degrees, const uint8_t* background
);

int tiny_image_perspective(
    TinyImage* image, const float* quad, const uint8_t* background
);

int tiny_image_arc(TinyImage* image, float degrees, const uint8_t* background);

int tiny_image_barrel(TinyImage* image, float amount);

int tiny_image_swirl(TinyImage* image, float degrees);

int tiny_image_polar(TinyImage* image, int inverse);

int tiny_image_corner_radius(TinyImage* image, uint32_t radius);
 
#pragma endregion
 
#pragma region image analysis

int tiny_image_histogram(
    const TinyImage* image, uint8_t channel, uint32_t* bins
);

int tiny_image_dominant_color(const TinyImage* image, uint8_t* color);

int tiny_image_palette(
    const TinyImage* image, uint32_t count, uint8_t* palette
);

int tiny_image_average_color(const TinyImage* image, uint8_t* color);

int tiny_image_phash(const TinyImage* image, uint64_t* hash);

uint32_t tiny_phash_distance(uint64_t first, uint64_t second);

int tiny_image_focus(
    const TinyImage* image, TinyImageGravity gravity, float* x, float* y
);

int tiny_image_blur_faces(TinyImage* image, float sigma);

int tiny_image_pixelate_faces(TinyImage* image, uint32_t size);
 
#pragma endregion
 
#pragma region image metadata

int tiny_image_set_exif(
    TinyImage* image, const char* exif_data, size_t exif_size
);

int tiny_image_get_exif(
    const TinyImage* image, char** exif_data, size_t* exif_size
);

int tiny_image_has_exif(const TinyImage* image);

int tiny_image_strip_exif(TinyImage* image);

int tiny_image_set_metadata(
    TinyImage* image, const char* key, const char* value
);

int tiny_image_get_metadata(
    const TinyImage* image, const char* key, char** value
);

int tiny_image_has_metadata(const TinyImage* image, const char* key);

int tiny_image_remove_metadata(TinyImage* image, const char* key);

int tiny_image_get_metadata_count(const TinyImage* image, size_t* count);
 
#pragma endregion
 
#pragma region image conversion

int tiny_image_to_rgb(TinyImage* image);

int tiny_image_to_rgba(TinyImage* image);

int tiny_image_to_grayscale(TinyImage* image);

int tiny_image_convert_channels(TinyImage* image, uint8_t channels);

int tiny_image_convert(TinyImage* image, TinyImageFormat format);

int tiny_image_istransparent(const TinyImage* image);

int tiny_image_set_transparent(TinyImage* image, int enable_transparency);

TinyImageFormat tiny_image_getformat(const TinyImage* image);
 
#pragma endregion
 
#ifdef __cplusplus
}
#endif