plan.h

Go to the documentation of this file.

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

#define TINYIMG_PLAN_MAX_OPS 32
 
#pragma region the ir

typedef enum TinyPlanOpKind
{
    TINYIMG_OP_NONE = 0,
    TINYIMG_OP_CROP = 1,
    TINYIMG_OP_RESIZE = 2,
    TINYIMG_OP_FIT = 3,
    TINYIMG_OP_FLIP_H = 4,
    TINYIMG_OP_FLIP_V = 5,
    TINYIMG_OP_ROTATE = 6,
    TINYIMG_OP_BRIGHTNESS = 7,
    TINYIMG_OP_CONTRAST = 8,
    TINYIMG_OP_SATURATION = 9,
    TINYIMG_OP_HUE = 10,
    TINYIMG_OP_GRAYSCALE = 11,
    TINYIMG_OP_INVERT = 12,
    TINYIMG_OP_GAMMA = 13,
    TINYIMG_OP_BLUR = 14,
    TINYIMG_OP_MATRIX = 15,
    TINYIMG_OP_CURVE = 16,
    TINYIMG_OP_EFFECT = 17,
} TinyPlanOpKind;

typedef enum TinyCurveKind
{
    TINYIMG_CURVE_GAMMA = 0,
    TINYIMG_CURVE_POSTERIZE = 1,
    TINYIMG_CURVE_THRESHOLD = 2,
    TINYIMG_CURVE_SOLARIZE = 3,
    TINYIMG_CURVE_EXPOSURE = 4,
    TINYIMG_CURVE_LEVELS = 5,
    TINYIMG_CURVE_FILL_LIGHT = 6,
    TINYIMG_CURVE_GAIN = 7,
    TINYIMG_CURVE_SIGMOID = 8,
    TINYIMG_CURVE_NEGATE = 9,
    TINYIMG_CURVE_SRGB = 10,
    TINYIMG_CURVE_BALANCE = 11,
} TinyCurveKind;

typedef enum TinyEffectKind
{
    TINYIMG_FX_UNSHARP = 0,
    TINYIMG_FX_CLARITY = 1,
    TINYIMG_FX_SOBEL = 2,
    TINYIMG_FX_EMBOSS = 3,
    TINYIMG_FX_PIXELATE = 4,
    TINYIMG_FX_MEDIAN = 5,
    TINYIMG_FX_DILATE = 6,
    TINYIMG_FX_ERODE = 7,
    TINYIMG_FX_OUTLINE = 8,
    TINYIMG_FX_MOTION_BLUR = 9,
    TINYIMG_FX_RADIAL_BLUR = 10,
    TINYIMG_FX_ZOOM_BLUR = 11,
    TINYIMG_FX_TILT_SHIFT = 12,
    TINYIMG_FX_BLUR_REGION = 13,
    TINYIMG_FX_PIXELATE_REGION = 14,
    TINYIMG_FX_CHROMATIC = 15,
    TINYIMG_FX_DITHER = 16,
    TINYIMG_FX_HALFTONE = 17,
    TINYIMG_FX_SCANLINES = 18,
} TinyEffectKind;

typedef enum TinyPlanOpClass
{
    TINYIMG_OP_CLASS_GEOMETRY = 0,
    TINYIMG_OP_CLASS_COLOR_MATRIX = 1,
    TINYIMG_OP_CLASS_COLOR_LUT = 2,
    TINYIMG_OP_CLASS_NEIGHBORHOOD = 3,
} TinyPlanOpClass;

typedef enum TinyResampleFilter
{
    TINYIMG_FILTER_AUTO = 0,
    TINYIMG_FILTER_NEAREST = 1,
    TINYIMG_FILTER_BILINEAR = 2,
    TINYIMG_FILTER_BOX = 3,
    TINYIMG_FILTER_CATMULL_ROM = 4,
} TinyResampleFilter;

