image.h

/* SPDX-License-Identifier: Apache-2.0 */
#ifndef MPIX_IMAGE_H
#define MPIX_IMAGE_H
 
#include <mpix/custom_api.h>
#include <mpix/formats.h>
#include <mpix/operation.h>
#include <mpix/pipeline.h>
#include <mpix/sample.h>
#include <mpix/stats.h>
#include <mpix/types.h>
 
static inline void mpix_image_from_buf(struct mpix_image *img, const uint8_t *buffer, size_t size,
                       const struct mpix_format *fmt)
{
    img->buffer = buffer;
    img->size = size;
    img->fmt = *fmt;
}
 
static inline int mpix_image_to_buf(struct mpix_image *img, uint8_t *buffer, size_t size)
{
    if (mpix_op_append(img, MPIX_OP_END, sizeof(*img->last_op), size) == NULL) return -ENOMEM;
    mpix_ring_set_buffer(&img->last_op->ring, buffer, size);
    return mpix_pipeline_process(img->first_op, img->buffer, img->size);
}
 
static inline int mpix_image_convert(struct mpix_image *img, uint32_t new_format)
{
    int32_t p[] = { (int32_t)new_format };
    return mpix_pipeline_add(img, MPIX_OP_CONVERT, p, ARRAY_SIZE(p));
}
 
static inline int mpix_image_palette_encode(struct mpix_image *img, uint32_t fourcc)
{
    int32_t p[] = { (int32_t)fourcc };
    return mpix_pipeline_add(img, MPIX_OP_PALETTE_ENCODE, p, ARRAY_SIZE(p));
}
 
static inline int mpix_image_palette_decode(struct mpix_image *img)
{
    return mpix_pipeline_add(img, MPIX_OP_PALETTE_DECODE, NULL, 0);
}
 
static inline int mpix_image_set_palette(struct mpix_image *img, struct mpix_palette *palette)
{
    return mpix_pipeline_set_palette(img->first_op, palette);
}
 
static inline int mpix_image_debayer(struct mpix_image *img, uint32_t window_size)
{
    enum mpix_op_type type = (window_size == 1) ? MPIX_OP_DEBAYER_1X1 :
                 (window_size == 2) ? MPIX_OP_DEBAYER_2X2 :
                 (window_size == 3) ? MPIX_OP_DEBAYER_3X3 : MPIX_NB_OP;
    return mpix_pipeline_add(img, type, NULL, 0);
}
 
static inline int mpix_image_correct_color_matrix(struct mpix_image *img)
{
    return mpix_pipeline_add(img, MPIX_OP_CORRECT_COLOR_MATRIX, NULL, 0);
}
 
static inline int mpix_image_correct_white_balance(struct mpix_image *img)
{
    return mpix_pipeline_add(img, MPIX_OP_CORRECT_WHITE_BALANCE, NULL, 0);
}
 
static inline int mpix_image_correct_black_level(struct mpix_image *img)
{
    return mpix_pipeline_add(img, MPIX_OP_CORRECT_BLACK_LEVEL, NULL, 0);
}
 
static inline int mpix_image_correct_gamma(struct mpix_image *img)
{
    return mpix_pipeline_add(img, MPIX_OP_CORRECT_GAMMA, NULL, 0);
}
 
static inline int mpix_image_qoi_encode(struct mpix_image *img)
{
    return mpix_pipeline_add(img, MPIX_OP_QOI_ENCODE, NULL, 0);
}
 
static inline int mpix_image_jpeg_encode(struct mpix_image *img)
{
    return mpix_pipeline_add(img, MPIX_OP_JPEG_ENCODE, NULL, 0);
}
 
static inline int mpix_image_resize_subsample(struct mpix_image *img,
                          uint16_t width, uint16_t height)
{
    int32_t p[] = { width, height };
    return mpix_pipeline_add(img, MPIX_OP_RESIZE_SUBSAMPLE, p, ARRAY_SIZE(p));
}
 
static inline int mpix_image_crop(struct mpix_image *img, uint16_t x_offset, uint16_t y_offset,
                  uint16_t crop_width, uint16_t crop_height)
{
    int32_t p[] = { x_offset, y_offset, crop_width, crop_height };
    return mpix_pipeline_add(img, MPIX_OP_CROP, p, ARRAY_SIZE(p));
}
 
