gp_dither.gen.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2009-2026 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef FILTERS_GP_DITHER_H
#define FILTERS_GP_DITHER_H
 
#include <filters/gp_filter.h>
 
typedef enum gp_dither_type {
        GP_DITHER_FLOYD_STEINBERG,
        GP_DITHER_ATKINSON,
        GP_DITHER_SIERRA,
        GP_DITHER_SIERRA_LITE,
        GP_DITHER_HILBERT_PEANO,
        GP_DITHER_BAYER_4,
        GP_DITHER_SHARPENED_BAYER_4,
        GP_DITHER_BAYER_8,
        GP_DITHER_SHARPENED_BAYER_8,
        GP_DITHER_MAX,
} gp_dither_type;
 
gp_dither_type gp_dither_type_by_name(const char *dither_name);
 
const char *gp_dither_type_name(gp_dither_type dither_type);
 
int gp_filter_dither(gp_dither_type type,
                     const gp_pixmap *src, gp_pixmap *dst,
                     gp_progress_cb *callback);
 
gp_pixmap *gp_filter_dither_alloc(gp_dither_type type,
                                  const gp_pixmap *src,
                                  gp_pixel_type pixel_type,
                                  gp_progress_cb *callback);
 
int gp_filter_floyd_steinberg(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_floyd_steinberg_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_FLOYD_STEINBERG, src, pixel_type, callback);
}
 
int gp_filter_atkinson(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_atkinson_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_ATKINSON, src, pixel_type, callback);
}
 
int gp_filter_sierra(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_sierra_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_SIERRA, src, pixel_type, callback);
}
 
int gp_filter_sierra_lite(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_sierra_lite_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_SIERRA_LITE, src, pixel_type, callback);
}
 
int gp_filter_hilbert_peano(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_hilbert_peano_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_HILBERT_PEANO, src, pixel_type, callback);
}
 
int gp_filter_bayer_4(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_bayer_4_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_BAYER_4, src, pixel_type, callback);
}
 
int gp_filter_sharpened_bayer_4(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_sharpened_bayer_4_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_SHARPENED_BAYER_4, src, pixel_type, callback);
}
 
int gp_filter_bayer_8(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_bayer_8_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_BAYER_8, src, pixel_type, callback);
}
 
int gp_filter_sharpened_bayer_8(const gp_pixmap *src,
                         gp_pixmap *dst,
                         gp_progress_cb *callback);
 
static inline gp_pixmap *gp_filter_sharpened_bayer_8_alloc(const gp_pixmap *src,
                                                    gp_pixel_type pixel_type,
                                                    gp_progress_cb *callback)
{
        return gp_filter_dither_alloc(GP_DITHER_SHARPENED_BAYER_8, src, pixel_type, callback);
}
 
#endif /* FILTERS_GP_DITHER_H */