typedef struct {
    TinyPlanOpKind kind;

    union {
        struct {
            uint32_t x;
            uint32_t y;
            uint32_t width;
            uint32_t height;
        } crop; 
 
        struct {
            uint32_t width;
            uint32_t height;
            TinyResampleFilter filter;
        } resize; 
 
        struct {
            uint32_t width;
            uint32_t height;
            TinyImageFit mode;
            TinyImageGravity gravity;
            float focus_x;
            float focus_y;
            uint8_t focused;
            TinyResampleFilter filter;
        } fit; 
 
        struct {
            uint32_t turns;
        } rotate; 
 
        struct {
            float amount;
            uint8_t gaussian;
        } blur; 
 
        struct {
            float m[12];
        } matrix; 
 
        struct {
            TinyCurveKind kind;
            float p[5];
            uint8_t channels;
        } curve; 
 
        struct {
            TinyEffectKind kind;
            float p[4];
            uint32_t x;
            uint32_t y;
            uint32_t width;
            uint32_t height;
        } effect; 
 
        struct {
            float value;
        } scalar; 

    };
} TinyPlanOp;

typedef struct {
    const uint8_t* buffer;
    size_t size;
    const TinyImage* image;

    uint32_t source_width;
    uint32_t source_height;
    uint8_t source_channels;
    TinyImageFormat source_format;

    uint8_t fusion;
    uint8_t effort;
    uint8_t background[4];

    uint32_t count;
    TinyPlanOp ops[TINYIMG_PLAN_MAX_OPS];
} TinyPlan;
 
#pragma endregion
 
#pragma region resolution

typedef enum TinyPlanKernel
{
    TINYIMG_KERNEL_REGION = 1 << 0,
    TINYIMG_KERNEL_SCALED = 1 << 1,
    TINYIMG_KERNEL_COPY = 1 << 2,
    TINYIMG_KERNEL_RESAMPLE = 1 << 3,
    TINYIMG_KERNEL_ORIENT = 1 << 4,
    TINYIMG_KERNEL_COLOR = 1 << 5,
    TINYIMG_KERNEL_PAD = 1 << 6,
    TINYIMG_KERNEL_GRAY_DECODE = 1 << 7,
    TINYIMG_KERNEL_NEIGHBORHOOD = 1 << 8,
} TinyPlanKernel;

typedef struct {
    TinyDecodeOpts decode;
    uint32_t decode_width;
    uint32_t decode_height;

    double source_x;
    double source_y;
    double source_width;
    double source_height;

    uint32_t sample_width;
    uint32_t sample_height;
    TinyResampleFilter filter_x;
    TinyResampleFilter filter_y;

    int8_t orientation[4];

    uint32_t width;
    uint32_t height;
    uint8_t channels;
    uint32_t offset_x;
    uint32_t offset_y;

    uint32_t ops;
    TinyPlanOp op[TINYIMG_PLAN_MAX_OPS];
    uint32_t eliminated;
    uint32_t collapsed;
    uint32_t color_stages;
    uint32_t color_stages_before;
    uint32_t consumed;
    uint32_t passes;
    uint32_t kernels;
} TinyPlanResolution;

typedef struct {
    TinyPlanOpClass kind;
    int32_t matrix[12];
    uint8_t lut[3][256];
} TinyColorStage;
 
#pragma endregion
 
#pragma region building

uint32_t tiny_plan_sizeof(void);

uint32_t tiny_plan_resolution_sizeof(void);

int tiny_plan_init(TinyPlan* plan, const uint8_t* buffer, size_t size);

int tiny_plan_init_image(TinyPlan* plan, const TinyImage* image);

int tiny_plan_set_fusion(TinyPlan* plan, int enabled);

int tiny_plan_set_effort(TinyPlan* plan, uint8_t effort);

int tiny_plan_background(TinyPlan* plan, const uint8_t* color);

int tiny_plan_crop(
    TinyPlan* plan, uint32_t x, uint32_t y, uint32_t width, uint32_t height
);

int tiny_plan_resize(TinyPlan* plan, uint32_t width, uint32_t height);

int tiny_plan_resize_with(
    TinyPlan* plan, uint32_t width, uint32_t height, TinyResampleFilter filter
);