static inline int mpix_image_sharpen(struct mpix_image *img, uint8_t level)
{
    int32_t p[] = { MPIX_KERNEL_SHARPEN };
    enum mpix_op_type type = (level == 3) ? MPIX_OP_KERNEL_CONVOLVE_3X3 :
                 (level == 5) ? MPIX_OP_KERNEL_CONVOLVE_5X5 : MPIX_NB_OP;
    return mpix_pipeline_add(img, type, p, ARRAY_SIZE(p));
}
 
static inline int mpix_image_denoise(struct mpix_image *img, uint8_t level)
{
    enum mpix_op_type type = (level == 3) ? MPIX_OP_KERNEL_DENOISE_3X3 :
                 (level == 5) ? MPIX_OP_KERNEL_DENOISE_5X5 : MPIX_NB_OP;
    return mpix_pipeline_add(img, type, NULL, 0);
}
 
static inline int mpix_image_edge_detect(struct mpix_image *img, uint8_t level)
{
    int32_t p[] = { MPIX_KERNEL_EDGE_DETECT };
    enum mpix_op_type type = (level == 3) ? MPIX_OP_KERNEL_CONVOLVE_3X3 :
                 (level == 5) ? MPIX_OP_KERNEL_CONVOLVE_5X5 : MPIX_NB_OP;
    return mpix_pipeline_add(img, type, p, ARRAY_SIZE(p));
}
 
static inline int mpix_image_gaussian_blur(struct mpix_image *img, uint8_t level)
{
    int32_t p[] = { MPIX_KERNEL_GAUSSIAN_BLUR };
    enum mpix_op_type type = (level == 3) ? MPIX_OP_KERNEL_CONVOLVE_3X3 :
                 (level == 5) ? MPIX_OP_KERNEL_CONVOLVE_5X5 : MPIX_NB_OP;
    return mpix_pipeline_add(img, type, p, ARRAY_SIZE(p));
}
 
static inline void mpix_image_from_palette(struct mpix_image *img, const struct mpix_palette *palette)
{
    uint16_t n = 1 << mpix_palette_bit_depth(palette->fourcc);
    struct mpix_format fmt = { .width = n, .height = 1, .fourcc = MPIX_FMT_RGB24 };
    mpix_image_from_buf(img, palette->colors_rgb24, n * 3, &fmt);
}
 
static inline int mpix_image_to_palette(struct mpix_image *img, struct mpix_palette *palette)
{
    uint16_t n = 1 << mpix_palette_bit_depth(palette->fourcc);
    return (n == 0) ? -EINVAL : mpix_image_to_buf(img, palette->colors_rgb24, n * 3);
}
 
int mpix_image_optimize_palette(struct mpix_image *img, struct mpix_palette *palette,
                uint16_t num_samples);
 
static inline void mpix_image_free(struct mpix_image *img)
{
    mpix_pipeline_free(img->first_op);
    img->first_op = img->last_op = NULL;
    memset(img->ctrls, 0x00, sizeof(img->ctrls));
}
 
static inline struct mpix_format *mpix_image_format(struct mpix_image *img)
{
    return img->first_op == NULL ? &img->fmt : &img->first_op->fmt;
}
 
static inline int mpix_image_sample_random_rgb(struct mpix_image *img, uint8_t rgb[3])
{
    return mpix_sample_random_rgb(img->buffer, mpix_image_format(img), rgb);
}
 
static inline void mpix_image_stats(struct mpix_image *img, struct mpix_stats *stats)
{
    mpix_stats_from_buf(stats, img->buffer, mpix_image_format(img));
}
 
static inline int mpix_image_ctrl_value(struct mpix_image *img, enum mpix_control_id cid,
                        int32_t value)
{
    if (cid > MPIX_NB_CID) return -ERANGE;
    if (img->ctrls[cid] == NULL) return -ENOENT;
    img->ctrls[cid][0] = value;
    return 0;
}
 
static inline int mpix_image_ctrl_array(struct mpix_image *img, enum mpix_control_id cid,
                        int32_t *array, size_t size)
{
    if (cid + size > MPIX_NB_CID) return -ERANGE;
    for (size_t i = 0; i < size; i++) {
        if (img->ctrls[cid + i] == NULL) return -ENOENT;
        *img->ctrls[cid + i] = array[i];
    }
    return 0;
}
 
static inline int mpix_image_read_output(struct mpix_image *img, const uint8_t **buf, size_t *size)
{
    if (img->last_op == NULL) return -EINVAL;
    mpix_op_input_all(img->last_op, buf, size);
    return (*size == 0) ? -ENODATA : 0;
}
 
#endif