int tiny_plan_fit(
    TinyPlan* plan, uint32_t width, uint32_t height, TinyImageFit mode,
    TinyImageGravity gravity
);

int tiny_plan_fit_with(
    TinyPlan* plan, uint32_t width, uint32_t height, TinyImageFit mode,
    TinyImageGravity gravity, TinyResampleFilter filter
);

int tiny_plan_flip_horizontal(TinyPlan* plan);

int tiny_plan_flip_vertical(TinyPlan* plan);

int tiny_plan_rotate(TinyPlan* plan, int32_t degrees);

int tiny_plan_brightness(TinyPlan* plan, float factor);

int tiny_plan_contrast(TinyPlan* plan, float factor);

int tiny_plan_saturation(TinyPlan* plan, float factor);

int tiny_plan_hue(TinyPlan* plan, float degrees);

int tiny_plan_grayscale(TinyPlan* plan);

int tiny_plan_invert(TinyPlan* plan);

int tiny_plan_gamma(TinyPlan* plan, float gamma);

int tiny_plan_blur(TinyPlan* plan, float radius);

int tiny_plan_gaussian_blur(TinyPlan* plan, float sigma);

int tiny_plan_matrix(TinyPlan* plan, const float* matrix);

int tiny_plan_curve(
    TinyPlan* plan, TinyCurveKind kind, const float* params, uint8_t channels
);

int tiny_plan_effect(TinyPlan* plan, TinyEffectKind kind, const float* params);

int tiny_plan_effect_rect(
    TinyPlan* plan, TinyEffectKind kind, const float* params, uint32_t x,
    uint32_t y, uint32_t width, uint32_t height
);
 
#pragma endregion
 
#pragma region inspecting

uint32_t tiny_plan_count(const TinyPlan* plan);

int tiny_plan_op_at(const TinyPlan* plan, uint32_t index, TinyPlanOp* op);

TinyPlanOpClass tiny_plan_op_class(TinyPlanOpKind kind);

uint32_t tiny_plan_cost(const TinyPlan* plan);

uint32_t tiny_encode_cost(
    TinyImageFormat format, uint32_t width, uint32_t height
);

typedef enum TinyPlanField
{
    TINYIMG_FIELD_REGION_X = 0,
    TINYIMG_FIELD_REGION_Y = 1,
    TINYIMG_FIELD_REGION_WIDTH = 2,
    TINYIMG_FIELD_REGION_HEIGHT = 3,
    TINYIMG_FIELD_SCALE = 4,
    TINYIMG_FIELD_DECODE_WIDTH = 5,
    TINYIMG_FIELD_DECODE_HEIGHT = 6,
    TINYIMG_FIELD_WIDTH = 7,
    TINYIMG_FIELD_HEIGHT = 8,
    TINYIMG_FIELD_CHANNELS = 9,
    TINYIMG_FIELD_OPS = 10,
    TINYIMG_FIELD_ELIMINATED = 11,
    TINYIMG_FIELD_COLLAPSED = 12,
    TINYIMG_FIELD_COLOR_STAGES = 13,
    TINYIMG_FIELD_PASSES = 14,
    TINYIMG_FIELD_KERNELS = 15,
} TinyPlanField;

uint32_t tiny_plan_field(
    const TinyPlanResolution* resolution, TinyPlanField field
);

int tiny_plan_resolve(const TinyPlan* plan, TinyPlanResolution* resolution);

int tiny_plan_color_stages(
    const TinyPlanResolution* resolution, TinyColorStage* stages,
    uint32_t capacity, uint32_t* count
);

int tiny_plan_replace(TinyImage* image, TinyPlan* plan);

int tiny_effect_apply(TinyImage* image, const TinyPlanOp* op);

int tiny_plan_blur_box(TinyImage* image, uint32_t radius);
 
#pragma endregion
 
#pragma region running

int tiny_plan_run(const TinyPlan* plan, TinyImage* out);

int tiny_plan_encode(
    const TinyPlan* plan, TinyImageFormat format, const TinyEncodeOpts* opts,
    TinyWriter* writer
);
 
#pragma endregion
 
#ifdef __cplusplus
}
#endif