From 3d4092c34ac2255c885b37fdb89aef961966fa9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Szil=C3=A1rd=20Bir=C3=B3?= Date: Thu, 3 Apr 2025 16:00:02 +0200 Subject: [PATCH] Add the missing files for the GBA packer (#504) * add libimagequant and stb_image_resize for the GBA packer * add cygwin1.dll for ad4.exe --- src/platform/gba/packer/libimagequant/blur.c | 132 + src/platform/gba/packer/libimagequant/blur.h | 8 + .../gba/packer/libimagequant/kmeans.c | 106 + .../gba/packer/libimagequant/kmeans.h | 19 + .../gba/packer/libimagequant/libimagequant.c | 2123 ++++++++++++++ .../gba/packer/libimagequant/libimagequant.h | 151 + .../gba/packer/libimagequant/mediancut.c | 464 +++ .../gba/packer/libimagequant/mediancut.h | 6 + .../gba/packer/libimagequant/mempool.c | 70 + .../gba/packer/libimagequant/mempool.h | 13 + .../gba/packer/libimagequant/nearest.c | 230 ++ .../gba/packer/libimagequant/nearest.h | 14 + src/platform/gba/packer/libimagequant/pam.c | 289 ++ src/platform/gba/packer/libimagequant/pam.h | 283 ++ src/platform/gba/packer/stb_image_resize.h | 2585 +++++++++++++++++ src/platform/gba/packer/tracks/cygwin1.dll | Bin 0 -> 2992181 bytes 16 files changed, 6493 insertions(+) create mode 100644 src/platform/gba/packer/libimagequant/blur.c create mode 100644 src/platform/gba/packer/libimagequant/blur.h create mode 100644 src/platform/gba/packer/libimagequant/kmeans.c create mode 100644 src/platform/gba/packer/libimagequant/kmeans.h create mode 100644 src/platform/gba/packer/libimagequant/libimagequant.c create mode 100644 src/platform/gba/packer/libimagequant/libimagequant.h create mode 100644 src/platform/gba/packer/libimagequant/mediancut.c create mode 100644 src/platform/gba/packer/libimagequant/mediancut.h create mode 100644 src/platform/gba/packer/libimagequant/mempool.c create mode 100644 src/platform/gba/packer/libimagequant/mempool.h create mode 100644 src/platform/gba/packer/libimagequant/nearest.c create mode 100644 src/platform/gba/packer/libimagequant/nearest.h create mode 100644 src/platform/gba/packer/libimagequant/pam.c create mode 100644 src/platform/gba/packer/libimagequant/pam.h create mode 100644 src/platform/gba/packer/stb_image_resize.h create mode 100644 src/platform/gba/packer/tracks/cygwin1.dll diff --git a/src/platform/gba/packer/libimagequant/blur.c b/src/platform/gba/packer/libimagequant/blur.c new file mode 100644 index 0000000..7f0a716 --- /dev/null +++ b/src/platform/gba/packer/libimagequant/blur.c @@ -0,0 +1,132 @@ +/* +© 2011-2015 by Kornel Lesiński. + +This file is part of libimagequant. + +libimagequant is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +libimagequant 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with libimagequant. If not, see . +*/ + +#include "libimagequant.h" +#include "pam.h" +#include "blur.h" + +/* + Blurs image horizontally (width 2*size+1) and writes it transposed to dst (called twice gives 2d blur) + */ +static void transposing_1d_blur(unsigned char *restrict src, unsigned char *restrict dst, unsigned int width, unsigned int height, const unsigned int size) +{ + assert(size > 0); + + for(unsigned int j=0; j < height; j++) { + unsigned char *restrict row = src + j*width; + + // accumulate sum for pixels outside line + unsigned int sum; + sum = row[0]*size; + for(unsigned int i=0; i < size; i++) { + sum += row[i]; + } + + // blur with left side outside line + for(unsigned int i=0; i < size; i++) { + sum -= row[0]; + sum += row[i+size]; + + dst[i*height + j] = sum / (size*2); + } + + for(unsigned int i=size; i < width-size; i++) { + sum -= row[i-size]; + sum += row[i+size]; + + dst[i*height + j] = sum / (size*2); + } + + // blur with right side outside line + for(unsigned int i=width-size; i < width; i++) { + sum -= row[i-size]; + sum += row[width-1]; + + dst[i*height + j] = sum / (size*2); + } + } +} + +/** + * Picks maximum of neighboring pixels (blur + lighten) + */ +LIQ_PRIVATE void liq_max3(unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height) +{ + for(unsigned int j=0; j < height; j++) { + const unsigned char *row = src + j*width, + *prevrow = src + (j > 1 ? j-1 : 0)*width, + *nextrow = src + MIN(height-1,j+1)*width; + + unsigned char prev,curr=row[0],next=row[0]; + + for(unsigned int i=0; i < width-1; i++) { + prev=curr; + curr=next; + next=row[i+1]; + + unsigned char t1 = MAX(prev,next); + unsigned char t2 = MAX(nextrow[i],prevrow[i]); + *dst++ = MAX(curr,MAX(t1,t2)); + } + unsigned char t1 = MAX(curr,next); + unsigned char t2 = MAX(nextrow[width-1],prevrow[width-1]); + *dst++ = MAX(t1,t2); + } +} + +/** + * Picks minimum of neighboring pixels (blur + darken) + */ +LIQ_PRIVATE void liq_min3(unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height) +{ + for(unsigned int j=0; j < height; j++) { + const unsigned char *row = src + j*width, + *prevrow = src + (j > 1 ? j-1 : 0)*width, + *nextrow = src + MIN(height-1,j+1)*width; + + unsigned char prev,curr=row[0],next=row[0]; + + for(unsigned int i=0; i < width-1; i++) { + prev=curr; + curr=next; + next=row[i+1]; + + unsigned char t1 = MIN(prev,next); + unsigned char t2 = MIN(nextrow[i],prevrow[i]); + *dst++ = MIN(curr,MIN(t1,t2)); + } + unsigned char t1 = MIN(curr,next); + unsigned char t2 = MIN(nextrow[width-1],prevrow[width-1]); + *dst++ = MIN(t1,t2); + } +} + +/* + Filters src image and saves it to dst, overwriting tmp in the process. + Image must be width*height pixels high. Size controls radius of box blur. + */ +LIQ_PRIVATE void liq_blur(unsigned char *src, unsigned char *tmp, unsigned char *dst, unsigned int width, unsigned int height, unsigned int size) +{ + assert(size > 0); + if (width < 2*size+1 || height < 2*size+1) { + return; + } + transposing_1d_blur(src, tmp, width, height, size); + transposing_1d_blur(tmp, dst, height, width, size); +} diff --git a/src/platform/gba/packer/libimagequant/blur.h b/src/platform/gba/packer/libimagequant/blur.h new file mode 100644 index 0000000..1e77819 --- /dev/null +++ b/src/platform/gba/packer/libimagequant/blur.h @@ -0,0 +1,8 @@ +#ifndef BLUR_H +#define BLUR_H + +LIQ_PRIVATE void liq_blur(unsigned char *src, unsigned char *tmp, unsigned char *dst, unsigned int width, unsigned int height, unsigned int size); +LIQ_PRIVATE void liq_max3(unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height); +LIQ_PRIVATE void liq_min3(unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height); + +#endif diff --git a/src/platform/gba/packer/libimagequant/kmeans.c b/src/platform/gba/packer/libimagequant/kmeans.c new file mode 100644 index 0000000..005be65 --- /dev/null +++ b/src/platform/gba/packer/libimagequant/kmeans.c @@ -0,0 +1,106 @@ +/* +** © 2011-2016 by Kornel Lesiński. +** See COPYRIGHT file for license. +*/ + +#include "libimagequant.h" +#include "pam.h" +#include "kmeans.h" +#include "nearest.h" +#include +#include + +#ifdef _OPENMP +#include +#else +#define omp_get_max_threads() 1 +#define omp_get_thread_num() 0 +#endif + +/* + * K-Means iteration: new palette color is computed from weighted average of colors that map to that palette entry. + */ +LIQ_PRIVATE void kmeans_init(const colormap *map, const unsigned int max_threads, kmeans_state average_color[]) +{ + memset(average_color, 0, sizeof(average_color[0])*(KMEANS_CACHE_LINE_GAP+map->colors)*max_threads); +} + +LIQ_PRIVATE void kmeans_update_color(const f_pixel acolor, const float value, const colormap *map, unsigned int match, const unsigned int thread, kmeans_state average_color[]) +{ + match += thread * (KMEANS_CACHE_LINE_GAP+map->colors); + average_color[match].a += acolor.a * value; + average_color[match].r += acolor.r * value; + average_color[match].g += acolor.g * value; + average_color[match].b += acolor.b * value; + average_color[match].total += value; +} + +LIQ_PRIVATE void kmeans_finalize(colormap *map, const unsigned int max_threads, const kmeans_state average_color[]) +{ + for (unsigned int i=0; i < map->colors; i++) { + double a=0, r=0, g=0, b=0, total=0; + + // Aggregate results from all threads + for(unsigned int t=0; t < max_threads; t++) { + const unsigned int offset = (KMEANS_CACHE_LINE_GAP+map->colors) * t + i; + + a += average_color[offset].a; + r += average_color[offset].r; + g += average_color[offset].g; + b += average_color[offset].b; + total += average_color[offset].total; + } + + if (!map->palette[i].fixed) { + map->palette[i].popularity = total; + if (total) { + map->palette[i].acolor = (f_pixel){ + .a = a / total, + .r = r / total, + .g = g / total, + .b = b / total, + }; + } else { + unsigned int r = (i + rand()%7); + map->palette[i].acolor.a = map->palette[r%map->colors].acolor.a; + map->palette[i].acolor.r = map->palette[r%map->colors].acolor.r; + map->palette[i].acolor.g = map->palette[(r+1)%map->colors].acolor.g; + map->palette[i].acolor.b = map->palette[(r+2)%map->colors].acolor.b; + } + } + } +} + +LIQ_PRIVATE double kmeans_do_iteration(histogram *hist, colormap *const map, kmeans_callback callback) +{ + const unsigned int max_threads = omp_get_max_threads(); + LIQ_ARRAY(kmeans_state, average_color, (KMEANS_CACHE_LINE_GAP+map->colors) * max_threads); + kmeans_init(map, max_threads, average_color); + struct nearest_map *const n = nearest_init(map); + hist_item *const achv = hist->achv; + const int hist_size = hist->size; + + double total_diff=0; +#if __GNUC__ >= 9 || __clang__ + #pragma omp parallel for if (hist_size > 2000) \ + schedule(static) default(none) shared(achv,average_color,callback,hist_size,map,n) reduction(+:total_diff) +#else + #pragma omp parallel for if (hist_size > 2000) \ + schedule(static) default(none) shared(average_color,callback) reduction(+:total_diff) +#endif + for(int j=0; j < hist_size; j++) { + float diff; + unsigned int match = nearest_search(n, &achv[j].acolor, achv[j].tmp.likely_colormap_index, &diff); + achv[j].tmp.likely_colormap_index = match; + total_diff += diff * achv[j].perceptual_weight; + + if (callback) callback(&achv[j], diff); + + kmeans_update_color(achv[j].acolor, achv[j].perceptual_weight, map, match, omp_get_thread_num(), average_color); + } + + nearest_free(n); + kmeans_finalize(map, max_threads, average_color); + + return total_diff / hist->total_perceptual_weight; +} diff --git a/src/platform/gba/packer/libimagequant/kmeans.h b/src/platform/gba/packer/libimagequant/kmeans.h new file mode 100644 index 0000000..c51d7bb --- /dev/null +++ b/src/platform/gba/packer/libimagequant/kmeans.h @@ -0,0 +1,19 @@ + +#ifndef KMEANS_H +#define KMEANS_H + +// Spread memory touched by different threads at least 64B apart which I assume is the cache line size. This should avoid memory write contention. +#define KMEANS_CACHE_LINE_GAP ((64+sizeof(kmeans_state)-1)/sizeof(kmeans_state)) + +typedef struct { + double a, r, g, b, total; +} kmeans_state; + +typedef void (*kmeans_callback)(hist_item *item, float diff); + +LIQ_PRIVATE void kmeans_init(const colormap *map, const unsigned int max_threads, kmeans_state state[]); +LIQ_PRIVATE void kmeans_update_color(const f_pixel acolor, const float value, const colormap *map, unsigned int match, const unsigned int thread, kmeans_state average_color[]); +LIQ_PRIVATE void kmeans_finalize(colormap *map, const unsigned int max_threads, const kmeans_state state[]); +LIQ_PRIVATE double kmeans_do_iteration(histogram *hist, colormap *const map, kmeans_callback callback); + +#endif diff --git a/src/platform/gba/packer/libimagequant/libimagequant.c b/src/platform/gba/packer/libimagequant/libimagequant.c new file mode 100644 index 0000000..a1bfafb --- /dev/null +++ b/src/platform/gba/packer/libimagequant/libimagequant.c @@ -0,0 +1,2123 @@ +/* +** © 2009-2018 by Kornel Lesiński. +** © 1989, 1991 by Jef Poskanzer. +** © 1997, 2000, 2002 by Greg Roelofs; based on an idea by Stefan Schneider. +** +** See COPYRIGHT file for license. +*/ + +#include +#include +#include +#include +#include +#include +#include + +#if !(defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199900L) && !(defined(_MSC_VER) && _MSC_VER >= 1800) +#error "This program requires C99, e.g. -std=c99 switch in GCC or it requires MSVC 18.0 or higher." +#error "Ignore torrent of syntax errors that may follow. It's only because compiler is set to use too old C version." +#endif + +#ifdef _OPENMP +#include +#define LIQ_TEMP_ROW_WIDTH(img_width) (((img_width) | 15) + 1) /* keep alignment & leave space between rows to avoid cache line contention */ +#else +#define LIQ_TEMP_ROW_WIDTH(img_width) (img_width) +#define omp_get_max_threads() 1 +#define omp_get_thread_num() 0 +#endif + +#include "libimagequant.h" + +#include "pam.h" +#include "mediancut.h" +#include "nearest.h" +#include "blur.h" +#include "kmeans.h" + +#define LIQ_HIGH_MEMORY_LIMIT (1<<26) /* avoid allocating buffers larger than 64MB */ + +// each structure has a pointer as a unique identifier that allows type checking at run time +static const char liq_attr_magic[] = "liq_attr"; +static const char liq_image_magic[] = "liq_image"; +static const char liq_result_magic[] = "liq_result"; +static const char liq_histogram_magic[] = "liq_histogram"; +static const char liq_remapping_result_magic[] = "liq_remapping_result"; +static const char liq_freed_magic[] = "free"; +#define CHECK_STRUCT_TYPE(attr, kind) liq_crash_if_invalid_handle_pointer_given((const liq_attr*)attr, kind ## _magic) +#define CHECK_USER_POINTER(ptr) liq_crash_if_invalid_pointer_given(ptr) + +struct liq_attr { + const char *magic_header; + void* (*malloc)(size_t); + void (*free)(void*); + + double target_mse, max_mse, kmeans_iteration_limit; + unsigned int max_colors, max_histogram_entries; + unsigned int min_posterization_output /* user setting */, min_posterization_input /* speed setting */; + unsigned int kmeans_iterations, feedback_loop_trials; + bool last_index_transparent, use_contrast_maps; + unsigned char use_dither_map; + unsigned char speed; + + unsigned char progress_stage1, progress_stage2, progress_stage3; + liq_progress_callback_function *progress_callback; + void *progress_callback_user_info; + + liq_log_callback_function *log_callback; + void *log_callback_user_info; + liq_log_flush_callback_function *log_flush_callback; + void *log_flush_callback_user_info; +}; + +struct liq_image { + const char *magic_header; + void* (*malloc)(size_t); + void (*free)(void*); + + f_pixel *f_pixels; + rgba_pixel **rows; + double gamma; + unsigned int width, height; + unsigned char *importance_map, *edges, *dither_map; + rgba_pixel *pixels, *temp_row; + f_pixel *temp_f_row; + liq_image_get_rgba_row_callback *row_callback; + void *row_callback_user_info; + liq_image *background; + f_pixel fixed_colors[256]; + unsigned short fixed_colors_count; + bool free_pixels, free_rows, free_rows_internal; +}; + +typedef struct liq_remapping_result { + const char *magic_header; + void* (*malloc)(size_t); + void (*free)(void*); + + unsigned char *pixels; + colormap *palette; + liq_progress_callback_function *progress_callback; + void *progress_callback_user_info; + + liq_palette int_palette; + double gamma, palette_error; + float dither_level; + unsigned char use_dither_map; + unsigned char progress_stage1; +} liq_remapping_result; + +struct liq_result { + const char *magic_header; + void* (*malloc)(size_t); + void (*free)(void*); + + liq_remapping_result *remapping; + colormap *palette; + liq_progress_callback_function *progress_callback; + void *progress_callback_user_info; + + liq_palette int_palette; + float dither_level; + double gamma, palette_error; + int min_posterization_output; + unsigned char use_dither_map; +}; + +struct liq_histogram { + const char *magic_header; + void* (*malloc)(size_t); + void (*free)(void*); + + struct acolorhash_table *acht; + double gamma; + f_pixel fixed_colors[256]; + unsigned short fixed_colors_count; + unsigned short ignorebits; + bool had_image_added; +}; + +static void contrast_maps(liq_image *image) LIQ_NONNULL; +static liq_error finalize_histogram(liq_histogram *input_hist, liq_attr *options, histogram **hist_output) LIQ_NONNULL; +static const rgba_pixel *liq_image_get_row_rgba(liq_image *input_image, unsigned int row) LIQ_NONNULL; +static bool liq_image_get_row_f_init(liq_image *img) LIQ_NONNULL; +static const f_pixel *liq_image_get_row_f(liq_image *input_image, unsigned int row) LIQ_NONNULL; +static void liq_remapping_result_destroy(liq_remapping_result *result) LIQ_NONNULL; +static liq_error pngquant_quantize(histogram *hist, const liq_attr *options, const int fixed_colors_count, const f_pixel fixed_colors[], const double gamma, bool fixed_result_colors, liq_result **) LIQ_NONNULL; +static liq_error liq_histogram_quantize_internal(liq_histogram *input_hist, liq_attr *attr, bool fixed_result_colors, liq_result **result_output) LIQ_NONNULL; + +LIQ_NONNULL static void liq_verbose_printf(const liq_attr *context, const char *fmt, ...) +{ + if (context->log_callback) { + va_list va; + va_start(va, fmt); + int required_space = vsnprintf(NULL, 0, fmt, va)+1; // +\0 + va_end(va); + + LIQ_ARRAY(char, buf, required_space); + va_start(va, fmt); + vsnprintf(buf, required_space, fmt, va); + va_end(va); + + context->log_callback(context, buf, context->log_callback_user_info); + } +} + +LIQ_NONNULL inline static void verbose_print(const liq_attr *attr, const char *msg) +{ + if (attr->log_callback) { + attr->log_callback(attr, msg, attr->log_callback_user_info); + } +} + +LIQ_NONNULL static void liq_verbose_printf_flush(liq_attr *attr) +{ + if (attr->log_flush_callback) { + attr->log_flush_callback(attr, attr->log_flush_callback_user_info); + } +} + +LIQ_NONNULL static bool liq_progress(const liq_attr *attr, const float percent) +{ + return attr->progress_callback && !attr->progress_callback(percent, attr->progress_callback_user_info); +} + +LIQ_NONNULL static bool liq_remap_progress(const liq_remapping_result *quant, const float percent) +{ + return quant->progress_callback && !quant->progress_callback(percent, quant->progress_callback_user_info); +} + +#if USE_SSE +inline static bool is_sse_available() +{ +#if (defined(__x86_64__) || defined(__amd64) || defined(_WIN64)) + return true; +#elif _MSC_VER + int info[4]; + __cpuid(info, 1); + /* bool is implemented as a built-in type of size 1 in MSVC */ + return info[3] & (1<<26) ? true : false; +#else + int a,b,c,d; + cpuid(1, a, b, c, d); + return d & (1<<25); // edx bit 25 is set when SSE is present +#endif +} +#endif + +/* make it clear in backtrace when user-supplied handle points to invalid memory */ +NEVER_INLINE LIQ_EXPORT bool liq_crash_if_invalid_handle_pointer_given(const liq_attr *user_supplied_pointer, const char *const expected_magic_header); +LIQ_EXPORT bool liq_crash_if_invalid_handle_pointer_given(const liq_attr *user_supplied_pointer, const char *const expected_magic_header) +{ + if (!user_supplied_pointer) { + return false; + } + + if (user_supplied_pointer->magic_header == liq_freed_magic) { + fprintf(stderr, "%s used after being freed", expected_magic_header); + // this is not normal error handling, this is programmer error that should crash the program. + // program cannot safely continue if memory has been used after it's been freed. + // abort() is nasty, but security vulnerability may be worse. + abort(); + } + + return user_supplied_pointer->magic_header == expected_magic_header; +} + +NEVER_INLINE LIQ_EXPORT bool liq_crash_if_invalid_pointer_given(const void *pointer); +LIQ_EXPORT bool liq_crash_if_invalid_pointer_given(const void *pointer) +{ + if (!pointer) { + return false; + } + // Force a read from the given (potentially invalid) memory location in order to check early whether this crashes the program or not. + // It doesn't matter what value is read, the code here is just to shut the compiler up about unused read. + char test_access = *((volatile char *)pointer); + return test_access || true; +} + +LIQ_NONNULL static void liq_log_error(const liq_attr *attr, const char *msg) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return; + liq_verbose_printf(attr, " error: %s", msg); +} + +static double quality_to_mse(long quality) +{ + if (quality == 0) { + return MAX_DIFF; + } + if (quality == 100) { + return 0; + } + + // curve fudged to be roughly similar to quality of libjpeg + // except lowest 10 for really low number of colors + const double extra_low_quality_fudge = MAX(0,0.016/(0.001+quality) - 0.001); + return extra_low_quality_fudge + 2.5/pow(210.0 + quality, 1.2) * (100.1-quality)/100.0; +} + +static unsigned int mse_to_quality(double mse) +{ + for(int i=100; i > 0; i--) { + if (mse <= quality_to_mse(i) + 0.000001) { // + epsilon for floating point errors + return i; + } + } + return 0; +} + +/** internally MSE is a sum of all channels with pixels 0..1 range, + but other software gives per-RGB-channel MSE for 0..255 range */ +static double mse_to_standard_mse(double mse) { + return mse * 65536.0/6.0; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_set_quality(liq_attr* attr, int minimum, int target) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return LIQ_INVALID_POINTER; + if (target < 0 || target > 100 || target < minimum || minimum < 0) return LIQ_VALUE_OUT_OF_RANGE; + + attr->target_mse = quality_to_mse(target); + attr->max_mse = quality_to_mse(minimum); + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL int liq_get_min_quality(const liq_attr *attr) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return -1; + return mse_to_quality(attr->max_mse); +} + +LIQ_EXPORT LIQ_NONNULL int liq_get_max_quality(const liq_attr *attr) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return -1; + return mse_to_quality(attr->target_mse); +} + + +LIQ_EXPORT LIQ_NONNULL liq_error liq_set_max_colors(liq_attr* attr, int colors) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return LIQ_INVALID_POINTER; + if (colors < 2 || colors > 256) return LIQ_VALUE_OUT_OF_RANGE; + + attr->max_colors = colors; + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL int liq_get_max_colors(const liq_attr *attr) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return -1; + + return attr->max_colors; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_set_min_posterization(liq_attr *attr, int bits) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return LIQ_INVALID_POINTER; + if (bits < 0 || bits > 4) return LIQ_VALUE_OUT_OF_RANGE; + + attr->min_posterization_output = bits; + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL int liq_get_min_posterization(const liq_attr *attr) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return -1; + + return attr->min_posterization_output; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_set_speed(liq_attr* attr, int speed) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return LIQ_INVALID_POINTER; + if (speed < 1 || speed > 10) return LIQ_VALUE_OUT_OF_RANGE; + + unsigned int iterations = MAX(8-speed, 0); + iterations += iterations * iterations/2; + attr->kmeans_iterations = iterations; + attr->kmeans_iteration_limit = 1.0/(double)(1<<(23-speed)); + attr->feedback_loop_trials = MAX(56-9*speed, 0); + + attr->max_histogram_entries = (1<<17) + (1<<18)*(10-speed); + attr->min_posterization_input = (speed >= 8) ? 1 : 0; + attr->use_dither_map = (speed <= (omp_get_max_threads() > 1 ? 7 : 5)); // parallelized dither map might speed up floyd remapping + if (attr->use_dither_map && speed < 3) { + attr->use_dither_map = 2; // always + } + attr->use_contrast_maps = (speed <= 7) || attr->use_dither_map; + attr->speed = speed; + + attr->progress_stage1 = attr->use_contrast_maps ? 20 : 8; + if (attr->feedback_loop_trials < 2) { + attr->progress_stage1 += 30; + } + attr->progress_stage3 = 50 / (1+speed); + attr->progress_stage2 = 100 - attr->progress_stage1 - attr->progress_stage3; + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL int liq_get_speed(const liq_attr *attr) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return -1; + + return attr->speed; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_set_output_gamma(liq_result* res, double gamma) +{ + if (!CHECK_STRUCT_TYPE(res, liq_result)) return LIQ_INVALID_POINTER; + if (gamma <= 0 || gamma >= 1.0) return LIQ_VALUE_OUT_OF_RANGE; + + if (res->remapping) { + liq_remapping_result_destroy(res->remapping); + res->remapping = NULL; + } + + res->gamma = gamma; + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_set_min_opacity(liq_attr* attr, int min) +{ + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL int liq_get_min_opacity(const liq_attr *attr) +{ + return 0; +} + +LIQ_EXPORT LIQ_NONNULL void liq_set_last_index_transparent(liq_attr* attr, int is_last) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return; + + attr->last_index_transparent = !!is_last; +} + +LIQ_EXPORT void liq_attr_set_progress_callback(liq_attr *attr, liq_progress_callback_function *callback, void *user_info) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return; + + attr->progress_callback = callback; + attr->progress_callback_user_info = user_info; +} + +LIQ_EXPORT void liq_result_set_progress_callback(liq_result *result, liq_progress_callback_function *callback, void *user_info) +{ + if (!CHECK_STRUCT_TYPE(result, liq_result)) return; + + result->progress_callback = callback; + result->progress_callback_user_info = user_info; +} + +LIQ_EXPORT void liq_set_log_callback(liq_attr *attr, liq_log_callback_function *callback, void* user_info) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return; + + liq_verbose_printf_flush(attr); + attr->log_callback = callback; + attr->log_callback_user_info = user_info; +} + +LIQ_EXPORT void liq_set_log_flush_callback(liq_attr *attr, liq_log_flush_callback_function *callback, void* user_info) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return; + + attr->log_flush_callback = callback; + attr->log_flush_callback_user_info = user_info; +} + +LIQ_EXPORT liq_attr* liq_attr_create() +{ + return liq_attr_create_with_allocator(NULL, NULL); +} + +LIQ_EXPORT LIQ_NONNULL void liq_attr_destroy(liq_attr *attr) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) { + return; + } + + liq_verbose_printf_flush(attr); + + attr->magic_header = liq_freed_magic; + attr->free(attr); +} + +LIQ_EXPORT LIQ_NONNULL liq_attr* liq_attr_copy(const liq_attr *orig) +{ + if (!CHECK_STRUCT_TYPE(orig, liq_attr)) { + return NULL; + } + + liq_attr *attr = orig->malloc(sizeof(liq_attr)); + if (!attr) return NULL; + *attr = *orig; + return attr; +} + +static void *liq_aligned_malloc(size_t size) +{ + unsigned char *ptr = malloc(size + 16); + if (!ptr) { + return NULL; + } + + uintptr_t offset = 16 - ((uintptr_t)ptr & 15); // also reserves 1 byte for ptr[-1] + ptr += offset; + assert(0 == (((uintptr_t)ptr) & 15)); + ptr[-1] = offset ^ 0x59; // store how much pointer was shifted to get the original for free() + return ptr; +} + +LIQ_NONNULL static void liq_aligned_free(void *inptr) +{ + unsigned char *ptr = inptr; + size_t offset = ptr[-1] ^ 0x59; + assert(offset > 0 && offset <= 16); + free(ptr - offset); +} + +LIQ_EXPORT liq_attr* liq_attr_create_with_allocator(void* (*custom_malloc)(size_t), void (*custom_free)(void*)) +{ +#if USE_SSE + if (!is_sse_available()) { + return NULL; + } +#endif + if (!custom_malloc && !custom_free) { + custom_malloc = liq_aligned_malloc; + custom_free = liq_aligned_free; + } else if (!custom_malloc != !custom_free) { + return NULL; // either specify both or none + } + + liq_attr *attr = custom_malloc(sizeof(liq_attr)); + if (!attr) return NULL; + *attr = (liq_attr) { + .magic_header = liq_attr_magic, + .malloc = custom_malloc, + .free = custom_free, + .max_colors = 256, + .last_index_transparent = false, // puts transparent color at last index. This is workaround for blu-ray subtitles. + .target_mse = 0, + .max_mse = MAX_DIFF, + }; + liq_set_speed(attr, 4); + return attr; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_image_add_fixed_color(liq_image *img, liq_color color) +{ + if (!CHECK_STRUCT_TYPE(img, liq_image)) return LIQ_INVALID_POINTER; + if (img->fixed_colors_count > 255) return LIQ_UNSUPPORTED; + + float gamma_lut[256]; + to_f_set_gamma(gamma_lut, img->gamma); + img->fixed_colors[img->fixed_colors_count++] = rgba_to_f(gamma_lut, (rgba_pixel){ + .r = color.r, + .g = color.g, + .b = color.b, + .a = color.a, + }); + return LIQ_OK; +} + +LIQ_NONNULL static liq_error liq_histogram_add_fixed_color_f(liq_histogram *hist, f_pixel color) +{ + if (hist->fixed_colors_count > 255) return LIQ_UNSUPPORTED; + + hist->fixed_colors[hist->fixed_colors_count++] = color; + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_histogram_add_fixed_color(liq_histogram *hist, liq_color color, double gamma) +{ + if (!CHECK_STRUCT_TYPE(hist, liq_histogram)) return LIQ_INVALID_POINTER; + + float gamma_lut[256]; + to_f_set_gamma(gamma_lut, gamma ? gamma : 0.45455); + const f_pixel px = rgba_to_f(gamma_lut, (rgba_pixel){ + .r = color.r, + .g = color.g, + .b = color.b, + .a = color.a, + }); + return liq_histogram_add_fixed_color_f(hist, px); +} + +LIQ_NONNULL static bool liq_image_use_low_memory(liq_image *img) +{ + img->temp_f_row = img->malloc(sizeof(img->f_pixels[0]) * LIQ_TEMP_ROW_WIDTH(img->width) * omp_get_max_threads()); + return img->temp_f_row != NULL; +} + +LIQ_NONNULL static bool liq_image_should_use_low_memory(liq_image *img, const bool low_memory_hint) +{ + return (size_t)img->width * (size_t)img->height > (low_memory_hint ? LIQ_HIGH_MEMORY_LIMIT/8 : LIQ_HIGH_MEMORY_LIMIT) / sizeof(f_pixel); // Watch out for integer overflow +} + +static liq_image *liq_image_create_internal(const liq_attr *attr, rgba_pixel* rows[], liq_image_get_rgba_row_callback *row_callback, void *row_callback_user_info, int width, int height, double gamma) +{ + if (gamma < 0 || gamma > 1.0) { + liq_log_error(attr, "gamma must be >= 0 and <= 1 (try 1/gamma instead)"); + return NULL; + } + + if (!rows && !row_callback) { + liq_log_error(attr, "missing row data"); + return NULL; + } + + liq_image *img = attr->malloc(sizeof(liq_image)); + if (!img) return NULL; + *img = (liq_image){ + .magic_header = liq_image_magic, + .malloc = attr->malloc, + .free = attr->free, + .width = width, .height = height, + .gamma = gamma ? gamma : 0.45455, + .rows = rows, + .row_callback = row_callback, + .row_callback_user_info = row_callback_user_info, + }; + + if (!rows) { + img->temp_row = attr->malloc(sizeof(img->temp_row[0]) * LIQ_TEMP_ROW_WIDTH(width) * omp_get_max_threads()); + if (!img->temp_row) return NULL; + } + + // if image is huge or converted pixels are not likely to be reused then don't cache converted pixels + if (liq_image_should_use_low_memory(img, !img->temp_row && !attr->use_contrast_maps && !attr->use_dither_map)) { + verbose_print(attr, " conserving memory"); + if (!liq_image_use_low_memory(img)) return NULL; + } + + return img; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_image_set_memory_ownership(liq_image *img, int ownership_flags) +{ + if (!CHECK_STRUCT_TYPE(img, liq_image)) return LIQ_INVALID_POINTER; + if (!img->rows || !ownership_flags || (ownership_flags & ~(LIQ_OWN_ROWS|LIQ_OWN_PIXELS))) { + return LIQ_VALUE_OUT_OF_RANGE; + } + + if (ownership_flags & LIQ_OWN_ROWS) { + if (img->free_rows_internal) return LIQ_VALUE_OUT_OF_RANGE; + img->free_rows = true; + } + + if (ownership_flags & LIQ_OWN_PIXELS) { + img->free_pixels = true; + if (!img->pixels) { + // for simplicity of this API there's no explicit bitmap argument, + // so the row with the lowest address is assumed to be at the start of the bitmap + img->pixels = img->rows[0]; + for(unsigned int i=1; i < img->height; i++) { + img->pixels = MIN(img->pixels, img->rows[i]); + } + } + } + + return LIQ_OK; +} + +LIQ_NONNULL static void liq_image_free_maps(liq_image *input_image); +LIQ_NONNULL static void liq_image_free_importance_map(liq_image *input_image); + +LIQ_EXPORT LIQ_NONNULL liq_error liq_image_set_importance_map(liq_image *img, unsigned char importance_map[], size_t buffer_size, enum liq_ownership ownership) { + if (!CHECK_STRUCT_TYPE(img, liq_image)) return LIQ_INVALID_POINTER; + if (!CHECK_USER_POINTER(importance_map)) return LIQ_INVALID_POINTER; + + const size_t required_size = (size_t)img->width * (size_t)img->height; + if (buffer_size < required_size) { + return LIQ_BUFFER_TOO_SMALL; + } + + if (ownership == LIQ_COPY_PIXELS) { + unsigned char *tmp = img->malloc(required_size); + if (!tmp) { + return LIQ_OUT_OF_MEMORY; + } + memcpy(tmp, importance_map, required_size); + importance_map = tmp; + } else if (ownership != LIQ_OWN_PIXELS) { + return LIQ_UNSUPPORTED; + } + + liq_image_free_importance_map(img); + img->importance_map = importance_map; + + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_image_set_background(liq_image *img, liq_image *background) +{ + if (!CHECK_STRUCT_TYPE(img, liq_image)) return LIQ_INVALID_POINTER; + if (!CHECK_STRUCT_TYPE(background, liq_image)) return LIQ_INVALID_POINTER; + + if (background->background) { + return LIQ_UNSUPPORTED; + } + if (img->width != background->width || img->height != background->height) { + return LIQ_BUFFER_TOO_SMALL; + } + + if (img->background) { + liq_image_destroy(img->background); + } + + img->background = background; + liq_image_free_maps(img); // Force them to be re-analyzed with the background + + return LIQ_OK; +} + +LIQ_NONNULL static bool check_image_size(const liq_attr *attr, const int width, const int height) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) { + return false; + } + + if (width <= 0 || height <= 0) { + liq_log_error(attr, "width and height must be > 0"); + return false; + } + + if (width > INT_MAX/sizeof(rgba_pixel)/height || width > INT_MAX/16/sizeof(f_pixel) || height > INT_MAX/sizeof(size_t)) { + liq_log_error(attr, "image too large"); + return false; + } + return true; +} + +LIQ_EXPORT liq_image *liq_image_create_custom(const liq_attr *attr, liq_image_get_rgba_row_callback *row_callback, void* user_info, int width, int height, double gamma) +{ + if (!check_image_size(attr, width, height)) { + return NULL; + } + return liq_image_create_internal(attr, NULL, row_callback, user_info, width, height, gamma); +} + +LIQ_EXPORT liq_image *liq_image_create_rgba_rows(const liq_attr *attr, void *const rows[], int width, int height, double gamma) +{ + if (!check_image_size(attr, width, height)) { + return NULL; + } + + for(int i=0; i < height; i++) { + if (!CHECK_USER_POINTER(rows+i) || !CHECK_USER_POINTER(rows[i])) { + liq_log_error(attr, "invalid row pointers"); + return NULL; + } + } + return liq_image_create_internal(attr, (rgba_pixel**)rows, NULL, NULL, width, height, gamma); +} + +LIQ_EXPORT LIQ_NONNULL liq_image *liq_image_create_rgba(const liq_attr *attr, const void* bitmap, int width, int height, double gamma) +{ + if (!check_image_size(attr, width, height)) { + return NULL; + } + if (!CHECK_USER_POINTER(bitmap)) { + liq_log_error(attr, "invalid bitmap pointer"); + return NULL; + } + + rgba_pixel *const pixels = (rgba_pixel *const)bitmap; + rgba_pixel **rows = attr->malloc(sizeof(rows[0])*height); + if (!rows) return NULL; + + for(int i=0; i < height; i++) { + rows[i] = pixels + width * i; + } + + liq_image *image = liq_image_create_internal(attr, rows, NULL, NULL, width, height, gamma); + if (!image) { + attr->free(rows); + return NULL; + } + image->free_rows = true; + image->free_rows_internal = true; + return image; +} + +NEVER_INLINE LIQ_EXPORT void liq_executing_user_callback(liq_image_get_rgba_row_callback *callback, liq_color *temp_row, int row, int width, void *user_info); +LIQ_EXPORT void liq_executing_user_callback(liq_image_get_rgba_row_callback *callback, liq_color *temp_row, int row, int width, void *user_info) +{ + assert(callback); + assert(temp_row); + callback(temp_row, row, width, user_info); +} + +LIQ_NONNULL inline static bool liq_image_has_rgba_pixels(const liq_image *img) +{ + if (!CHECK_STRUCT_TYPE(img, liq_image)) { + return false; + } + return img->rows || (img->temp_row && img->row_callback); +} + +LIQ_NONNULL inline static bool liq_image_can_use_rgba_rows(const liq_image *img) +{ + assert(liq_image_has_rgba_pixels(img)); + return img->rows; +} + +LIQ_NONNULL static const rgba_pixel *liq_image_get_row_rgba(liq_image *img, unsigned int row) +{ + if (liq_image_can_use_rgba_rows(img)) { + return img->rows[row]; + } + + assert(img->temp_row); + rgba_pixel *temp_row = img->temp_row + LIQ_TEMP_ROW_WIDTH(img->width) * omp_get_thread_num(); + if (img->rows) { + memcpy(temp_row, img->rows[row], img->width * sizeof(temp_row[0])); + } else { + liq_executing_user_callback(img->row_callback, (liq_color*)temp_row, row, img->width, img->row_callback_user_info); + } + + return temp_row; +} + +LIQ_NONNULL static void convert_row_to_f(liq_image *img, f_pixel *row_f_pixels, const unsigned int row, const float gamma_lut[]) +{ + assert(row_f_pixels); + assert(!USE_SSE || 0 == ((uintptr_t)row_f_pixels & 15)); + + const rgba_pixel *const row_pixels = liq_image_get_row_rgba(img, row); + + for(unsigned int col=0; col < img->width; col++) { + row_f_pixels[col] = rgba_to_f(gamma_lut, row_pixels[col]); + } +} + +LIQ_NONNULL static bool liq_image_get_row_f_init(liq_image *img) +{ + assert(omp_get_thread_num() == 0); + if (img->f_pixels) { + return true; + } + if (!liq_image_should_use_low_memory(img, false)) { + img->f_pixels = img->malloc(sizeof(img->f_pixels[0]) * img->width * img->height); + } + if (!img->f_pixels) { + return liq_image_use_low_memory(img); + } + + if (!liq_image_has_rgba_pixels(img)) { + return false; + } + + float gamma_lut[256]; + to_f_set_gamma(gamma_lut, img->gamma); + for(unsigned int i=0; i < img->height; i++) { + convert_row_to_f(img, &img->f_pixels[i*img->width], i, gamma_lut); + } + return true; +} + +LIQ_NONNULL static const f_pixel *liq_image_get_row_f(liq_image *img, unsigned int row) +{ + if (!img->f_pixels) { + assert(img->temp_f_row); // init should have done that + float gamma_lut[256]; + to_f_set_gamma(gamma_lut, img->gamma); + f_pixel *row_for_thread = img->temp_f_row + LIQ_TEMP_ROW_WIDTH(img->width) * omp_get_thread_num(); + convert_row_to_f(img, row_for_thread, row, gamma_lut); + return row_for_thread; + } + return img->f_pixels + img->width * row; +} + +LIQ_EXPORT LIQ_NONNULL int liq_image_get_width(const liq_image *input_image) +{ + if (!CHECK_STRUCT_TYPE(input_image, liq_image)) return -1; + return input_image->width; +} + +LIQ_EXPORT LIQ_NONNULL int liq_image_get_height(const liq_image *input_image) +{ + if (!CHECK_STRUCT_TYPE(input_image, liq_image)) return -1; + return input_image->height; +} + +typedef void free_func(void*); + +LIQ_NONNULL static free_func *get_default_free_func(liq_image *img) +{ + // When default allocator is used then user-supplied pointers must be freed with free() + if (img->free_rows_internal || img->free != liq_aligned_free) { + return img->free; + } + return free; +} + +LIQ_NONNULL static void liq_image_free_rgba_source(liq_image *input_image) +{ + if (input_image->free_pixels && input_image->pixels) { + get_default_free_func(input_image)(input_image->pixels); + input_image->pixels = NULL; + } + + if (input_image->free_rows && input_image->rows) { + get_default_free_func(input_image)(input_image->rows); + input_image->rows = NULL; + } +} + +LIQ_NONNULL static void liq_image_free_importance_map(liq_image *input_image) { + if (input_image->importance_map) { + input_image->free(input_image->importance_map); + input_image->importance_map = NULL; + } +} + +LIQ_NONNULL static void liq_image_free_maps(liq_image *input_image) { + liq_image_free_importance_map(input_image); + + if (input_image->edges) { + input_image->free(input_image->edges); + input_image->edges = NULL; + } + + if (input_image->dither_map) { + input_image->free(input_image->dither_map); + input_image->dither_map = NULL; + } +} + +LIQ_EXPORT LIQ_NONNULL void liq_image_destroy(liq_image *input_image) +{ + if (!CHECK_STRUCT_TYPE(input_image, liq_image)) return; + + liq_image_free_rgba_source(input_image); + + liq_image_free_maps(input_image); + + if (input_image->f_pixels) { + input_image->free(input_image->f_pixels); + } + + if (input_image->temp_row) { + input_image->free(input_image->temp_row); + } + + if (input_image->temp_f_row) { + input_image->free(input_image->temp_f_row); + } + + if (input_image->background) { + liq_image_destroy(input_image->background); + } + + input_image->magic_header = liq_freed_magic; + input_image->free(input_image); +} + +LIQ_EXPORT liq_histogram* liq_histogram_create(const liq_attr* attr) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) { + return NULL; + } + + liq_histogram *hist = attr->malloc(sizeof(liq_histogram)); + if (!hist) return NULL; + *hist = (liq_histogram) { + .magic_header = liq_histogram_magic, + .malloc = attr->malloc, + .free = attr->free, + + .ignorebits = MAX(attr->min_posterization_output, attr->min_posterization_input), + }; + return hist; +} + +LIQ_EXPORT LIQ_NONNULL void liq_histogram_destroy(liq_histogram *hist) +{ + if (!CHECK_STRUCT_TYPE(hist, liq_histogram)) return; + hist->magic_header = liq_freed_magic; + + pam_freeacolorhash(hist->acht); + hist->free(hist); +} + +LIQ_EXPORT LIQ_NONNULL liq_result *liq_quantize_image(liq_attr *attr, liq_image *img) +{ + liq_result *res; + if (LIQ_OK != liq_image_quantize(img, attr, &res)) { + return NULL; + } + return res; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_image_quantize(liq_image *const img, liq_attr *const attr, liq_result **result_output) +{ + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return LIQ_INVALID_POINTER; + if (!liq_image_has_rgba_pixels(img)) { + return LIQ_UNSUPPORTED; + } + + liq_histogram *hist = liq_histogram_create(attr); + if (!hist) { + return LIQ_OUT_OF_MEMORY; + } + liq_error err = liq_histogram_add_image(hist, attr, img); + if (LIQ_OK != err) { + liq_histogram_destroy(hist); + return err; + } + + err = liq_histogram_quantize_internal(hist, attr, false, result_output); + liq_histogram_destroy(hist); + + return err; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_histogram_quantize(liq_histogram *input_hist, liq_attr *attr, liq_result **result_output) { + return liq_histogram_quantize_internal(input_hist, attr, true, result_output); +} + +LIQ_NONNULL static liq_error liq_histogram_quantize_internal(liq_histogram *input_hist, liq_attr *attr, bool fixed_result_colors, liq_result **result_output) +{ + if (!CHECK_USER_POINTER(result_output)) return LIQ_INVALID_POINTER; + *result_output = NULL; + + if (!CHECK_STRUCT_TYPE(attr, liq_attr)) return LIQ_INVALID_POINTER; + if (!CHECK_STRUCT_TYPE(input_hist, liq_histogram)) return LIQ_INVALID_POINTER; + + if (liq_progress(attr, 0)) return LIQ_ABORTED; + + histogram *hist; + liq_error err = finalize_histogram(input_hist, attr, &hist); + if (err != LIQ_OK) { + return err; + } + + err = pngquant_quantize(hist, attr, input_hist->fixed_colors_count, input_hist->fixed_colors, input_hist->gamma, fixed_result_colors, result_output); + pam_freeacolorhist(hist); + + return err; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_set_dithering_level(liq_result *res, float dither_level) +{ + if (!CHECK_STRUCT_TYPE(res, liq_result)) return LIQ_INVALID_POINTER; + + if (res->remapping) { + liq_remapping_result_destroy(res->remapping); + res->remapping = NULL; + } + + if (dither_level < 0 || dither_level > 1.0f) return LIQ_VALUE_OUT_OF_RANGE; + res->dither_level = dither_level; + return LIQ_OK; +} + +LIQ_NONNULL static liq_remapping_result *liq_remapping_result_create(liq_result *result) +{ + if (!CHECK_STRUCT_TYPE(result, liq_result)) { + return NULL; + } + + liq_remapping_result *res = result->malloc(sizeof(liq_remapping_result)); + if (!res) return NULL; + *res = (liq_remapping_result) { + .magic_header = liq_remapping_result_magic, + .malloc = result->malloc, + .free = result->free, + .dither_level = result->dither_level, + .use_dither_map = result->use_dither_map, + .palette_error = result->palette_error, + .gamma = result->gamma, + .palette = pam_duplicate_colormap(result->palette), + .progress_callback = result->progress_callback, + .progress_callback_user_info = result->progress_callback_user_info, + .progress_stage1 = result->use_dither_map ? 20 : 0, + }; + return res; +} + +LIQ_EXPORT LIQ_NONNULL double liq_get_output_gamma(const liq_result *result) +{ + if (!CHECK_STRUCT_TYPE(result, liq_result)) return -1; + + return result->gamma; +} + +LIQ_NONNULL static void liq_remapping_result_destroy(liq_remapping_result *result) +{ + if (!CHECK_STRUCT_TYPE(result, liq_remapping_result)) return; + + if (result->palette) pam_freecolormap(result->palette); + if (result->pixels) result->free(result->pixels); + + result->magic_header = liq_freed_magic; + result->free(result); +} + +LIQ_EXPORT LIQ_NONNULL void liq_result_destroy(liq_result *res) +{ + if (!CHECK_STRUCT_TYPE(res, liq_result)) return; + + memset(&res->int_palette, 0, sizeof(liq_palette)); + + if (res->remapping) { + memset(&res->remapping->int_palette, 0, sizeof(liq_palette)); + liq_remapping_result_destroy(res->remapping); + } + + pam_freecolormap(res->palette); + + res->magic_header = liq_freed_magic; + res->free(res); +} + + +LIQ_EXPORT LIQ_NONNULL double liq_get_quantization_error(const liq_result *result) { + if (!CHECK_STRUCT_TYPE(result, liq_result)) return -1; + + if (result->palette_error >= 0) { + return mse_to_standard_mse(result->palette_error); + } + + return -1; +} + +LIQ_EXPORT LIQ_NONNULL double liq_get_remapping_error(const liq_result *result) { + if (!CHECK_STRUCT_TYPE(result, liq_result)) return -1; + + if (result->remapping && result->remapping->palette_error >= 0) { + return mse_to_standard_mse(result->remapping->palette_error); + } + + return -1; +} + +LIQ_EXPORT LIQ_NONNULL int liq_get_quantization_quality(const liq_result *result) { + if (!CHECK_STRUCT_TYPE(result, liq_result)) return -1; + + if (result->palette_error >= 0) { + return mse_to_quality(result->palette_error); + } + + return -1; +} + +LIQ_EXPORT LIQ_NONNULL int liq_get_remapping_quality(const liq_result *result) { + if (!CHECK_STRUCT_TYPE(result, liq_result)) return -1; + + if (result->remapping && result->remapping->palette_error >= 0) { + return mse_to_quality(result->remapping->palette_error); + } + + return -1; +} + +LIQ_NONNULL static int compare_popularity(const void *ch1, const void *ch2) +{ + const float v1 = ((const colormap_item*)ch1)->popularity; + const float v2 = ((const colormap_item*)ch2)->popularity; + return v1 > v2 ? -1 : 1; +} + +LIQ_NONNULL static void sort_palette_qsort(colormap *map, int start, int nelem) +{ + if (!nelem) return; + qsort(map->palette + start, nelem, sizeof(map->palette[0]), compare_popularity); +} + +#define SWAP_PALETTE(map, a,b) { \ + const colormap_item tmp = (map)->palette[(a)]; \ + (map)->palette[(a)] = (map)->palette[(b)]; \ + (map)->palette[(b)] = tmp; } + +LIQ_NONNULL static void sort_palette(colormap *map, const liq_attr *options) +{ + /* + ** Step 3.5 [GRR]: remap the palette colors so that all entries with + ** the maximal alpha value (i.e., fully opaque) are at the end and can + ** therefore be omitted from the tRNS chunk. + */ + if (options->last_index_transparent) { + for(unsigned int i=0; i < map->colors; i++) { + if (map->palette[i].acolor.a < 1.f/256.f) { + const unsigned int old = i, transparent_dest = map->colors-1; + + SWAP_PALETTE(map, transparent_dest, old); + + /* colors sorted by popularity make pngs slightly more compressible */ + sort_palette_qsort(map, 0, map->colors-1); + return; + } + } + } + + unsigned int non_fixed_colors = 0; + for(unsigned int i = 0; i < map->colors; i++) { + if (map->palette[i].fixed) { + break; + } + non_fixed_colors++; + } + + /* move transparent colors to the beginning to shrink trns chunk */ + unsigned int num_transparent = 0; + for(unsigned int i = 0; i < non_fixed_colors; i++) { + if (map->palette[i].acolor.a < 255.f/256.f) { + // current transparent color is swapped with earlier opaque one + if (i != num_transparent) { + SWAP_PALETTE(map, num_transparent, i); + i--; + } + num_transparent++; + } + } + + liq_verbose_printf(options, " eliminated opaque tRNS-chunk entries...%d entr%s transparent", num_transparent, (num_transparent == 1)? "y" : "ies"); + + /* colors sorted by popularity make pngs slightly more compressible + * opaque and transparent are sorted separately + */ + sort_palette_qsort(map, 0, num_transparent); + sort_palette_qsort(map, num_transparent, non_fixed_colors - num_transparent); + + if (non_fixed_colors > 9 && map->colors > 16) { + SWAP_PALETTE(map, 7, 1); // slightly improves compression + SWAP_PALETTE(map, 8, 2); + SWAP_PALETTE(map, 9, 3); + } +} + +inline static unsigned int posterize_channel(unsigned int color, unsigned int bits) +{ + return (color & ~((1<> (8-bits)); +} + +LIQ_NONNULL static void set_rounded_palette(liq_palette *const dest, colormap *const map, const double gamma, unsigned int posterize) +{ + float gamma_lut[256]; + to_f_set_gamma(gamma_lut, gamma); + + dest->count = map->colors; + for(unsigned int x = 0; x < map->colors; ++x) { + rgba_pixel px = f_to_rgb(gamma, map->palette[x].acolor); + + px.r = posterize_channel(px.r, posterize); + px.g = posterize_channel(px.g, posterize); + px.b = posterize_channel(px.b, posterize); + px.a = posterize_channel(px.a, posterize); + + map->palette[x].acolor = rgba_to_f(gamma_lut, px); /* saves rounding error introduced by to_rgb, which makes remapping & dithering more accurate */ + + if (!px.a && !map->palette[x].fixed) { + px.r = 71; px.g = 112; px.b = 76; + } + + dest->entries[x] = (liq_color){.r=px.r,.g=px.g,.b=px.b,.a=px.a}; + } +} + +LIQ_EXPORT LIQ_NONNULL const liq_palette *liq_get_palette(liq_result *result) +{ + if (!CHECK_STRUCT_TYPE(result, liq_result)) return NULL; + + if (result->remapping && result->remapping->int_palette.count) { + return &result->remapping->int_palette; + } + + if (!result->int_palette.count) { + set_rounded_palette(&result->int_palette, result->palette, result->gamma, result->min_posterization_output); + } + return &result->int_palette; +} + +LIQ_NONNULL static float remap_to_palette(liq_image *const input_image, unsigned char *const *const output_pixels, colormap *const map) +{ + const int rows = input_image->height; + const unsigned int cols = input_image->width; + double remapping_error=0; + + if (!liq_image_get_row_f_init(input_image)) { + return -1; + } + if (input_image->background && !liq_image_get_row_f_init(input_image->background)) { + return -1; + } + + const colormap_item *acolormap = map->palette; + + struct nearest_map *const n = nearest_init(map); + const int transparent_index = input_image->background ? nearest_search(n, &(f_pixel){0,0,0,0}, 0, NULL) : 0; + + + const unsigned int max_threads = omp_get_max_threads(); + LIQ_ARRAY(kmeans_state, average_color, (KMEANS_CACHE_LINE_GAP+map->colors) * max_threads); + kmeans_init(map, max_threads, average_color); + +#if __GNUC__ >= 9 || __clang__ + #pragma omp parallel for if (rows*cols > 3000) \ + schedule(static) default(none) shared(acolormap,average_color,cols,input_image,map,n,output_pixels,rows,transparent_index) reduction(+:remapping_error) +#else + #pragma omp parallel for if (rows*cols > 3000) \ + schedule(static) default(none) shared(acolormap) shared(average_color) reduction(+:remapping_error) +#endif + for(int row = 0; row < rows; ++row) { + const f_pixel *const row_pixels = liq_image_get_row_f(input_image, row); + const f_pixel *const bg_pixels = input_image->background && acolormap[transparent_index].acolor.a < 1.f/256.f ? liq_image_get_row_f(input_image->background, row) : NULL; + + unsigned int last_match=0; + for(unsigned int col = 0; col < cols; ++col) { + float diff; + last_match = nearest_search(n, &row_pixels[col], last_match, &diff); + if (bg_pixels && colordifference(bg_pixels[col], acolormap[last_match].acolor) <= diff) { + last_match = transparent_index; + } + output_pixels[row][col] = last_match; + + remapping_error += diff; + kmeans_update_color(row_pixels[col], 1.0, map, last_match, omp_get_thread_num(), average_color); + } + } + + kmeans_finalize(map, max_threads, average_color); + + nearest_free(n); + + return remapping_error / (input_image->width * input_image->height); +} + +inline static f_pixel get_dithered_pixel(const float dither_level, const float max_dither_error, const f_pixel thiserr, const f_pixel px) +{ + /* Use Floyd-Steinberg errors to adjust actual color. */ + const float sr = thiserr.r * dither_level, + sg = thiserr.g * dither_level, + sb = thiserr.b * dither_level, + sa = thiserr.a * dither_level; + + float ratio = 1.0; + const float max_overflow = 1.1f; + const float max_underflow = -0.1f; + + // allowing some overflow prevents undithered bands caused by clamping of all channels + if (px.r + sr > max_overflow) ratio = MIN(ratio, (max_overflow -px.r)/sr); + else { if (px.r + sr < max_underflow) ratio = MIN(ratio, (max_underflow-px.r)/sr); } + if (px.g + sg > max_overflow) ratio = MIN(ratio, (max_overflow -px.g)/sg); + else { if (px.g + sg < max_underflow) ratio = MIN(ratio, (max_underflow-px.g)/sg); } + if (px.b + sb > max_overflow) ratio = MIN(ratio, (max_overflow -px.b)/sb); + else { if (px.b + sb < max_underflow) ratio = MIN(ratio, (max_underflow-px.b)/sb); } + + float a = px.a + sa; + if (a > 1.f) { a = 1.f; } + else if (a < 0) { a = 0; } + + // If dithering error is crazy high, don't propagate it that much + // This prevents crazy geen pixels popping out of the blue (or red or black! ;) + const float dither_error = sr*sr + sg*sg + sb*sb + sa*sa; + if (dither_error > max_dither_error) { + ratio *= 0.8f; + } else if (dither_error < 2.f/256.f/256.f) { + // don't dither areas that don't have noticeable error — makes file smaller + return px; + } + + return (f_pixel) { + .r=px.r + sr * ratio, + .g=px.g + sg * ratio, + .b=px.b + sb * ratio, + .a=a, + }; +} + +/** + Uses edge/noise map to apply dithering only to flat areas. Dithering on edges creates jagged lines, and noisy areas are "naturally" dithered. + + If output_image_is_remapped is true, only pixels noticeably changed by error diffusion will be written to output image. + */ +LIQ_NONNULL static bool remap_to_palette_floyd(liq_image *input_image, unsigned char *const output_pixels[], liq_remapping_result *quant, const float max_dither_error, const bool output_image_is_remapped) +{ + const int rows = input_image->height, cols = input_image->width; + const unsigned char *dither_map = quant->use_dither_map ? (input_image->dither_map ? input_image->dither_map : input_image->edges) : NULL; + + const colormap *map = quant->palette; + const colormap_item *acolormap = map->palette; + + if (!liq_image_get_row_f_init(input_image)) { + return false; + } + if (input_image->background && !liq_image_get_row_f_init(input_image->background)) { + return false; + } + + /* Initialize Floyd-Steinberg error vectors. */ + const size_t errwidth = cols+2; + f_pixel *restrict thiserr = input_image->malloc(errwidth * sizeof(thiserr[0]) * 2); // +2 saves from checking out of bounds access + if (!thiserr) return false; + f_pixel *restrict nexterr = thiserr + errwidth; + memset(thiserr, 0, errwidth * sizeof(thiserr[0])); + + bool ok = true; + struct nearest_map *const n = nearest_init(map); + const int transparent_index = input_image->background ? nearest_search(n, &(f_pixel){0,0,0,0}, 0, NULL) : 0; + + // response to this value is non-linear and without it any value < 0.8 would give almost no dithering + float base_dithering_level = quant->dither_level; + base_dithering_level = 1.f - (1.f-base_dithering_level)*(1.f-base_dithering_level); + + if (dither_map) { + base_dithering_level *= 1.f/255.f; // convert byte to float + } + base_dithering_level *= 15.f/16.f; // prevent small errors from accumulating + + int fs_direction = 1; + unsigned int last_match=0; + for (int row = 0; row < rows; ++row) { + if (liq_remap_progress(quant, quant->progress_stage1 + row * (100.f - quant->progress_stage1) / rows)) { + ok = false; + break; + } + + memset(nexterr, 0, errwidth * sizeof(nexterr[0])); + + int col = (fs_direction > 0) ? 0 : (cols - 1); + const f_pixel *const row_pixels = liq_image_get_row_f(input_image, row); + const f_pixel *const bg_pixels = input_image->background && acolormap[transparent_index].acolor.a < 1.f/256.f ? liq_image_get_row_f(input_image->background, row) : NULL; + + do { + float dither_level = base_dithering_level; + if (dither_map) { + dither_level *= dither_map[row*cols + col]; + } + + const f_pixel spx = get_dithered_pixel(dither_level, max_dither_error, thiserr[col + 1], row_pixels[col]); + + const unsigned int guessed_match = output_image_is_remapped ? output_pixels[row][col] : last_match; + float diff; + last_match = nearest_search(n, &spx, guessed_match, &diff); + f_pixel output_px = acolormap[last_match].acolor; + if (bg_pixels && colordifference(bg_pixels[col], output_px) <= diff) { + output_px = bg_pixels[col]; + output_pixels[row][col] = transparent_index; + } else { + output_pixels[row][col] = last_match; + } + + f_pixel err = { + .r = (spx.r - output_px.r), + .g = (spx.g - output_px.g), + .b = (spx.b - output_px.b), + .a = (spx.a - output_px.a), + }; + + // If dithering error is crazy high, don't propagate it that much + // This prevents crazy geen pixels popping out of the blue (or red or black! ;) + if (err.r*err.r + err.g*err.g + err.b*err.b + err.a*err.a > max_dither_error) { + err.r *= 0.75f; + err.g *= 0.75f; + err.b *= 0.75f; + err.a *= 0.75f; + } + + /* Propagate Floyd-Steinberg error terms. */ + if (fs_direction > 0) { + thiserr[col + 2].a += err.a * (7.f/16.f); + thiserr[col + 2].r += err.r * (7.f/16.f); + thiserr[col + 2].g += err.g * (7.f/16.f); + thiserr[col + 2].b += err.b * (7.f/16.f); + + nexterr[col + 2].a = err.a * (1.f/16.f); + nexterr[col + 2].r = err.r * (1.f/16.f); + nexterr[col + 2].g = err.g * (1.f/16.f); + nexterr[col + 2].b = err.b * (1.f/16.f); + + nexterr[col + 1].a += err.a * (5.f/16.f); + nexterr[col + 1].r += err.r * (5.f/16.f); + nexterr[col + 1].g += err.g * (5.f/16.f); + nexterr[col + 1].b += err.b * (5.f/16.f); + + nexterr[col ].a += err.a * (3.f/16.f); + nexterr[col ].r += err.r * (3.f/16.f); + nexterr[col ].g += err.g * (3.f/16.f); + nexterr[col ].b += err.b * (3.f/16.f); + + } else { + thiserr[col ].a += err.a * (7.f/16.f); + thiserr[col ].r += err.r * (7.f/16.f); + thiserr[col ].g += err.g * (7.f/16.f); + thiserr[col ].b += err.b * (7.f/16.f); + + nexterr[col ].a = err.a * (1.f/16.f); + nexterr[col ].r = err.r * (1.f/16.f); + nexterr[col ].g = err.g * (1.f/16.f); + nexterr[col ].b = err.b * (1.f/16.f); + + nexterr[col + 1].a += err.a * (5.f/16.f); + nexterr[col + 1].r += err.r * (5.f/16.f); + nexterr[col + 1].g += err.g * (5.f/16.f); + nexterr[col + 1].b += err.b * (5.f/16.f); + + nexterr[col + 2].a += err.a * (3.f/16.f); + nexterr[col + 2].r += err.r * (3.f/16.f); + nexterr[col + 2].g += err.g * (3.f/16.f); + nexterr[col + 2].b += err.b * (3.f/16.f); + } + + // remapping is done in zig-zag + col += fs_direction; + if (fs_direction > 0) { + if (col >= cols) break; + } else { + if (col < 0) break; + } + } while(1); + + f_pixel *const temperr = thiserr; + thiserr = nexterr; + nexterr = temperr; + fs_direction = -fs_direction; + } + + input_image->free(MIN(thiserr, nexterr)); // MIN because pointers were swapped + nearest_free(n); + + return ok; +} + +/* fixed colors are always included in the palette, so it would be wasteful to duplicate them in palette from histogram */ +LIQ_NONNULL static void remove_fixed_colors_from_histogram(histogram *hist, const int fixed_colors_count, const f_pixel fixed_colors[], const float target_mse) +{ + const float max_difference = MAX(target_mse/2.f, 2.f/256.f/256.f); + if (fixed_colors_count) { + for(int j=0; j < hist->size; j++) { + for(unsigned int i=0; i < fixed_colors_count; i++) { + if (colordifference(hist->achv[j].acolor, fixed_colors[i]) < max_difference) { + hist->achv[j] = hist->achv[--hist->size]; // remove color from histogram by overwriting with the last entry + j--; break; // continue searching histogram + } + } + } + } +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_histogram_add_colors(liq_histogram *input_hist, const liq_attr *options, const liq_histogram_entry entries[], int num_entries, double gamma) +{ + if (!CHECK_STRUCT_TYPE(options, liq_attr)) return LIQ_INVALID_POINTER; + if (!CHECK_STRUCT_TYPE(input_hist, liq_histogram)) return LIQ_INVALID_POINTER; + if (!CHECK_USER_POINTER(entries)) return LIQ_INVALID_POINTER; + if (gamma < 0 || gamma >= 1.0) return LIQ_VALUE_OUT_OF_RANGE; + if (num_entries <= 0 || num_entries > 1<<30) return LIQ_VALUE_OUT_OF_RANGE; + + if (input_hist->ignorebits > 0 && input_hist->had_image_added) { + return LIQ_UNSUPPORTED; + } + input_hist->ignorebits = 0; + + input_hist->had_image_added = true; + input_hist->gamma = gamma ? gamma : 0.45455; + + if (!input_hist->acht) { + input_hist->acht = pam_allocacolorhash(~0, num_entries*num_entries, 0, options->malloc, options->free); + if (!input_hist->acht) { + return LIQ_OUT_OF_MEMORY; + } + } + // Fake image size. It's only for hash size estimates. + if (!input_hist->acht->cols) { + input_hist->acht->cols = num_entries; + } + input_hist->acht->rows += num_entries; + + const unsigned int hash_size = input_hist->acht->hash_size; + for(int i=0; i < num_entries; i++) { + const rgba_pixel rgba = { + .r = entries[i].color.r, + .g = entries[i].color.g, + .b = entries[i].color.b, + .a = entries[i].color.a, + }; + union rgba_as_int px = {rgba}; + unsigned int hash; + if (px.rgba.a) { + hash = px.l % hash_size; + } else { + hash=0; px.l=0; + } + if (!pam_add_to_hash(input_hist->acht, hash, entries[i].count, px, i, num_entries)) { + return LIQ_OUT_OF_MEMORY; + } + } + + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_histogram_add_image(liq_histogram *input_hist, const liq_attr *options, liq_image *input_image) +{ + if (!CHECK_STRUCT_TYPE(options, liq_attr)) return LIQ_INVALID_POINTER; + if (!CHECK_STRUCT_TYPE(input_hist, liq_histogram)) return LIQ_INVALID_POINTER; + if (!CHECK_STRUCT_TYPE(input_image, liq_image)) return LIQ_INVALID_POINTER; + + const unsigned int cols = input_image->width, rows = input_image->height; + + if (!input_image->importance_map && options->use_contrast_maps) { + contrast_maps(input_image); + } + + input_hist->gamma = input_image->gamma; + + for(int i = 0; i < input_image->fixed_colors_count; i++) { + liq_error res = liq_histogram_add_fixed_color_f(input_hist, input_image->fixed_colors[i]); + if (res != LIQ_OK) { + return res; + } + } + + /* + ** Step 2: attempt to make a histogram of the colors, unclustered. + ** If at first we don't succeed, increase ignorebits to increase color + ** coherence and try again. + */ + + if (liq_progress(options, options->progress_stage1 * 0.4f)) { + return LIQ_ABORTED; + } + + const bool all_rows_at_once = liq_image_can_use_rgba_rows(input_image); + + // Usual solution is to start from scratch when limit is exceeded, but that's not possible if it's not + // the first image added + const unsigned int max_histogram_entries = input_hist->had_image_added ? ~0 : options->max_histogram_entries; + do { + if (!input_hist->acht) { + input_hist->acht = pam_allocacolorhash(max_histogram_entries, rows*cols, input_hist->ignorebits, options->malloc, options->free); + } + if (!input_hist->acht) return LIQ_OUT_OF_MEMORY; + + // histogram uses noise contrast map for importance. Color accuracy in noisy areas is not very important. + // noise map does not include edges to avoid ruining anti-aliasing + for(unsigned int row=0; row < rows; row++) { + bool added_ok; + if (all_rows_at_once) { + added_ok = pam_computeacolorhash(input_hist->acht, (const rgba_pixel *const *)input_image->rows, cols, rows, input_image->importance_map); + if (added_ok) break; + } else { + const rgba_pixel* rows_p[1] = { liq_image_get_row_rgba(input_image, row) }; + added_ok = pam_computeacolorhash(input_hist->acht, rows_p, cols, 1, input_image->importance_map ? &input_image->importance_map[row * cols] : NULL); + } + if (!added_ok) { + input_hist->ignorebits++; + liq_verbose_printf(options, " too many colors! Scaling colors to improve clustering... %d", input_hist->ignorebits); + pam_freeacolorhash(input_hist->acht); + input_hist->acht = NULL; + if (liq_progress(options, options->progress_stage1 * 0.6f)) return LIQ_ABORTED; + break; + } + } + } while(!input_hist->acht); + + input_hist->had_image_added = true; + + liq_image_free_importance_map(input_image); + + if (input_image->free_pixels && input_image->f_pixels) { + liq_image_free_rgba_source(input_image); // bow can free the RGBA source if copy has been made in f_pixels + } + + return LIQ_OK; +} + +LIQ_NONNULL static liq_error finalize_histogram(liq_histogram *input_hist, liq_attr *options, histogram **hist_output) +{ + if (liq_progress(options, options->progress_stage1 * 0.9f)) { + return LIQ_ABORTED; + } + + if (!input_hist->acht) { + return LIQ_BITMAP_NOT_AVAILABLE; + } + + histogram *hist = pam_acolorhashtoacolorhist(input_hist->acht, input_hist->gamma, options->malloc, options->free); + pam_freeacolorhash(input_hist->acht); + input_hist->acht = NULL; + + if (!hist) { + return LIQ_OUT_OF_MEMORY; + } + liq_verbose_printf(options, " made histogram...%d colors found", hist->size); + remove_fixed_colors_from_histogram(hist, input_hist->fixed_colors_count, input_hist->fixed_colors, options->target_mse); + + *hist_output = hist; + return LIQ_OK; +} + +/** + Builds two maps: + importance_map - approximation of areas with high-frequency noise, except straight edges. 1=flat, 0=noisy. + edges - noise map including all edges + */ +LIQ_NONNULL static void contrast_maps(liq_image *image) +{ + const unsigned int cols = image->width, rows = image->height; + if (cols < 4 || rows < 4 || (3*cols*rows) > LIQ_HIGH_MEMORY_LIMIT) { + return; + } + + unsigned char *restrict noise = image->importance_map ? image->importance_map : image->malloc(cols*rows); + image->importance_map = NULL; + unsigned char *restrict edges = image->edges ? image->edges : image->malloc(cols*rows); + image->edges = NULL; + + unsigned char *restrict tmp = image->malloc(cols*rows); + + if (!noise || !edges || !tmp || !liq_image_get_row_f_init(image)) { + image->free(noise); + image->free(edges); + image->free(tmp); + return; + } + + const f_pixel *curr_row, *prev_row, *next_row; + curr_row = prev_row = next_row = liq_image_get_row_f(image, 0); + + for (unsigned int j=0; j < rows; j++) { + prev_row = curr_row; + curr_row = next_row; + next_row = liq_image_get_row_f(image, MIN(rows-1,j+1)); + + f_pixel prev, curr = curr_row[0], next=curr; + for (unsigned int i=0; i < cols; i++) { + prev=curr; + curr=next; + next = curr_row[MIN(cols-1,i+1)]; + + // contrast is difference between pixels neighbouring horizontally and vertically + const float a = fabsf(prev.a+next.a - curr.a*2.f), + r = fabsf(prev.r+next.r - curr.r*2.f), + g = fabsf(prev.g+next.g - curr.g*2.f), + b = fabsf(prev.b+next.b - curr.b*2.f); + + const f_pixel prevl = prev_row[i]; + const f_pixel nextl = next_row[i]; + + const float a1 = fabsf(prevl.a+nextl.a - curr.a*2.f), + r1 = fabsf(prevl.r+nextl.r - curr.r*2.f), + g1 = fabsf(prevl.g+nextl.g - curr.g*2.f), + b1 = fabsf(prevl.b+nextl.b - curr.b*2.f); + + const float horiz = MAX(MAX(a,r),MAX(g,b)); + const float vert = MAX(MAX(a1,r1),MAX(g1,b1)); + const float edge = MAX(horiz,vert); + float z = edge - fabsf(horiz-vert)*.5f; + z = 1.f - MAX(z,MIN(horiz,vert)); + z *= z; // noise is amplified + z *= z; + // 85 is about 1/3rd of weight (not 0, because noisy pixels still need to be included, just not as precisely). + const unsigned int z_int = 85 + (unsigned int)(z * 171.f); + noise[j*cols+i] = MIN(z_int, 255); + const int e_int = 255 - (int)(edge * 256.f); + edges[j*cols+i] = e_int > 0 ? MIN(e_int, 255) : 0; + } + } + + // noise areas are shrunk and then expanded to remove thin edges from the map + liq_max3(noise, tmp, cols, rows); + liq_max3(tmp, noise, cols, rows); + + liq_blur(noise, tmp, noise, cols, rows, 3); + + liq_max3(noise, tmp, cols, rows); + + liq_min3(tmp, noise, cols, rows); + liq_min3(noise, tmp, cols, rows); + liq_min3(tmp, noise, cols, rows); + + liq_min3(edges, tmp, cols, rows); + liq_max3(tmp, edges, cols, rows); + for(unsigned int i=0; i < cols*rows; i++) edges[i] = MIN(noise[i], edges[i]); + + image->free(tmp); + + image->importance_map = noise; + image->edges = edges; +} + +/** + * Builds map of neighbor pixels mapped to the same palette entry + * + * For efficiency/simplicity it mainly looks for same consecutive pixels horizontally + * and peeks 1 pixel above/below. Full 2d algorithm doesn't improve it significantly. + * Correct flood fill doesn't have visually good properties. + */ +LIQ_NONNULL static void update_dither_map(liq_image *input_image, unsigned char *const *const row_pointers, colormap *map) +{ + const unsigned int width = input_image->width; + const unsigned int height = input_image->height; + unsigned char *const edges = input_image->edges; + + for(unsigned int row=0; row < height; row++) { + unsigned char lastpixel = row_pointers[row][0]; + unsigned int lastcol=0; + + for(unsigned int col=1; col < width; col++) { + const unsigned char px = row_pointers[row][col]; + if (input_image->background && map->palette[px].acolor.a < 1.f/256.f) { + // Transparency may or may not create an edge. When there's an explicit background set, assume no edge. + continue; + } + + if (px != lastpixel || col == width-1) { + int neighbor_count = 10 * (col-lastcol); + + unsigned int i=lastcol; + while(i < col) { + if (row > 0) { + unsigned char pixelabove = row_pointers[row-1][i]; + if (pixelabove == lastpixel) neighbor_count += 15; + } + if (row < height-1) { + unsigned char pixelbelow = row_pointers[row+1][i]; + if (pixelbelow == lastpixel) neighbor_count += 15; + } + i++; + } + + while(lastcol <= col) { + int e = edges[row*width + lastcol]; + edges[row*width + lastcol++] = (e+128) * (255.f/(255+128)) * (1.f - 20.f / (20 + neighbor_count)); + } + lastpixel = px; + } + } + } + input_image->dither_map = input_image->edges; + input_image->edges = NULL; +} + +/** + * Palette can be NULL, in which case it creates a new palette from scratch. + */ +static colormap *add_fixed_colors_to_palette(colormap *palette, const int max_colors, const f_pixel fixed_colors[], const int fixed_colors_count, void* (*malloc)(size_t), void (*free)(void*)) +{ + if (!fixed_colors_count) return palette; + + colormap *newpal = pam_colormap(MIN(max_colors, (palette ? palette->colors : 0) + fixed_colors_count), malloc, free); + unsigned int i=0; + if (palette && fixed_colors_count < max_colors) { + unsigned int palette_max = MIN(palette->colors, max_colors - fixed_colors_count); + for(; i < palette_max; i++) { + newpal->palette[i] = palette->palette[i]; + } + } + for(int j=0; j < MIN(max_colors, fixed_colors_count); j++) { + newpal->palette[i++] = (colormap_item){ + .acolor = fixed_colors[j], + .fixed = true, + }; + } + if (palette) pam_freecolormap(palette); + return newpal; +} + +LIQ_NONNULL static void adjust_histogram_callback(hist_item *item, float diff) +{ + item->adjusted_weight = (item->perceptual_weight+item->adjusted_weight) * (sqrtf(1.f+diff)); +} + +/** + Repeats mediancut with different histogram weights to find palette with minimum error. + + feedback_loop_trials controls how long the search will take. < 0 skips the iteration. + */ +static colormap *find_best_palette(histogram *hist, const liq_attr *options, const double max_mse, const f_pixel fixed_colors[], const unsigned int fixed_colors_count, double *palette_error_p) +{ + unsigned int max_colors = options->max_colors; + + // if output is posterized it doesn't make sense to aim for perfrect colors, so increase target_mse + // at this point actual gamma is not set, so very conservative posterization estimate is used + const double target_mse = MIN(max_mse, MAX(options->target_mse, pow((1<min_posterization_output)/1024.0, 2))); + int feedback_loop_trials = options->feedback_loop_trials; + if (hist->size > 5000) {feedback_loop_trials = (feedback_loop_trials*3 + 3)/4;} + if (hist->size > 25000) {feedback_loop_trials = (feedback_loop_trials*3 + 3)/4;} + if (hist->size > 50000) {feedback_loop_trials = (feedback_loop_trials*3 + 3)/4;} + if (hist->size > 100000) {feedback_loop_trials = (feedback_loop_trials*3 + 3)/4;} + colormap *acolormap = NULL; + double least_error = MAX_DIFF; + double target_mse_overshoot = feedback_loop_trials>0 ? 1.05 : 1.0; + const float total_trials = (float)(feedback_loop_trials>0?feedback_loop_trials:1); + int fails_in_a_row=0; + + do { + colormap *newmap; + if (hist->size && fixed_colors_count < max_colors) { + newmap = mediancut(hist, max_colors-fixed_colors_count, target_mse * target_mse_overshoot, MAX(MAX(45.0/65536.0, target_mse), least_error)*1.2, + options->malloc, options->free); + } else { + feedback_loop_trials = 0; + newmap = NULL; + } + newmap = add_fixed_colors_to_palette(newmap, max_colors, fixed_colors, fixed_colors_count, options->malloc, options->free); + if (!newmap) { + return NULL; + } + + if (feedback_loop_trials <= 0) { + return newmap; + } + + // after palette has been created, total error (MSE) is calculated to keep the best palette + // at the same time K-Means iteration is done to improve the palette + // and histogram weights are adjusted based on remapping error to give more weight to poorly matched colors + + const bool first_run_of_target_mse = !acolormap && target_mse > 0; + double total_error = kmeans_do_iteration(hist, newmap, first_run_of_target_mse ? NULL : adjust_histogram_callback); + + // goal is to increase quality or to reduce number of colors used if quality is good enough + if (!acolormap || total_error < least_error || (total_error <= target_mse && newmap->colors < max_colors)) { + if (acolormap) pam_freecolormap(acolormap); + acolormap = newmap; + + if (total_error < target_mse && total_error > 0) { + // K-Means iteration improves quality above what mediancut aims for + // this compensates for it, making mediancut aim for worse + target_mse_overshoot = MIN(target_mse_overshoot*1.25, target_mse/total_error); + } + + least_error = total_error; + + // if number of colors could be reduced, try to keep it that way + // but allow extra color as a bit of wiggle room in case quality can be improved too + max_colors = MIN(newmap->colors+1, max_colors); + + feedback_loop_trials -= 1; // asymptotic improvement could make it go on forever + fails_in_a_row = 0; + } else { + fails_in_a_row++; + target_mse_overshoot = 1.0; + + // if error is really bad, it's unlikely to improve, so end sooner + feedback_loop_trials -= 5 + fails_in_a_row; + pam_freecolormap(newmap); + } + + float fraction_done = 1.f-MAX(0.f, feedback_loop_trials/total_trials); + if (liq_progress(options, options->progress_stage1 + fraction_done * options->progress_stage2)) break; + liq_verbose_printf(options, " selecting colors...%d%%", (int)(100.f * fraction_done)); + } + while(feedback_loop_trials > 0); + + *palette_error_p = least_error; + return acolormap; +} + +static colormap *histogram_to_palette(const histogram *hist, const liq_attr *options) { + if (!hist->size) { + return NULL; + } + colormap *acolormap = pam_colormap(hist->size, options->malloc, options->free); + for(unsigned int i=0; i < hist->size; i++) { + acolormap->palette[i].acolor = hist->achv[i].acolor; + acolormap->palette[i].popularity = hist->achv[i].perceptual_weight; + } + return acolormap; +} + +LIQ_NONNULL static liq_error pngquant_quantize(histogram *hist, const liq_attr *options, const int fixed_colors_count, const f_pixel fixed_colors[], const double gamma, bool fixed_result_colors, liq_result **result_output) +{ + colormap *acolormap; + double palette_error = -1; + + assert((verbose_print(options, "SLOW debug checks enabled. Recompile with NDEBUG for normal operation."),1)); + + const bool few_input_colors = hist->size+fixed_colors_count <= options->max_colors; + + if (liq_progress(options, options->progress_stage1)) return LIQ_ABORTED; + + // If image has few colors to begin with (and no quality degradation is required) + // then it's possible to skip quantization entirely + if (few_input_colors && options->target_mse == 0) { + acolormap = add_fixed_colors_to_palette(histogram_to_palette(hist, options), options->max_colors, fixed_colors, fixed_colors_count, options->malloc, options->free); + palette_error = 0; + } else { + const double max_mse = options->max_mse * (few_input_colors ? 0.33 : 1.0); // when degrading image that's already paletted, require much higher improvement, since pal2pal often looks bad and there's little gain + acolormap = find_best_palette(hist, options, max_mse, fixed_colors, fixed_colors_count, &palette_error); + if (!acolormap) { + return LIQ_VALUE_OUT_OF_RANGE; + } + + // K-Means iteration approaches local minimum for the palette + double iteration_limit = options->kmeans_iteration_limit; + unsigned int iterations = options->kmeans_iterations; + + if (!iterations && palette_error < 0 && max_mse < MAX_DIFF) iterations = 1; // otherwise total error is never calculated and MSE limit won't work + + if (iterations) { + // likely_colormap_index (used and set in kmeans_do_iteration) can't point to index outside colormap + if (acolormap->colors < 256) for(unsigned int j=0; j < hist->size; j++) { + if (hist->achv[j].tmp.likely_colormap_index >= acolormap->colors) { + hist->achv[j].tmp.likely_colormap_index = 0; // actual value doesn't matter, as the guess is out of date anyway + } + } + + if (hist->size > 5000) {iterations = (iterations*3 + 3)/4;} + if (hist->size > 25000) {iterations = (iterations*3 + 3)/4;} + if (hist->size > 50000) {iterations = (iterations*3 + 3)/4;} + if (hist->size > 100000) {iterations = (iterations*3 + 3)/4; iteration_limit *= 2;} + + verbose_print(options, " moving colormap towards local minimum"); + + double previous_palette_error = MAX_DIFF; + + for(unsigned int i=0; i < iterations; i++) { + palette_error = kmeans_do_iteration(hist, acolormap, NULL); + + if (liq_progress(options, options->progress_stage1 + options->progress_stage2 + (i * options->progress_stage3 * 0.9f) / iterations)) { + break; + } + + if (fabs(previous_palette_error-palette_error) < iteration_limit) { + break; + } + + if (palette_error > max_mse*1.5) { // probably hopeless + if (palette_error > max_mse*3.0) break; // definitely hopeless + i++; + } + + previous_palette_error = palette_error; + } + } + + if (palette_error > max_mse) { + liq_verbose_printf(options, " image degradation MSE=%.3f (Q=%d) exceeded limit of %.3f (%d)", + mse_to_standard_mse(palette_error), mse_to_quality(palette_error), + mse_to_standard_mse(max_mse), mse_to_quality(max_mse)); + pam_freecolormap(acolormap); + return LIQ_QUALITY_TOO_LOW; + } + } + + if (liq_progress(options, options->progress_stage1 + options->progress_stage2 + options->progress_stage3 * 0.95f)) { + pam_freecolormap(acolormap); + return LIQ_ABORTED; + } + + sort_palette(acolormap, options); + + // If palette was created from a multi-image histogram, + // then it shouldn't be optimized for one image during remapping + if (fixed_result_colors) { + for(unsigned int i=0; i < acolormap->colors; i++) { + acolormap->palette[i].fixed = true; + } + } + + liq_result *result = options->malloc(sizeof(liq_result)); + if (!result) return LIQ_OUT_OF_MEMORY; + *result = (liq_result){ + .magic_header = liq_result_magic, + .malloc = options->malloc, + .free = options->free, + .palette = acolormap, + .palette_error = palette_error, + .use_dither_map = options->use_dither_map, + .gamma = gamma, + .min_posterization_output = options->min_posterization_output, + }; + *result_output = result; + return LIQ_OK; +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_write_remapped_image(liq_result *result, liq_image *input_image, void *buffer, size_t buffer_size) +{ + if (!CHECK_STRUCT_TYPE(result, liq_result)) { + return LIQ_INVALID_POINTER; + } + if (!CHECK_STRUCT_TYPE(input_image, liq_image)) { + return LIQ_INVALID_POINTER; + } + if (!CHECK_USER_POINTER(buffer)) { + return LIQ_INVALID_POINTER; + } + + const size_t required_size = (size_t)input_image->width * (size_t)input_image->height; + if (buffer_size < required_size) { + return LIQ_BUFFER_TOO_SMALL; + } + + LIQ_ARRAY(unsigned char *, rows, input_image->height); + unsigned char *buffer_bytes = buffer; + for(unsigned int i=0; i < input_image->height; i++) { + rows[i] = &buffer_bytes[input_image->width * i]; + } + return liq_write_remapped_image_rows(result, input_image, rows); +} + +LIQ_EXPORT LIQ_NONNULL liq_error liq_write_remapped_image_rows(liq_result *quant, liq_image *input_image, unsigned char **row_pointers) +{ + if (!CHECK_STRUCT_TYPE(quant, liq_result)) return LIQ_INVALID_POINTER; + if (!CHECK_STRUCT_TYPE(input_image, liq_image)) return LIQ_INVALID_POINTER; + for(unsigned int i=0; i < input_image->height; i++) { + if (!CHECK_USER_POINTER(row_pointers+i) || !CHECK_USER_POINTER(row_pointers[i])) return LIQ_INVALID_POINTER; + } + + if (quant->remapping) { + liq_remapping_result_destroy(quant->remapping); + } + liq_remapping_result *const result = quant->remapping = liq_remapping_result_create(quant); + if (!result) return LIQ_OUT_OF_MEMORY; + + if (!input_image->edges && !input_image->dither_map && quant->use_dither_map) { + contrast_maps(input_image); + } + + if (liq_remap_progress(result, result->progress_stage1 * 0.25f)) { + return LIQ_ABORTED; + } + + /* + ** Step 4: map the colors in the image to their closest match in the + ** new colormap, and write 'em out. + */ + + float remapping_error = result->palette_error; + if (result->dither_level == 0) { + set_rounded_palette(&result->int_palette, result->palette, result->gamma, quant->min_posterization_output); + remapping_error = remap_to_palette(input_image, row_pointers, result->palette); + } else { + const bool is_image_huge = (input_image->width * input_image->height) > 2000 * 2000; + const bool allow_dither_map = result->use_dither_map == 2 || (!is_image_huge && result->use_dither_map); + const bool generate_dither_map = allow_dither_map && (input_image->edges && !input_image->dither_map); + if (generate_dither_map) { + // If dithering (with dither map) is required, this image is used to find areas that require dithering + remapping_error = remap_to_palette(input_image, row_pointers, result->palette); + update_dither_map(input_image, row_pointers, result->palette); + } + + if (liq_remap_progress(result, result->progress_stage1 * 0.5f)) { + return LIQ_ABORTED; + } + + // remapping above was the last chance to do K-Means iteration, hence the final palette is set after remapping + set_rounded_palette(&result->int_palette, result->palette, result->gamma, quant->min_posterization_output); + + if (!remap_to_palette_floyd(input_image, row_pointers, result, MAX(remapping_error*2.4, 16.f/256.f), generate_dither_map)) { + return LIQ_ABORTED; + } + } + + // remapping error from dithered image is absurd, so always non-dithered value is used + // palette_error includes some perceptual weighting from histogram which is closer correlated with dssim + // so that should be used when possible. + if (result->palette_error < 0) { + result->palette_error = remapping_error; + } + + return LIQ_OK; +} + +LIQ_EXPORT int liq_version() { + return LIQ_VERSION; +} diff --git a/src/platform/gba/packer/libimagequant/libimagequant.h b/src/platform/gba/packer/libimagequant/libimagequant.h new file mode 100644 index 0000000..e227b0a --- /dev/null +++ b/src/platform/gba/packer/libimagequant/libimagequant.h @@ -0,0 +1,151 @@ +/* + * https://pngquant.org + */ + +#ifndef LIBIMAGEQUANT_H +#define LIBIMAGEQUANT_H + +#ifdef IMAGEQUANT_EXPORTS +#define LIQ_EXPORT __declspec(dllexport) +#endif + +#ifndef LIQ_EXPORT +#define LIQ_EXPORT extern +#endif + +#define LIQ_VERSION 21300 +#define LIQ_VERSION_STRING "2.13.0" + +#ifndef LIQ_PRIVATE +#if defined(__GNUC__) || defined (__llvm__) +#define LIQ_PRIVATE __attribute__((visibility("hidden"))) +#define LIQ_NONNULL __attribute__((nonnull)) +#define LIQ_USERESULT __attribute__((warn_unused_result)) +#else +#define LIQ_PRIVATE +#define LIQ_NONNULL +#define LIQ_USERESULT +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +typedef struct liq_attr liq_attr; +typedef struct liq_image liq_image; +typedef struct liq_result liq_result; +typedef struct liq_histogram liq_histogram; + +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_ABORTED, + LIQ_BITMAP_NOT_AVAILABLE, + LIQ_BUFFER_TOO_SMALL, + LIQ_INVALID_POINTER, + LIQ_UNSUPPORTED, +} liq_error; + +enum liq_ownership { + LIQ_OWN_ROWS=4, + LIQ_OWN_PIXELS=8, + LIQ_COPY_PIXELS=16, +}; + +typedef struct liq_histogram_entry { + liq_color color; + unsigned int count; +} liq_histogram_entry; + +LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_create(void); +LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_create_with_allocator(void* (*malloc)(size_t), void (*free)(void*)); +LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_copy(const liq_attr *orig) LIQ_NONNULL; +LIQ_EXPORT void liq_attr_destroy(liq_attr *attr) LIQ_NONNULL; + +LIQ_EXPORT LIQ_USERESULT liq_histogram* liq_histogram_create(const liq_attr* attr); +LIQ_EXPORT liq_error liq_histogram_add_image(liq_histogram *hist, const liq_attr *attr, liq_image* image) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_histogram_add_colors(liq_histogram *hist, const liq_attr *attr, const liq_histogram_entry entries[], int num_entries, double gamma) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_histogram_add_fixed_color(liq_histogram *hist, liq_color color, double gamma) LIQ_NONNULL; +LIQ_EXPORT void liq_histogram_destroy(liq_histogram *hist) LIQ_NONNULL; + +LIQ_EXPORT liq_error liq_set_max_colors(liq_attr* attr, int colors) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT int liq_get_max_colors(const liq_attr* attr) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_set_speed(liq_attr* attr, int speed) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT int liq_get_speed(const liq_attr* attr) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_set_min_opacity(liq_attr* attr, int min) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT int liq_get_min_opacity(const liq_attr* attr) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_set_min_posterization(liq_attr* attr, int bits) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT int liq_get_min_posterization(const liq_attr* attr) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_set_quality(liq_attr* attr, int minimum, int maximum) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT int liq_get_min_quality(const liq_attr* attr) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT int liq_get_max_quality(const liq_attr* attr) LIQ_NONNULL; +LIQ_EXPORT void liq_set_last_index_transparent(liq_attr* attr, int is_last) LIQ_NONNULL; + +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); + +typedef int liq_progress_callback_function(float progress_percent, void* user_info); +LIQ_EXPORT void liq_attr_set_progress_callback(liq_attr*, liq_progress_callback_function*, void* user_info); +LIQ_EXPORT void liq_result_set_progress_callback(liq_result*, liq_progress_callback_function*, void* user_info); + +// The rows and their data are not modified. The type of `rows` is non-const only due to a bug in C's typesystem design. +LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_rgba_rows(const liq_attr *attr, void *const rows[], int width, int height, double gamma) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_rgba(const liq_attr *attr, const void *bitmap, int width, int height, double gamma) LIQ_NONNULL; + +typedef void liq_image_get_rgba_row_callback(liq_color row_out[], int row, int width, void* user_info); +LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_custom(const 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_NONNULL; +LIQ_EXPORT liq_error liq_image_set_background(liq_image *img, liq_image *background_image) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_image_set_importance_map(liq_image *img, unsigned char buffer[], size_t buffer_size, enum liq_ownership memory_handling) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_image_add_fixed_color(liq_image *img, liq_color color) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT int liq_image_get_width(const liq_image *img) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT int liq_image_get_height(const liq_image *img) LIQ_NONNULL; +LIQ_EXPORT void liq_image_destroy(liq_image *img) LIQ_NONNULL; + +LIQ_EXPORT LIQ_USERESULT liq_error liq_histogram_quantize(liq_histogram *const input_hist, liq_attr *const options, liq_result **result_output) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT liq_error liq_image_quantize(liq_image *const input_image, liq_attr *const options, liq_result **result_output) LIQ_NONNULL; + +LIQ_EXPORT liq_error liq_set_dithering_level(liq_result *res, float dither_level) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_set_output_gamma(liq_result* res, double gamma) LIQ_NONNULL; +LIQ_EXPORT LIQ_USERESULT double liq_get_output_gamma(const liq_result *result) LIQ_NONNULL; + +LIQ_EXPORT LIQ_USERESULT const liq_palette *liq_get_palette(liq_result *result) LIQ_NONNULL; + +LIQ_EXPORT liq_error liq_write_remapped_image(liq_result *result, liq_image *input_image, void *buffer, size_t buffer_size) LIQ_NONNULL; +LIQ_EXPORT liq_error liq_write_remapped_image_rows(liq_result *result, liq_image *input_image, unsigned char **row_pointers) LIQ_NONNULL; + +LIQ_EXPORT double liq_get_quantization_error(const liq_result *result) LIQ_NONNULL; +LIQ_EXPORT int liq_get_quantization_quality(const liq_result *result) LIQ_NONNULL; +LIQ_EXPORT double liq_get_remapping_error(const liq_result *result) LIQ_NONNULL; +LIQ_EXPORT int liq_get_remapping_quality(const liq_result *result) LIQ_NONNULL; + +LIQ_EXPORT void liq_result_destroy(liq_result *) LIQ_NONNULL; + +LIQ_EXPORT int liq_version(void); + + +// Deprecated +LIQ_EXPORT LIQ_USERESULT liq_result *liq_quantize_image(liq_attr *options, liq_image *input_image) LIQ_NONNULL; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/platform/gba/packer/libimagequant/mediancut.c b/src/platform/gba/packer/libimagequant/mediancut.c new file mode 100644 index 0000000..2c6d1d8 --- /dev/null +++ b/src/platform/gba/packer/libimagequant/mediancut.c @@ -0,0 +1,464 @@ +/* +** © 2009-2018 by Kornel Lesiński. +** © 1989, 1991 by Jef Poskanzer. +** © 1997, 2000, 2002 by Greg Roelofs; based on an idea by Stefan Schneider. +** +** See COPYRIGHT file for license. +*/ + +#include +#include + +#include "libimagequant.h" +#include "pam.h" +#include "mediancut.h" + +#define index_of_channel(ch) (offsetof(f_pixel,ch)/sizeof(float)) + +static f_pixel averagepixels(unsigned int clrs, const hist_item achv[]); + +struct box { + f_pixel color; + f_pixel variance; + double sum, total_error, max_error; + unsigned int ind; + unsigned int colors; +}; + +ALWAYS_INLINE static double variance_diff(double val, const double good_enough); +inline static double variance_diff(double val, const double good_enough) +{ + val *= val; + if (val < good_enough*good_enough) return val*0.25; + return val; +} + +/** Weighted per-channel variance of the box. It's used to decide which channel to split by */ +static f_pixel box_variance(const hist_item achv[], const struct box *box) +{ + f_pixel mean = box->color; + double variancea=0, variancer=0, varianceg=0, varianceb=0; + + for(unsigned int i = 0; i < box->colors; ++i) { + const f_pixel px = achv[box->ind + i].acolor; + double weight = achv[box->ind + i].adjusted_weight; + variancea += variance_diff(mean.a - px.a, 2.0/256.0)*weight; + variancer += variance_diff(mean.r - px.r, 1.0/256.0)*weight; + varianceg += variance_diff(mean.g - px.g, 1.0/256.0)*weight; + varianceb += variance_diff(mean.b - px.b, 1.0/256.0)*weight; + } + + return (f_pixel){ + .a = variancea*(4.0/16.0), + .r = variancer*(7.0/16.0), + .g = varianceg*(9.0/16.0), + .b = varianceb*(5.0/16.0), + }; +} + +static double box_max_error(const hist_item achv[], const struct box *box) +{ + f_pixel mean = box->color; + double max_error = 0; + + for(unsigned int i = 0; i < box->colors; ++i) { + const double diff = colordifference(mean, achv[box->ind + i].acolor); + if (diff > max_error) { + max_error = diff; + } + } + return max_error; +} + +ALWAYS_INLINE static double color_weight(f_pixel median, hist_item h); + +static inline void hist_item_swap(hist_item *l, hist_item *r) +{ + if (l != r) { + hist_item t = *l; + *l = *r; + *r = t; + } +} + +ALWAYS_INLINE static unsigned int qsort_pivot(const hist_item *const base, const unsigned int len); +inline static unsigned int qsort_pivot(const hist_item *const base, const unsigned int len) +{ + if (len < 32) { + return len/2; + } + + const unsigned int aidx=8, bidx=len/2, cidx=len-1; + const unsigned int a=base[aidx].tmp.sort_value, b=base[bidx].tmp.sort_value, c=base[cidx].tmp.sort_value; + return (a < b) ? ((b < c) ? bidx : ((a < c) ? cidx : aidx )) + : ((b > c) ? bidx : ((a < c) ? aidx : cidx )); +} + +ALWAYS_INLINE static unsigned int qsort_partition(hist_item *const base, const unsigned int len); +inline static unsigned int qsort_partition(hist_item *const base, const unsigned int len) +{ + unsigned int l = 1, r = len; + if (len >= 8) { + hist_item_swap(&base[0], &base[qsort_pivot(base,len)]); + } + + const unsigned int pivot_value = base[0].tmp.sort_value; + while (l < r) { + if (base[l].tmp.sort_value >= pivot_value) { + l++; + } else { + while(l < --r && base[r].tmp.sort_value <= pivot_value) {} + hist_item_swap(&base[l], &base[r]); + } + } + l--; + hist_item_swap(&base[0], &base[l]); + + return l; +} + +/** quick select algorithm */ +static void hist_item_sort_range(hist_item base[], unsigned int len, unsigned int sort_start) +{ + for(;;) { + const unsigned int l = qsort_partition(base, len), r = l+1; + + if (l > 0 && sort_start < l) { + len = l; + } + else if (r < len && sort_start > r) { + base += r; len -= r; sort_start -= r; + } + else break; + } +} + +/** sorts array to make sum of weights lower than halfvar one side, returns edge between halfvar parts of the set */ +static hist_item *hist_item_sort_halfvar(hist_item base[], unsigned int len, double *const lowervar, const double halfvar) +{ + do { + const unsigned int l = qsort_partition(base, len), r = l+1; + + // check if sum of left side is smaller than half, + // if it is, then it doesn't need to be sorted + unsigned int t = 0; double tmpsum = *lowervar; + while (t <= l && tmpsum < halfvar) tmpsum += base[t++].color_weight; + + if (tmpsum < halfvar) { + *lowervar = tmpsum; + } else { + if (l > 0) { + hist_item *res = hist_item_sort_halfvar(base, l, lowervar, halfvar); + if (res) return res; + } else { + // End of left recursion. This will be executed in order from the first element. + *lowervar += base[0].color_weight; + if (*lowervar > halfvar) return &base[0]; + } + } + + if (len > r) { + base += r; len -= r; // tail-recursive "call" + } else { + *lowervar += base[r].color_weight; + return (*lowervar > halfvar) ? &base[r] : NULL; + } + } while(1); +} + +static f_pixel get_median(const struct box *b, hist_item achv[]); + +typedef struct { + unsigned int chan; float variance; +} channelvariance; + +static int comparevariance(const void *ch1, const void *ch2) +{ + return ((const channelvariance*)ch1)->variance > ((const channelvariance*)ch2)->variance ? -1 : + (((const channelvariance*)ch1)->variance < ((const channelvariance*)ch2)->variance ? 1 : 0); +} + +/** Finds which channels need to be sorted first and preproceses achv for fast sort */ +static double prepare_sort(struct box *b, hist_item achv[]) +{ + /* + ** Sort dimensions by their variance, and then sort colors first by dimension with highest variance + */ + channelvariance channels[4] = { + {index_of_channel(a), b->variance.a}, + {index_of_channel(r), b->variance.r}, + {index_of_channel(g), b->variance.g}, + {index_of_channel(b), b->variance.b}, + }; + + qsort(channels, 4, sizeof(channels[0]), comparevariance); + + const unsigned int ind1 = b->ind; + const unsigned int colors = b->colors; +#if __GNUC__ >= 9 || __clang__ + #pragma omp parallel for if (colors > 25000) \ + schedule(static) default(none) shared(achv, channels, colors, ind1) +#else + #pragma omp parallel for if (colors > 25000) \ + schedule(static) default(none) shared(achv, channels) +#endif + for(unsigned int i=0; i < colors; i++) { + const float *chans = (const float *)&achv[ind1 + i].acolor; + // Only the first channel really matters. When trying median cut many times + // with different histogram weights, I don't want sort randomness to influence outcome. + achv[ind1 + i].tmp.sort_value = ((unsigned int)(chans[channels[0].chan]*65535.0)<<16) | + (unsigned int)((chans[channels[2].chan] + chans[channels[1].chan]/2.0 + chans[channels[3].chan]/4.0)*65535.0); + } + + const f_pixel median = get_median(b, achv); + + // box will be split to make color_weight of each side even + const unsigned int ind = b->ind, end = ind+b->colors; + double totalvar = 0; + #pragma omp parallel for if (end - ind > 15000) \ + schedule(static) default(shared) reduction(+:totalvar) + for(unsigned int j=ind; j < end; j++) totalvar += (achv[j].color_weight = color_weight(median, achv[j])); + return totalvar / 2.0; +} + +/** finds median in unsorted set by sorting only minimum required */ +static f_pixel get_median(const struct box *b, hist_item achv[]) +{ + const unsigned int median_start = (b->colors-1)/2; + + hist_item_sort_range(&(achv[b->ind]), b->colors, + median_start); + + if (b->colors&1) return achv[b->ind + median_start].acolor; + + // technically the second color is not guaranteed to be sorted correctly + // but most of the time it is good enough to be useful + return averagepixels(2, &achv[b->ind + median_start]); +} + +/* + ** Find the best splittable box. -1 if no boxes are splittable. + */ +static int best_splittable_box(struct box bv[], unsigned int boxes, const double max_mse) +{ + int bi=-1; double maxsum=0; + for(unsigned int i=0; i < boxes; i++) { + if (bv[i].colors < 2) { + continue; + } + + // looks only at max variance, because it's only going to split by it + const double cv = MAX(bv[i].variance.r, MAX(bv[i].variance.g,bv[i].variance.b)); + double thissum = bv[i].sum * MAX(bv[i].variance.a, cv); + + if (bv[i].max_error > max_mse) { + thissum = thissum* bv[i].max_error/max_mse; + } + + if (thissum > maxsum) { + maxsum = thissum; + bi = i; + } + } + return bi; +} + +inline static double color_weight(f_pixel median, hist_item h) +{ + float diff = colordifference(median, h.acolor); + return sqrt(diff) * (sqrt(1.0+h.adjusted_weight)-1.0); +} + +static void set_colormap_from_boxes(colormap *map, struct box bv[], unsigned int boxes, hist_item *achv); +static void adjust_histogram(hist_item *achv, const struct box bv[], unsigned int boxes); + +static double box_error(const struct box *box, const hist_item achv[]) +{ + f_pixel avg = box->color; + + double total_error=0; + for (unsigned int i = 0; i < box->colors; ++i) { + total_error += colordifference(avg, achv[box->ind + i].acolor) * achv[box->ind + i].perceptual_weight; + } + + return total_error; +} + + +static bool total_box_error_below_target(double target_mse, struct box bv[], unsigned int boxes, const histogram *hist) +{ + target_mse *= hist->total_perceptual_weight; + double total_error=0; + + for(unsigned int i=0; i < boxes; i++) { + // error is (re)calculated lazily + if (bv[i].total_error >= 0) { + total_error += bv[i].total_error; + } + if (total_error > target_mse) return false; + } + + for(unsigned int i=0; i < boxes; i++) { + if (bv[i].total_error < 0) { + bv[i].total_error = box_error(&bv[i], hist->achv); + total_error += bv[i].total_error; + } + if (total_error > target_mse) return false; + } + + return true; +} + +static void box_init(struct box *box, const hist_item *achv, const unsigned int ind, const unsigned int colors, const double sum) { + box->ind = ind; + box->colors = colors; + box->sum = sum; + box->total_error = -1; + + box->color = averagepixels(colors, &achv[ind]); + box->variance = box_variance(achv, box); + box->max_error = box_max_error(achv, box); +} + +/* + ** Here is the fun part, the median-cut colormap generator. This is based + ** on Paul Heckbert's paper, "Color Image Quantization for Frame Buffer + ** Display," SIGGRAPH 1982 Proceedings, page 297. + */ +LIQ_PRIVATE colormap *mediancut(histogram *hist, unsigned int newcolors, const double target_mse, const double max_mse, void* (*malloc)(size_t), void (*free)(void*)) +{ + hist_item *achv = hist->achv; + LIQ_ARRAY(struct box, bv, newcolors); + unsigned int boxes = 1; + + /* + ** Set up the initial box. + */ + { + double sum = 0; + for(unsigned int i=0; i < hist->size; i++) { + sum += achv[i].adjusted_weight; + } + box_init(&bv[0], achv, 0, hist->size, sum); + + + /* + ** Main loop: split boxes until we have enough. + */ + while (boxes < newcolors) { + + // first splits boxes that exceed quality limit (to have colors for things like odd green pixel), + // later raises the limit to allow large smooth areas/gradients get colors. + const double current_max_mse = max_mse + (boxes/(double)newcolors)*16.0*max_mse; + const int bi = best_splittable_box(bv, boxes, current_max_mse); + if (bi < 0) { + break; /* ran out of colors! */ + } + + unsigned int indx = bv[bi].ind; + unsigned int clrs = bv[bi].colors; + + /* + Classic implementation tries to get even number of colors or pixels in each subdivision. + + Here, instead of popularity I use (sqrt(popularity)*variance) metric. + Each subdivision balances number of pixels (popular colors) and low variance - + boxes can be large if they have similar colors. Later boxes with high variance + will be more likely to be split. + + Median used as expected value gives much better results than mean. + */ + + const double halfvar = prepare_sort(&bv[bi], achv); + double lowervar=0; + + // hist_item_sort_halfvar sorts and sums lowervar at the same time + // returns item to break at …minus one, which does smell like an off-by-one error. + hist_item *break_p = hist_item_sort_halfvar(&achv[indx], clrs, &lowervar, halfvar); + unsigned int break_at = MIN(clrs-1, break_p - &achv[indx] + 1); + + /* + ** Split the box. + */ + double sm = bv[bi].sum; + double lowersum = 0; + for(unsigned int i=0; i < break_at; i++) lowersum += achv[indx + i].adjusted_weight; + + box_init(&bv[bi], achv, indx, break_at, lowersum); + box_init(&bv[boxes], achv, indx + break_at, clrs - break_at, sm - lowersum); + + ++boxes; + + if (total_box_error_below_target(target_mse, bv, boxes, hist)) { + break; + } + } + } + + colormap *map = pam_colormap(boxes, malloc, free); + set_colormap_from_boxes(map, bv, boxes, achv); + + adjust_histogram(achv, bv, boxes); + + return map; +} + +static void set_colormap_from_boxes(colormap *map, struct box* bv, unsigned int boxes, hist_item *achv) +{ + /* + ** Ok, we've got enough boxes. Now choose a representative color for + ** each box. There are a number of possible ways to make this choice. + ** One would be to choose the center of the box; this ignores any structure + ** within the boxes. Another method would be to average all the colors in + ** the box - this is the method specified in Heckbert's paper. + */ + + for(unsigned int bi = 0; bi < boxes; ++bi) { + map->palette[bi].acolor = bv[bi].color; + + /* store total color popularity (perceptual_weight is approximation of it) */ + map->palette[bi].popularity = 0; + for(unsigned int i=bv[bi].ind; i < bv[bi].ind+bv[bi].colors; i++) { + map->palette[bi].popularity += achv[i].perceptual_weight; + } + } +} + +/* increase histogram popularity by difference from the final color (this is used as part of feedback loop) */ +static void adjust_histogram(hist_item *achv, const struct box* bv, unsigned int boxes) +{ + for(unsigned int bi = 0; bi < boxes; ++bi) { + for(unsigned int i=bv[bi].ind; i < bv[bi].ind+bv[bi].colors; i++) { + achv[i].tmp.likely_colormap_index = bi; + } + } +} + +static f_pixel averagepixels(unsigned int clrs, const hist_item achv[]) +{ + double r = 0, g = 0, b = 0, a = 0, sum = 0; + + #pragma omp parallel for if (clrs > 25000) \ + schedule(static) default(shared) reduction(+:a) reduction(+:r) reduction(+:g) reduction(+:b) reduction(+:sum) + for(unsigned int i = 0; i < clrs; i++) { + const f_pixel px = achv[i].acolor; + const double weight = achv[i].adjusted_weight; + + sum += weight; + a += px.a * weight; + r += px.r * weight; + g += px.g * weight; + b += px.b * weight; + } + + if (sum) { + a /= sum; + r /= sum; + g /= sum; + b /= sum; + } + + assert(!isnan(r) && !isnan(g) && !isnan(b) && !isnan(a)); + + return (f_pixel){.r=r, .g=g, .b=b, .a=a}; +} diff --git a/src/platform/gba/packer/libimagequant/mediancut.h b/src/platform/gba/packer/libimagequant/mediancut.h new file mode 100644 index 0000000..9a4cb53 --- /dev/null +++ b/src/platform/gba/packer/libimagequant/mediancut.h @@ -0,0 +1,6 @@ +#ifndef MEDIANCUT_H +#define MEDIANCUT_H + +LIQ_PRIVATE colormap *mediancut(histogram *hist, unsigned int newcolors, const double target_mse, const double max_mse, void* (*malloc)(size_t), void (*free)(void*)); + +#endif diff --git a/src/platform/gba/packer/libimagequant/mempool.c b/src/platform/gba/packer/libimagequant/mempool.c new file mode 100644 index 0000000..cd49f59 --- /dev/null +++ b/src/platform/gba/packer/libimagequant/mempool.c @@ -0,0 +1,70 @@ +/* +** © 2009-2017 by Kornel Lesiński. +** © 1989, 1991 by Jef Poskanzer. +** © 1997, 2000, 2002 by Greg Roelofs; based on an idea by Stefan Schneider. +** +** See COPYRIGHT file for license. +*/ + +#include "libimagequant.h" +#include "mempool.h" +#include +#include +#include + +#define ALIGN_MASK 15UL +#define MEMPOOL_RESERVED ((sizeof(struct mempool)+ALIGN_MASK) & ~ALIGN_MASK) + +struct mempool { + unsigned int used, size; + void* (*malloc)(size_t); + void (*free)(void*); + struct mempool *next; +}; +LIQ_PRIVATE void* mempool_create(mempoolptr *mptr, const unsigned int size, unsigned int max_size, void* (*malloc)(size_t), void (*free)(void*)) +{ + if (*mptr && ((*mptr)->used+size) <= (*mptr)->size) { + unsigned int prevused = (*mptr)->used; + (*mptr)->used += (size+15UL) & ~0xFUL; + return ((char*)(*mptr)) + prevused; + } + + mempoolptr old = *mptr; + if (!max_size) max_size = (1<<17); + max_size = size+ALIGN_MASK > max_size ? size+ALIGN_MASK : max_size; + + *mptr = malloc(MEMPOOL_RESERVED + max_size); + if (!*mptr) return NULL; + **mptr = (struct mempool){ + .malloc = malloc, + .free = free, + .size = MEMPOOL_RESERVED + max_size, + .used = sizeof(struct mempool), + .next = old, + }; + uintptr_t mptr_used_start = (uintptr_t)(*mptr) + (*mptr)->used; + (*mptr)->used += (ALIGN_MASK + 1 - (mptr_used_start & ALIGN_MASK)) & ALIGN_MASK; // reserve bytes required to make subsequent allocations aligned + assert(!(((uintptr_t)(*mptr) + (*mptr)->used) & ALIGN_MASK)); + + return mempool_alloc(mptr, size, size); +} + +LIQ_PRIVATE void* mempool_alloc(mempoolptr *mptr, const unsigned int size, const unsigned int max_size) +{ + if (((*mptr)->used+size) <= (*mptr)->size) { + unsigned int prevused = (*mptr)->used; + (*mptr)->used += (size + ALIGN_MASK) & ~ALIGN_MASK; + return ((char*)(*mptr)) + prevused; + } + + return mempool_create(mptr, size, max_size, (*mptr)->malloc, (*mptr)->free); +} + +LIQ_PRIVATE void mempool_destroy(mempoolptr m) +{ + while (m) { + mempoolptr next = m->next; + m->free(m); + m = next; + } +} diff --git a/src/platform/gba/packer/libimagequant/mempool.h b/src/platform/gba/packer/libimagequant/mempool.h new file mode 100644 index 0000000..9b7333b --- /dev/null +++ b/src/platform/gba/packer/libimagequant/mempool.h @@ -0,0 +1,13 @@ +#ifndef MEMPOOL_H +#define MEMPOOL_H + +#include + +struct mempool; +typedef struct mempool *mempoolptr; + +LIQ_PRIVATE void* mempool_create(mempoolptr *mptr, const unsigned int size, unsigned int capacity, void* (*malloc)(size_t), void (*free)(void*)); +LIQ_PRIVATE void* mempool_alloc(mempoolptr *mptr, const unsigned int size, const unsigned int capacity); +LIQ_PRIVATE void mempool_destroy(mempoolptr m); + +#endif diff --git a/src/platform/gba/packer/libimagequant/nearest.c b/src/platform/gba/packer/libimagequant/nearest.c new file mode 100644 index 0000000..cae477f --- /dev/null +++ b/src/platform/gba/packer/libimagequant/nearest.c @@ -0,0 +1,230 @@ +/* +** © 2009-2015 by Kornel Lesiński. +** © 1989, 1991 by Jef Poskanzer. +** © 1997, 2000, 2002 by Greg Roelofs; based on an idea by Stefan Schneider. +** +** See COPYRIGHT file for license. +*/ + +#include "libimagequant.h" +#include "pam.h" +#include "nearest.h" +#include "mempool.h" +#include + +typedef struct vp_sort_tmp { + float distance_squared; + unsigned int idx; +} vp_sort_tmp; + +typedef struct vp_search_tmp { + float distance; + float distance_squared; + unsigned int idx; + int exclude; +} vp_search_tmp; + +struct leaf { + f_pixel color; + unsigned int idx; +}; + +typedef struct vp_node { + struct vp_node *near, *far; + f_pixel vantage_point; + float radius, radius_squared; + struct leaf *rest; + unsigned short idx; + unsigned short restcount; +} vp_node; + +struct nearest_map { + vp_node *root; + const colormap_item *palette; + float nearest_other_color_dist[256]; + mempoolptr mempool; +}; + +static void vp_search_node(const vp_node *node, const f_pixel *const needle, vp_search_tmp *const best_candidate); + +static int vp_compare_distance(const void *ap, const void *bp) { + float a = ((const vp_sort_tmp*)ap)->distance_squared; + float b = ((const vp_sort_tmp*)bp)->distance_squared; + return a > b ? 1 : -1; +} + +static void vp_sort_indexes_by_distance(const f_pixel vantage_point, vp_sort_tmp indexes[], int num_indexes, const colormap_item items[]) { + for(int i=0; i < num_indexes; i++) { + indexes[i].distance_squared = colordifference(vantage_point, items[indexes[i].idx].acolor); + } + qsort(indexes, num_indexes, sizeof(indexes[0]), vp_compare_distance); +} + +/* + * Usually it should pick farthest point, but picking most popular point seems to make search quicker anyway + */ +static int vp_find_best_vantage_point_index(vp_sort_tmp indexes[], int num_indexes, const colormap_item items[]) { + int best = 0; + float best_popularity = items[indexes[0].idx].popularity; + for(int i = 1; i < num_indexes; i++) { + if (items[indexes[i].idx].popularity > best_popularity) { + best_popularity = items[indexes[i].idx].popularity; + best = i; + } + } + return best; +} + +static vp_node *vp_create_node(mempoolptr *m, vp_sort_tmp indexes[], int num_indexes, const colormap_item items[]) { + if (num_indexes <= 0) { + return NULL; + } + + vp_node *node = mempool_alloc(m, sizeof(node[0]), 0); + + if (num_indexes == 1) { + *node = (vp_node){ + .vantage_point = items[indexes[0].idx].acolor, + .idx = indexes[0].idx, + .radius = MAX_DIFF, + .radius_squared = MAX_DIFF, + }; + return node; + } + + const int ref = vp_find_best_vantage_point_index(indexes, num_indexes, items); + const int ref_idx = indexes[ref].idx; + + // Removes the `ref_idx` item from remaining items, because it's included in the current node + num_indexes -= 1; + indexes[ref] = indexes[num_indexes]; + + vp_sort_indexes_by_distance(items[ref_idx].acolor, indexes, num_indexes, items); + + // Remaining items are split by the median distance + const int half_idx = num_indexes/2; + + *node = (vp_node){ + .vantage_point = items[ref_idx].acolor, + .idx = ref_idx, + .radius = sqrtf(indexes[half_idx].distance_squared), + .radius_squared = indexes[half_idx].distance_squared, + }; + if (num_indexes < 7) { + node->rest = mempool_alloc(m, sizeof(node->rest[0]) * num_indexes, 0); + node->restcount = num_indexes; + for(int i=0; i < num_indexes; i++) { + node->rest[i].idx = indexes[i].idx; + node->rest[i].color = items[indexes[i].idx].acolor; + } + } else { + node->near = vp_create_node(m, indexes, half_idx, items); + node->far = vp_create_node(m, &indexes[half_idx], num_indexes - half_idx, items); + } + + return node; +} + +LIQ_PRIVATE struct nearest_map *nearest_init(const colormap *map) { + mempoolptr m = NULL; + struct nearest_map *handle = mempool_create(&m, sizeof(handle[0]), sizeof(handle[0]) + sizeof(vp_node)*map->colors+16, map->malloc, map->free); + + LIQ_ARRAY(vp_sort_tmp, indexes, map->colors); + + for(unsigned int i=0; i < map->colors; i++) { + indexes[i].idx = i; + } + + vp_node *root = vp_create_node(&m, indexes, map->colors, map->palette); + *handle = (struct nearest_map){ + .root = root, + .palette = map->palette, + .mempool = m, + }; + + for(unsigned int i=0; i < map->colors; i++) { + vp_search_tmp best = { + .distance = MAX_DIFF, + .distance_squared = MAX_DIFF, + .exclude = i, + }; + vp_search_node(root, &map->palette[i].acolor, &best); + handle->nearest_other_color_dist[i] = best.distance * best.distance / 4.0; // half of squared distance + } + + return handle; +} + +static void vp_search_node(const vp_node *node, const f_pixel *const needle, vp_search_tmp *const best_candidate) { + do { + const float distance_squared = colordifference(node->vantage_point, *needle); + const float distance = sqrtf(distance_squared); + + if (distance_squared < best_candidate->distance_squared && best_candidate->exclude != node->idx) { + best_candidate->distance = distance; + best_candidate->distance_squared = distance_squared; + best_candidate->idx = node->idx; + } + + if (node->restcount) { + for(int i=0; i < node->restcount; i++) { + const float distance_squared = colordifference(node->rest[i].color, *needle); + if (distance_squared < best_candidate->distance_squared && best_candidate->exclude != node->rest[i].idx) { + best_candidate->distance = sqrtf(distance_squared); + best_candidate->distance_squared = distance_squared; + best_candidate->idx = node->rest[i].idx; + } + } + return; + } + + // Recurse towards most likely candidate first to narrow best candidate's distance as soon as possible + if (distance_squared < node->radius_squared) { + if (node->near) { + vp_search_node(node->near, needle, best_candidate); + } + // The best node (final answer) may be just ouside the radius, but not farther than + // the best distance we know so far. The vp_search_node above should have narrowed + // best_candidate->distance, so this path is rarely taken. + if (node->far && distance >= node->radius - best_candidate->distance) { + node = node->far; // Fast tail recursion + } else { + return; + } + } else { + if (node->far) { + vp_search_node(node->far, needle, best_candidate); + } + if (node->near && distance <= node->radius + best_candidate->distance) { + node = node->near; // Fast tail recursion + } else { + return; + } + } + } while(true); +} + +LIQ_PRIVATE unsigned int nearest_search(const struct nearest_map *handle, const f_pixel *px, const int likely_colormap_index, float *diff) { + const float guess_diff = colordifference(handle->palette[likely_colormap_index].acolor, *px); + if (guess_diff < handle->nearest_other_color_dist[likely_colormap_index]) { + if (diff) *diff = guess_diff; + return likely_colormap_index; + } + + vp_search_tmp best_candidate = { + .distance = sqrtf(guess_diff), + .distance_squared = guess_diff, + .idx = likely_colormap_index, + .exclude = -1, + }; + vp_search_node(handle->root, px, &best_candidate); + if (diff) { + *diff = best_candidate.distance * best_candidate.distance; + } + return best_candidate.idx; +} + +LIQ_PRIVATE void nearest_free(struct nearest_map *centroids) +{ + mempool_destroy(centroids->mempool); +} diff --git a/src/platform/gba/packer/libimagequant/nearest.h b/src/platform/gba/packer/libimagequant/nearest.h new file mode 100644 index 0000000..10a0a2c --- /dev/null +++ b/src/platform/gba/packer/libimagequant/nearest.h @@ -0,0 +1,14 @@ +// +// nearest.h +// pngquant +// + +#ifndef NEAREST_H +#define NEAREST_H + +struct nearest_map; +LIQ_PRIVATE struct nearest_map *nearest_init(const colormap *palette); +LIQ_PRIVATE unsigned int nearest_search(const struct nearest_map *map, const f_pixel *px, const int palette_index_guess, float *diff); +LIQ_PRIVATE void nearest_free(struct nearest_map *map); + +#endif diff --git a/src/platform/gba/packer/libimagequant/pam.c b/src/platform/gba/packer/libimagequant/pam.c new file mode 100644 index 0000000..6e36222 --- /dev/null +++ b/src/platform/gba/packer/libimagequant/pam.c @@ -0,0 +1,289 @@ +/* pam.c - pam (portable alpha map) utility library +** +** © 2009-2017 by Kornel Lesiński. +** © 1989, 1991 by Jef Poskanzer. +** © 1997, 2000, 2002 by Greg Roelofs; based on an idea by Stefan Schneider. +** +** See COPYRIGHT file for license. +*/ + +#include +#include + +#include "libimagequant.h" +#include "pam.h" +#include "mempool.h" + +LIQ_PRIVATE bool pam_computeacolorhash(struct acolorhash_table *acht, const rgba_pixel *const pixels[], unsigned int cols, unsigned int rows, const unsigned char *importance_map) +{ + const unsigned int ignorebits = acht->ignorebits; + const unsigned int channel_mask = 255U>>ignorebits<>ignorebits) ^ 0xFFU; + const unsigned int posterize_mask = channel_mask << 24 | channel_mask << 16 | channel_mask << 8 | channel_mask; + const unsigned int posterize_high_mask = channel_hmask << 24 | channel_hmask << 16 | channel_hmask << 8 | channel_hmask; + + const unsigned int hash_size = acht->hash_size; + + /* Go through the entire image, building a hash table of colors. */ + for(unsigned int row = 0; row < rows; ++row) { + + for(unsigned int col = 0; col < cols; ++col) { + unsigned int boost; + + // RGBA color is casted to long for easier hasing/comparisons + union rgba_as_int px = {pixels[row][col]}; + unsigned int hash; + if (!px.rgba.a) { + // "dirty alpha" has different RGBA values that end up being the same fully transparent color + px.l=0; hash=0; + + boost = 2000; + if (importance_map) { + importance_map++; + } + } else { + // mask posterizes all 4 channels in one go + px.l = (px.l & posterize_mask) | ((px.l & posterize_high_mask) >> (8-ignorebits)); + // fancier hashing algorithms didn't improve much + hash = px.l % hash_size; + + if (importance_map) { + boost = *importance_map++; + } else { + boost = 255; + } + } + + if (!pam_add_to_hash(acht, hash, boost, px, row, rows)) { + return false; + } + } + + } + acht->cols = cols; + acht->rows += rows; + return true; +} + +LIQ_PRIVATE bool pam_add_to_hash(struct acolorhash_table *acht, unsigned int hash, unsigned int boost, union rgba_as_int px, unsigned int row, unsigned int rows) +{ + /* head of the hash function stores first 2 colors inline (achl->used = 1..2), + to reduce number of allocations of achl->other_items. + */ + struct acolorhist_arr_head *achl = &acht->buckets[hash]; + if (achl->inline1.color.l == px.l && achl->used) { + achl->inline1.perceptual_weight += boost; + return true; + } + if (achl->used) { + if (achl->used > 1) { + if (achl->inline2.color.l == px.l) { + achl->inline2.perceptual_weight += boost; + return true; + } + // other items are stored as an array (which gets reallocated if needed) + struct acolorhist_arr_item *other_items = achl->other_items; + unsigned int i = 0; + for (; i < achl->used-2; i++) { + if (other_items[i].color.l == px.l) { + other_items[i].perceptual_weight += boost; + return true; + } + } + + // the array was allocated with spare items + if (i < achl->capacity) { + other_items[i] = (struct acolorhist_arr_item){ + .color = px, + .perceptual_weight = boost, + }; + achl->used++; + ++acht->colors; + return true; + } + + if (++acht->colors > acht->maxcolors) { + return false; + } + + struct acolorhist_arr_item *new_items; + unsigned int capacity; + if (!other_items) { // there was no array previously, alloc "small" array + capacity = 8; + if (acht->freestackp <= 0) { + // estimate how many colors are going to be + headroom + const size_t mempool_size = ((acht->rows + rows-row) * 2 * acht->colors / (acht->rows + row + 1) + 1024) * sizeof(struct acolorhist_arr_item); + new_items = mempool_alloc(&acht->mempool, sizeof(struct acolorhist_arr_item)*capacity, mempool_size); + } else { + // freestack stores previously freed (reallocated) arrays that can be reused + // (all pesimistically assumed to be capacity = 8) + new_items = acht->freestack[--acht->freestackp]; + } + } else { + const unsigned int stacksize = sizeof(acht->freestack)/sizeof(acht->freestack[0]); + + // simply reallocs and copies array to larger capacity + capacity = achl->capacity*2 + 16; + if (acht->freestackp < stacksize-1) { + acht->freestack[acht->freestackp++] = other_items; + } + const size_t mempool_size = ((acht->rows + rows-row) * 2 * acht->colors / (acht->rows + row + 1) + 32*capacity) * sizeof(struct acolorhist_arr_item); + new_items = mempool_alloc(&acht->mempool, sizeof(struct acolorhist_arr_item)*capacity, mempool_size); + if (!new_items) return false; + memcpy(new_items, other_items, sizeof(other_items[0])*achl->capacity); + } + + achl->other_items = new_items; + achl->capacity = capacity; + new_items[i] = (struct acolorhist_arr_item){ + .color = px, + .perceptual_weight = boost, + }; + achl->used++; + } else { + // these are elses for first checks whether first and second inline-stored colors are used + achl->inline2.color.l = px.l; + achl->inline2.perceptual_weight = boost; + achl->used = 2; + ++acht->colors; + } + } else { + achl->inline1.color.l = px.l; + achl->inline1.perceptual_weight = boost; + achl->used = 1; + ++acht->colors; + } + return true; +} + +LIQ_PRIVATE struct acolorhash_table *pam_allocacolorhash(unsigned int maxcolors, unsigned int surface, unsigned int ignorebits, void* (*malloc)(size_t), void (*free)(void*)) +{ + const size_t estimated_colors = MIN(maxcolors, surface/(ignorebits + (surface > 512*512 ? 6 : 5))); + const size_t hash_size = estimated_colors < 66000 ? 6673 : (estimated_colors < 200000 ? 12011 : 24019); + + mempoolptr m = NULL; + const size_t buckets_size = hash_size * sizeof(struct acolorhist_arr_head); + const size_t mempool_size = sizeof(struct acolorhash_table) + buckets_size + estimated_colors * sizeof(struct acolorhist_arr_item); + struct acolorhash_table *t = mempool_create(&m, sizeof(*t) + buckets_size, mempool_size, malloc, free); + if (!t) return NULL; + *t = (struct acolorhash_table){ + .mempool = m, + .hash_size = hash_size, + .maxcolors = maxcolors, + .ignorebits = ignorebits, + }; + memset(t->buckets, 0, buckets_size); + return t; +} + +ALWAYS_INLINE static float pam_add_to_hist(const float *gamma_lut, hist_item *achv, unsigned int *j, const struct acolorhist_arr_item *entry, const float max_perceptual_weight) +{ + if (entry->perceptual_weight == 0) { + return 0; + } + const float w = MIN(entry->perceptual_weight/128.f, max_perceptual_weight); + achv[*j].adjusted_weight = achv[*j].perceptual_weight = w; + achv[*j].acolor = rgba_to_f(gamma_lut, entry->color.rgba); + *j += 1; + return w; +} + +LIQ_PRIVATE histogram *pam_acolorhashtoacolorhist(const struct acolorhash_table *acht, const double gamma, void* (*malloc)(size_t), void (*free)(void*)) +{ + histogram *hist = malloc(sizeof(hist[0])); + if (!hist || !acht) return NULL; + *hist = (histogram){ + .achv = malloc(MAX(1,acht->colors) * sizeof(hist->achv[0])), + .size = acht->colors, + .free = free, + .ignorebits = acht->ignorebits, + }; + if (!hist->achv) return NULL; + + float gamma_lut[256]; + to_f_set_gamma(gamma_lut, gamma); + + /* Limit perceptual weight to 1/10th of the image surface area to prevent + a single color from dominating all others. */ + float max_perceptual_weight = 0.1f * acht->cols * acht->rows; + double total_weight = 0; + + unsigned int j=0; + for(unsigned int i=0; i < acht->hash_size; ++i) { + const struct acolorhist_arr_head *const achl = &acht->buckets[i]; + if (achl->used) { + total_weight += pam_add_to_hist(gamma_lut, hist->achv, &j, &achl->inline1, max_perceptual_weight); + + if (achl->used > 1) { + total_weight += pam_add_to_hist(gamma_lut, hist->achv, &j, &achl->inline2, max_perceptual_weight); + + for(unsigned int k=0; k < achl->used-2; k++) { + total_weight += pam_add_to_hist(gamma_lut, hist->achv, &j, &achl->other_items[k], max_perceptual_weight); + } + } + } + } + hist->size = j; + hist->total_perceptual_weight = total_weight; + for(unsigned int k=0; k < hist->size; k++) { + hist->achv[k].tmp.likely_colormap_index = 0; + } + if (!j) { + pam_freeacolorhist(hist); + return NULL; + } + return hist; +} + + +LIQ_PRIVATE void pam_freeacolorhash(struct acolorhash_table *acht) +{ + if (acht) { + mempool_destroy(acht->mempool); + } +} + +LIQ_PRIVATE void pam_freeacolorhist(histogram *hist) +{ + hist->free(hist->achv); + hist->free(hist); +} + +LIQ_PRIVATE colormap *pam_colormap(unsigned int colors, void* (*malloc)(size_t), void (*free)(void*)) +{ + assert(colors > 0 && colors < 65536); + + colormap *map; + const size_t colors_size = colors * sizeof(map->palette[0]); + map = malloc(sizeof(colormap) + colors_size); + if (!map) return NULL; + *map = (colormap){ + .malloc = malloc, + .free = free, + .colors = colors, + }; + memset(map->palette, 0, colors_size); + return map; +} + +LIQ_PRIVATE colormap *pam_duplicate_colormap(colormap *map) +{ + colormap *dupe = pam_colormap(map->colors, map->malloc, map->free); + for(unsigned int i=0; i < map->colors; i++) { + dupe->palette[i] = map->palette[i]; + } + return dupe; +} + +LIQ_PRIVATE void pam_freecolormap(colormap *c) +{ + c->free(c); +} + +LIQ_PRIVATE void to_f_set_gamma(float gamma_lut[], const double gamma) +{ + for(int i=0; i < 256; i++) { + gamma_lut[i] = pow((double)i/255.0, internal_gamma/gamma); + } +} + diff --git a/src/platform/gba/packer/libimagequant/pam.h b/src/platform/gba/packer/libimagequant/pam.h new file mode 100644 index 0000000..5a7d50e --- /dev/null +++ b/src/platform/gba/packer/libimagequant/pam.h @@ -0,0 +1,283 @@ +/* pam.h - pam (portable alpha map) utility library + ** + ** Colormap routines. + ** + ** Copyright (C) 1989, 1991 by Jef Poskanzer. + ** Copyright (C) 1997 by Greg Roelofs. + ** + ** Permission to use, copy, modify, and distribute this software and its + ** documentation for any purpose and without fee is hereby granted, provided + ** that the above copyright notice appear in all copies and that both that + ** copyright notice and this permission notice appear in supporting + ** documentation. This software is provided "as is" without express or + ** implied warranty. + */ + +#ifndef PAM_H +#define PAM_H + +// accidental debug assertions make color search much slower, +// so force assertions off if there's no explicit setting +#if !defined(NDEBUG) && !defined(DEBUG) +#define NDEBUG +#endif + +#include +#include +#include +#include + +#ifndef MAX +# define MAX(a,b) ((a) > (b)? (a) : (b)) +# define MIN(a,b) ((a) < (b)? (a) : (b)) +#endif + +#define MAX_DIFF 1e20 + +#ifndef USE_SSE +# if defined(__SSE__) && (defined(__amd64__) || defined(__X86_64__) || defined(_WIN64) || defined(WIN32) || defined(__WIN32__)) +# define USE_SSE 1 +# else +# define USE_SSE 0 +# endif +#endif + +#if USE_SSE +# include +# ifdef _MSC_VER +# include +# define SSE_ALIGN +# else +# define SSE_ALIGN __attribute__ ((aligned (16))) +# if defined(__i386__) && defined(__PIC__) +# define cpuid(func,ax,bx,cx,dx)\ + __asm__ __volatile__ ( \ + "push %%ebx\n" \ + "cpuid\n" \ + "mov %%ebx, %1\n" \ + "pop %%ebx\n" \ + : "=a" (ax), "=r" (bx), "=c" (cx), "=d" (dx) \ + : "a" (func)); +# else +# define cpuid(func,ax,bx,cx,dx)\ + __asm__ __volatile__ ("cpuid":\ + "=a" (ax), "=b" (bx), "=c" (cx), "=d" (dx) : "a" (func)); +# endif +#endif +#else +# define SSE_ALIGN +#endif + +#ifndef _MSC_VER +#define LIQ_ARRAY(type, var, count) type var[count] +#else +#define LIQ_ARRAY(type, var, count) type* var = (type*)_alloca(sizeof(type)*(count)) +#endif + +#if defined(__GNUC__) || defined (__llvm__) +#define ALWAYS_INLINE __attribute__((always_inline)) inline +#define NEVER_INLINE __attribute__ ((noinline)) +#elif defined(_MSC_VER) +#define inline __inline +#define restrict __restrict +#define ALWAYS_INLINE __forceinline +#define NEVER_INLINE __declspec(noinline) +#else +#define ALWAYS_INLINE inline +#define NEVER_INLINE +#endif + +/* from pam.h */ + +typedef struct { + unsigned char r, g, b, a; +} rgba_pixel; + +typedef struct { + float a, r, g, b; +} SSE_ALIGN f_pixel; + +static const float internal_gamma = 0.5499f; + +LIQ_PRIVATE void to_f_set_gamma(float gamma_lut[], const double gamma); + +/** + Converts 8-bit color to internal gamma and premultiplied alpha. + (premultiplied color space is much better for blending of semitransparent colors) + */ +ALWAYS_INLINE static f_pixel rgba_to_f(const float gamma_lut[], const rgba_pixel px); +inline static f_pixel rgba_to_f(const float gamma_lut[], const rgba_pixel px) +{ + float a = px.a/255.f; + + return (f_pixel) { + .a = a, + .r = gamma_lut[px.r]*a, + .g = gamma_lut[px.g]*a, + .b = gamma_lut[px.b]*a, + }; +} + +inline static rgba_pixel f_to_rgb(const float gamma, const f_pixel px) +{ + if (px.a < 1.f/256.f) { + return (rgba_pixel){0,0,0,0}; + } + + float r = px.r / px.a, + g = px.g / px.a, + b = px.b / px.a, + a = px.a; + + r = powf(r, gamma/internal_gamma); + g = powf(g, gamma/internal_gamma); + b = powf(b, gamma/internal_gamma); + + // 256, because numbers are in range 1..255.9999… rounded down + r *= 256.f; + g *= 256.f; + b *= 256.f; + a *= 256.f; + + return (rgba_pixel){ + .r = r>=255.f ? 255 : r, + .g = g>=255.f ? 255 : g, + .b = b>=255.f ? 255 : b, + .a = a>=255.f ? 255 : a, + }; +} + +ALWAYS_INLINE static double colordifference_ch(const double x, const double y, const double alphas); +inline static double colordifference_ch(const double x, const double y, const double alphas) +{ + // maximum of channel blended on white, and blended on black + // premultiplied alpha and backgrounds 0/1 shorten the formula + const double black = x-y, white = black+alphas; + return MAX(black*black, white*white); +} + +ALWAYS_INLINE static float colordifference_stdc(const f_pixel px, const f_pixel py); +inline static float colordifference_stdc(const f_pixel px, const f_pixel py) +{ + // px_b.rgb = px.rgb + 0*(1-px.a) // blend px on black + // px_b.a = px.a + 1*(1-px.a) + // px_w.rgb = px.rgb + 1*(1-px.a) // blend px on white + // px_w.a = px.a + 1*(1-px.a) + + // px_b.rgb = px.rgb // difference same as in opaque RGB + // px_b.a = 1 + // px_w.rgb = px.rgb - px.a // difference simplifies to formula below + // px_w.a = 1 + + // (px.rgb - px.a) - (py.rgb - py.a) + // (px.rgb - py.rgb) + (py.a - px.a) + + const double alphas = py.a-px.a; + return colordifference_ch(px.r, py.r, alphas) + + colordifference_ch(px.g, py.g, alphas) + + colordifference_ch(px.b, py.b, alphas); +} + +ALWAYS_INLINE static float colordifference(f_pixel px, f_pixel py); +inline static float colordifference(f_pixel px, f_pixel py) +{ +#if USE_SSE + const __m128 vpx = _mm_load_ps((const float*)&px); + const __m128 vpy = _mm_load_ps((const float*)&py); + + // y.a - x.a + __m128 alphas = _mm_sub_ss(vpy, vpx); + alphas = _mm_shuffle_ps(alphas,alphas,0); // copy first to all four + + __m128 onblack = _mm_sub_ps(vpx, vpy); // x - y + __m128 onwhite = _mm_add_ps(onblack, alphas); // x - y + (y.a - x.a) + + onblack = _mm_mul_ps(onblack, onblack); + onwhite = _mm_mul_ps(onwhite, onwhite); + const __m128 max = _mm_max_ps(onwhite, onblack); + + // add rgb, not a + const __m128 maxhl = _mm_movehl_ps(max, max); + const __m128 tmp = _mm_add_ps(max, maxhl); + const __m128 sum = _mm_add_ss(maxhl, _mm_shuffle_ps(tmp, tmp, 1)); + + const float res = _mm_cvtss_f32(sum); + assert(fabs(res - colordifference_stdc(px,py)) < 0.001); + return res; +#else + return colordifference_stdc(px,py); +#endif +} + +/* from pamcmap.h */ +union rgba_as_int { + rgba_pixel rgba; + unsigned int l; +}; + +typedef struct { + f_pixel acolor; + float adjusted_weight, // perceptual weight changed to tweak how mediancut selects colors + perceptual_weight; // number of pixels weighted by importance of different areas of the picture + + float color_weight; // these two change every time histogram subset is sorted + union { + unsigned int sort_value; + unsigned char likely_colormap_index; + } tmp; +} hist_item; + +typedef struct { + hist_item *achv; + void (*free)(void*); + double total_perceptual_weight; + unsigned int size; + unsigned int ignorebits; +} histogram; + +typedef struct { + f_pixel acolor; + float popularity; + bool fixed; // if true it's user-supplied and must not be changed (e.g in K-Means iteration) +} colormap_item; + +typedef struct colormap { + unsigned int colors; + void* (*malloc)(size_t); + void (*free)(void*); + colormap_item palette[]; +} colormap; + +struct acolorhist_arr_item { + union rgba_as_int color; + unsigned int perceptual_weight; +}; + +struct acolorhist_arr_head { + struct acolorhist_arr_item inline1, inline2; + unsigned int used, capacity; + struct acolorhist_arr_item *other_items; +}; + +struct acolorhash_table { + struct mempool *mempool; + unsigned int ignorebits, maxcolors, colors, cols, rows; + unsigned int hash_size; + unsigned int freestackp; + struct acolorhist_arr_item *freestack[512]; + struct acolorhist_arr_head buckets[]; +}; + +LIQ_PRIVATE void pam_freeacolorhash(struct acolorhash_table *acht); +LIQ_PRIVATE struct acolorhash_table *pam_allocacolorhash(unsigned int maxcolors, unsigned int surface, unsigned int ignorebits, void* (*malloc)(size_t), void (*free)(void*)); +LIQ_PRIVATE histogram *pam_acolorhashtoacolorhist(const struct acolorhash_table *acht, const double gamma, void* (*malloc)(size_t), void (*free)(void*)); +LIQ_PRIVATE bool pam_computeacolorhash(struct acolorhash_table *acht, const rgba_pixel *const pixels[], unsigned int cols, unsigned int rows, const unsigned char *importance_map); +LIQ_PRIVATE bool pam_add_to_hash(struct acolorhash_table *acht, unsigned int hash, unsigned int boost, union rgba_as_int px, unsigned int row, unsigned int rows); + +LIQ_PRIVATE void pam_freeacolorhist(histogram *h); + +LIQ_PRIVATE colormap *pam_colormap(unsigned int colors, void* (*malloc)(size_t), void (*free)(void*)); +LIQ_PRIVATE colormap *pam_duplicate_colormap(colormap *map); +LIQ_PRIVATE void pam_freecolormap(colormap *c); + +#endif diff --git a/src/platform/gba/packer/stb_image_resize.h b/src/platform/gba/packer/stb_image_resize.h new file mode 100644 index 0000000..bcca92c --- /dev/null +++ b/src/platform/gba/packer/stb_image_resize.h @@ -0,0 +1,2585 @@ +/* stb_image_resize - v0.90 - public domain image resizing + by Jorge L Rodriguez (@VinoBS) - 2014 + http://github.com/nothings/stb + + Written with emphasis on usability, portability, and efficiency. (No + SIMD or threads, so it be easily outperformed by libs that use those.) + Only scaling and translation is supported, no rotations or shears. + Easy API downsamples w/Mitchell filter, upsamples w/cubic interpolation. + + COMPILING & LINKING + In one C/C++ file that #includes this file, do this: + #define STB_IMAGE_RESIZE_IMPLEMENTATION + before the #include. That will create the implementation in that file. + + QUICKSTART + stbir_resize_uint8( input_pixels , in_w , in_h , 0, + output_pixels, out_w, out_h, 0, num_channels) + stbir_resize_float(...) + stbir_resize_uint8_srgb( input_pixels , in_w , in_h , 0, + output_pixels, out_w, out_h, 0, + num_channels , alpha_chan , 0) + stbir_resize_uint8_srgb_edgemode( + input_pixels , in_w , in_h , 0, + output_pixels, out_w, out_h, 0, + num_channels , alpha_chan , 0, STBIR_EDGE_CLAMP) + // WRAP/REFLECT/ZERO + + FULL API + See the "header file" section of the source for API documentation. + + ADDITIONAL DOCUMENTATION + + SRGB & FLOATING POINT REPRESENTATION + The sRGB functions presume IEEE floating point. If you do not have + IEEE floating point, define STBIR_NON_IEEE_FLOAT. This will use + a slower implementation. + + MEMORY ALLOCATION + The resize functions here perform a single memory allocation using + malloc. To control the memory allocation, before the #include that + triggers the implementation, do: + + #define STBIR_MALLOC(size,context) ... + #define STBIR_FREE(ptr,context) ... + + Each resize function makes exactly one call to malloc/free, so to use + temp memory, store the temp memory in the context and return that. + + ASSERT + Define STBIR_ASSERT(boolval) to override assert() and not use assert.h + + OPTIMIZATION + Define STBIR_SATURATE_INT to compute clamp values in-range using + integer operations instead of float operations. This may be faster + on some platforms. + + DEFAULT FILTERS + For functions which don't provide explicit control over what filters + to use, you can change the compile-time defaults with + + #define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_something + #define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_something + + See stbir_filter in the header-file section for the list of filters. + + NEW FILTERS + A number of 1D filter kernels are used. For a list of + supported filters see the stbir_filter enum. To add a new filter, + write a filter function and add it to stbir__filter_info_table. + + PROGRESS + For interactive use with slow resize operations, you can install + a progress-report callback: + + #define STBIR_PROGRESS_REPORT(val) some_func(val) + + The parameter val is a float which goes from 0 to 1 as progress is made. + + For example: + + static void my_progress_report(float progress); + #define STBIR_PROGRESS_REPORT(val) my_progress_report(val) + + #define STB_IMAGE_RESIZE_IMPLEMENTATION + #include "stb_image_resize.h" + + static void my_progress_report(float progress) + { + printf("Progress: %f%%\n", progress*100); + } + + MAX CHANNELS + If your image has more than 64 channels, define STBIR_MAX_CHANNELS + to the max you'll have. + + ALPHA CHANNEL + Most of the resizing functions provide the ability to control how + the alpha channel of an image is processed. The important things + to know about this: + + 1. The best mathematically-behaved version of alpha to use is + called "premultiplied alpha", in which the other color channels + have had the alpha value multiplied in. If you use premultiplied + alpha, linear filtering (such as image resampling done by this + library, or performed in texture units on GPUs) does the "right + thing". While premultiplied alpha is standard in the movie CGI + industry, it is still uncommon in the videogame/real-time world. + + If you linearly filter non-premultiplied alpha, strange effects + occur. (For example, the average of 1% opaque bright green + and 99% opaque black produces 50% transparent dark green when + non-premultiplied, whereas premultiplied it produces 50% + transparent near-black. The former introduces green energy + that doesn't exist in the source image.) + + 2. Artists should not edit premultiplied-alpha images; artists + want non-premultiplied alpha images. Thus, art tools generally output + non-premultiplied alpha images. + + 3. You will get best results in most cases by converting images + to premultiplied alpha before processing them mathematically. + + 4. If you pass the flag STBIR_FLAG_ALPHA_PREMULTIPLIED, the + resizer does not do anything special for the alpha channel; + it is resampled identically to other channels. This produces + the correct results for premultiplied-alpha images, but produces + less-than-ideal results for non-premultiplied-alpha images. + + 5. If you do not pass the flag STBIR_FLAG_ALPHA_PREMULTIPLIED, + then the resizer weights the contribution of input pixels + based on their alpha values, or, equivalently, it multiplies + the alpha value into the color channels, resamples, then divides + by the resultant alpha value. Input pixels which have alpha=0 do + not contribute at all to output pixels unless _all_ of the input + pixels affecting that output pixel have alpha=0, in which case + the result for that pixel is the same as it would be without + STBIR_FLAG_ALPHA_PREMULTIPLIED. However, this is only true for + input images in integer formats. For input images in float format, + input pixels with alpha=0 have no effect, and output pixels + which have alpha=0 will be 0 in all channels. (For float images, + you can manually achieve the same result by adding a tiny epsilon + value to the alpha channel of every image, and then subtracting + or clamping it at the end.) + + 6. You can suppress the behavior described in #5 and make + all-0-alpha pixels have 0 in all channels by #defining + STBIR_NO_ALPHA_EPSILON. + + 7. You can separately control whether the alpha channel is + interpreted as linear or affected by the colorspace. By default + it is linear; you almost never want to apply the colorspace. + (For example, graphics hardware does not apply sRGB conversion + to the alpha channel.) + + ADDITIONAL CONTRIBUTORS + Sean Barrett: API design, optimizations + + REVISIONS + 0.90 (2014-09-17) first released version + + LICENSE + This software is in the public domain. Where that dedication is not + recognized, you are granted a perpetual, irrevocable license to copy + and modify this file as you see fit. + + TODO + Don't decode all of the image data when only processing a partial tile + Don't use full-width decode buffers when only processing a partial tile + When processing wide images, break processing into tiles so data fits in L1 cache + Installable filters? + Resize that respects alpha test coverage + (Reference code: FloatImage::alphaTestCoverage and FloatImage::scaleAlphaToCoverage: + https://code.google.com/p/nvidia-texture-tools/source/browse/trunk/src/nvimage/FloatImage.cpp ) +*/ + +#ifndef STBIR_INCLUDE_STB_IMAGE_RESIZE_H +#define STBIR_INCLUDE_STB_IMAGE_RESIZE_H + +#ifdef _MSC_VER +typedef unsigned char stbir_uint8; +typedef unsigned short stbir_uint16; +typedef unsigned int stbir_uint32; +#else +#include +typedef uint8_t stbir_uint8; +typedef uint16_t stbir_uint16; +typedef uint32_t stbir_uint32; +#endif + +#ifdef STB_IMAGE_RESIZE_STATIC +#define STBIRDEF static +#else +#ifdef __cplusplus +#define STBIRDEF extern "C" +#else +#define STBIRDEF extern +#endif +#endif + + +////////////////////////////////////////////////////////////////////////////// +// +// Easy-to-use API: +// +// * "input pixels" points to an array of image data with 'num_channels' channels (e.g. RGB=3, RGBA=4) +// * input_w is input image width (x-axis), input_h is input image height (y-axis) +// * stride is the offset between successive rows of image data in memory, in bytes. you can +// specify 0 to mean packed continuously in memory +// * alpha channel is treated identically to other channels. +// * colorspace is linear or sRGB as specified by function name +// * returned result is 1 for success or 0 in case of an error. +// #define STBIR_ASSERT() to trigger an assert on parameter validation errors. +// * Memory required grows approximately linearly with input and output size, but with +// discontinuities at input_w == output_w and input_h == output_h. +// * These functions use a "default" resampling filter defined at compile time. To change the filter, +// you can change the compile-time defaults by #defining STBIR_DEFAULT_FILTER_UPSAMPLE +// and STBIR_DEFAULT_FILTER_DOWNSAMPLE, or you can use the medium-complexity API. + +STBIRDEF int stbir_resize_uint8( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels); + +STBIRDEF int stbir_resize_float( const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + float *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels); + + +// The following functions interpret image data as gamma-corrected sRGB. +// Specify STBIR_ALPHA_CHANNEL_NONE if you have no alpha channel, +// or otherwise provide the index of the alpha channel. Flags value +// of 0 will probably do the right thing if you're not sure what +// the flags mean. + +#define STBIR_ALPHA_CHANNEL_NONE -1 + +// Set this flag if your texture has premultiplied alpha. Otherwise, stbir will +// use alpha-weighted resampling (effectively premultiplying, resampling, +// then unpremultiplying). +#define STBIR_FLAG_ALPHA_PREMULTIPLIED (1 << 0) +// The specified alpha channel should be handled as gamma-corrected value even +// when doing sRGB operations. +#define STBIR_FLAG_ALPHA_USES_COLORSPACE (1 << 1) + +STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags); + + +typedef enum +{ + STBIR_EDGE_CLAMP = 1, + STBIR_EDGE_REFLECT = 2, + STBIR_EDGE_WRAP = 3, + STBIR_EDGE_ZERO = 4, +} stbir_edge; + +// This function adds the ability to specify how requests to sample off the edge of the image are handled. +STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_wrap_mode); + +////////////////////////////////////////////////////////////////////////////// +// +// Medium-complexity API +// +// This extends the easy-to-use API as follows: +// +// * Alpha-channel can be processed separately +// * If alpha_channel is not STBIR_ALPHA_CHANNEL_NONE +// * Alpha channel will not be gamma corrected (unless flags&STBIR_FLAG_GAMMA_CORRECT) +// * Filters will be weighted by alpha channel (unless flags&STBIR_FLAG_ALPHA_PREMULTIPLIED) +// * Filter can be selected explicitly +// * uint16 image type +// * sRGB colorspace available for all types +// * context parameter for passing to STBIR_MALLOC + +typedef enum +{ + STBIR_FILTER_DEFAULT = 0, // use same filter type that easy-to-use API chooses + STBIR_FILTER_BOX = 1, // A trapezoid w/1-pixel wide ramps, same result as box for integer scale ratios + STBIR_FILTER_TRIANGLE = 2, // On upsampling, produces same results as bilinear texture filtering + STBIR_FILTER_CUBICBSPLINE = 3, // The cubic b-spline (aka Mitchell-Netrevalli with B=1,C=0), gaussian-esque + STBIR_FILTER_CATMULLROM = 4, // An interpolating cubic spline + STBIR_FILTER_MITCHELL = 5, // Mitchell-Netrevalli filter with B=1/3, C=1/3 +} stbir_filter; + +typedef enum +{ + STBIR_COLORSPACE_LINEAR, + STBIR_COLORSPACE_SRGB, + + STBIR_MAX_COLORSPACES, +} stbir_colorspace; + +// The following functions are all identical except for the type of the image data + +STBIRDEF int stbir_resize_uint8_generic( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, + void *alloc_context); + +STBIRDEF int stbir_resize_uint16_generic(const stbir_uint16 *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + stbir_uint16 *output_pixels , int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, + void *alloc_context); + +STBIRDEF int stbir_resize_float_generic( const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + float *output_pixels , int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, + void *alloc_context); + + + +////////////////////////////////////////////////////////////////////////////// +// +// Full-complexity API +// +// This extends the medium API as follows: +// +// * uint32 image type +// * not typesafe +// * separate filter types for each axis +// * separate edge modes for each axis +// * can specify scale explicitly for subpixel correctness +// * can specify image source tile using texture coordinates + +typedef enum +{ + STBIR_TYPE_UINT8 , + STBIR_TYPE_UINT16, + STBIR_TYPE_UINT32, + STBIR_TYPE_FLOAT , + + STBIR_MAX_TYPES +} stbir_datatype; + +STBIRDEF int stbir_resize( const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_datatype datatype, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, + stbir_filter filter_horizontal, stbir_filter filter_vertical, + stbir_colorspace space, void *alloc_context); + +STBIRDEF int stbir_resize_subpixel(const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_datatype datatype, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, + stbir_filter filter_horizontal, stbir_filter filter_vertical, + stbir_colorspace space, void *alloc_context, + float x_scale, float y_scale, + float x_offset, float y_offset); + +STBIRDEF int stbir_resize_region( const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_datatype datatype, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, + stbir_filter filter_horizontal, stbir_filter filter_vertical, + stbir_colorspace space, void *alloc_context, + float s0, float t0, float s1, float t1); +// (s0, t0) & (s1, t1) are the top-left and bottom right corner (uv addressing style: [0, 1]x[0, 1]) of a region of the input image to use. + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBIR_INCLUDE_STB_IMAGE_RESIZE_H + + + + + +#ifdef STB_IMAGE_RESIZE_IMPLEMENTATION + +#ifndef STBIR_ASSERT +#include +#define STBIR_ASSERT(x) assert(x) +#endif + +#ifdef STBIR_DEBUG +#define STBIR__DEBUG_ASSERT STBIR_ASSERT +#else +#define STBIR__DEBUG_ASSERT +#endif + +// If you hit this it means I haven't done it yet. +#define STBIR__UNIMPLEMENTED(x) STBIR_ASSERT(!(x)) + +// For memset +#include + +#include + +#ifndef STBIR_MALLOC +#include +#define STBIR_MALLOC(size,c) malloc(size) +#define STBIR_FREE(ptr,c) free(ptr) +#endif + +#ifndef _MSC_VER +#ifdef __cplusplus +#define stbir__inline inline +#else +#define stbir__inline +#endif +#else +#define stbir__inline __forceinline +#endif + + +// should produce compiler error if size is wrong +typedef unsigned char stbir__validate_uint32[sizeof(stbir_uint32) == 4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBIR__NOTUSED(v) (void)(v) +#else +#define STBIR__NOTUSED(v) (void)sizeof(v) +#endif + +#define STBIR__ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0])) + +#ifndef STBIR_DEFAULT_FILTER_UPSAMPLE +#define STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_CATMULLROM +#endif + +#ifndef STBIR_DEFAULT_FILTER_DOWNSAMPLE +#define STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_MITCHELL +#endif + +#ifndef STBIR_PROGRESS_REPORT +#define STBIR_PROGRESS_REPORT(float_0_to_1) +#endif + +#ifndef STBIR_MAX_CHANNELS +#define STBIR_MAX_CHANNELS 64 +#endif + +#if STBIR_MAX_CHANNELS > 65536 +#error "Too many channels; STBIR_MAX_CHANNELS must be no more than 65536." +// because we store the indices in 16-bit variables +#endif + +// This value is added to alpha just before premultiplication to avoid +// zeroing out color values. It is equivalent to 2^-80. If you don't want +// that behavior (it may interfere if you have floating point images with +// very small alpha values) then you can define STBIR_NO_ALPHA_EPSILON to +// disable it. +#ifndef STBIR_ALPHA_EPSILON +#define STBIR_ALPHA_EPSILON ((float)1 / (1 << 20) / (1 << 20) / (1 << 20) / (1 << 20)) +#endif + + + +#ifdef _MSC_VER +#define STBIR__UNUSED_PARAM(v) (void)(v) +#else +#define STBIR__UNUSED_PARAM(v) (void)sizeof(v) +#endif + +// must match stbir_datatype +static unsigned char stbir__type_size[] = { + 1, // STBIR_TYPE_UINT8 + 2, // STBIR_TYPE_UINT16 + 4, // STBIR_TYPE_UINT32 + 4, // STBIR_TYPE_FLOAT +}; + +// Kernel function centered at 0 +typedef float (stbir__kernel_fn)(float x, float scale); +typedef float (stbir__support_fn)(float scale); + +typedef struct +{ + stbir__kernel_fn* kernel; + stbir__support_fn* support; +} stbir__filter_info; + +// When upsampling, the contributors are which source pixels contribute. +// When downsampling, the contributors are which destination pixels are contributed to. +typedef struct +{ + int n0; // First contributing pixel + int n1; // Last contributing pixel +} stbir__contributors; + +typedef struct +{ + const void* input_data; + int input_w; + int input_h; + int input_stride_bytes; + + void* output_data; + int output_w; + int output_h; + int output_stride_bytes; + + float s0, t0, s1, t1; + + float horizontal_shift; // Units: output pixels + float vertical_shift; // Units: output pixels + float horizontal_scale; + float vertical_scale; + + int channels; + int alpha_channel; + stbir_uint32 flags; + stbir_datatype type; + stbir_filter horizontal_filter; + stbir_filter vertical_filter; + stbir_edge edge_horizontal; + stbir_edge edge_vertical; + stbir_colorspace colorspace; + + stbir__contributors* horizontal_contributors; + float* horizontal_coefficients; + + stbir__contributors* vertical_contributors; + float* vertical_coefficients; + + int decode_buffer_pixels; + float* decode_buffer; + + float* horizontal_buffer; + + // cache these because ceil/floor are inexplicably showing up in profile + int horizontal_coefficient_width; + int vertical_coefficient_width; + int horizontal_filter_pixel_width; + int vertical_filter_pixel_width; + int horizontal_filter_pixel_margin; + int vertical_filter_pixel_margin; + int horizontal_num_contributors; + int vertical_num_contributors; + + int ring_buffer_length_bytes; // The length of an individual entry in the ring buffer. The total number of ring buffers is stbir__get_filter_pixel_width(filter) + int ring_buffer_first_scanline; + int ring_buffer_last_scanline; + int ring_buffer_begin_index; + float* ring_buffer; + + float* encode_buffer; // A temporary buffer to store floats so we don't lose precision while we do multiply-adds. + + int horizontal_contributors_size; + int horizontal_coefficients_size; + int vertical_contributors_size; + int vertical_coefficients_size; + int decode_buffer_size; + int horizontal_buffer_size; + int ring_buffer_size; + int encode_buffer_size; +} stbir__info; + +static stbir__inline int stbir__min(int a, int b) +{ + return a < b ? a : b; +} + +static stbir__inline int stbir__max(int a, int b) +{ + return a > b ? a : b; +} + +static stbir__inline float stbir__saturate(float x) +{ + if (x < 0) + return 0; + + if (x > 1) + return 1; + + return x; +} + +#ifdef STBIR_SATURATE_INT +static stbir__inline stbir_uint8 stbir__saturate8(int x) +{ + if ((unsigned int) x <= 255) + return x; + + if (x < 0) + return 0; + + return 255; +} + +static stbir__inline stbir_uint16 stbir__saturate16(int x) +{ + if ((unsigned int) x <= 65535) + return x; + + if (x < 0) + return 0; + + return 65535; +} +#endif + +static float stbir__srgb_uchar_to_linear_float[256] = { + 0.000000f, 0.000304f, 0.000607f, 0.000911f, 0.001214f, 0.001518f, 0.001821f, 0.002125f, 0.002428f, 0.002732f, 0.003035f, + 0.003347f, 0.003677f, 0.004025f, 0.004391f, 0.004777f, 0.005182f, 0.005605f, 0.006049f, 0.006512f, 0.006995f, 0.007499f, + 0.008023f, 0.008568f, 0.009134f, 0.009721f, 0.010330f, 0.010960f, 0.011612f, 0.012286f, 0.012983f, 0.013702f, 0.014444f, + 0.015209f, 0.015996f, 0.016807f, 0.017642f, 0.018500f, 0.019382f, 0.020289f, 0.021219f, 0.022174f, 0.023153f, 0.024158f, + 0.025187f, 0.026241f, 0.027321f, 0.028426f, 0.029557f, 0.030713f, 0.031896f, 0.033105f, 0.034340f, 0.035601f, 0.036889f, + 0.038204f, 0.039546f, 0.040915f, 0.042311f, 0.043735f, 0.045186f, 0.046665f, 0.048172f, 0.049707f, 0.051269f, 0.052861f, + 0.054480f, 0.056128f, 0.057805f, 0.059511f, 0.061246f, 0.063010f, 0.064803f, 0.066626f, 0.068478f, 0.070360f, 0.072272f, + 0.074214f, 0.076185f, 0.078187f, 0.080220f, 0.082283f, 0.084376f, 0.086500f, 0.088656f, 0.090842f, 0.093059f, 0.095307f, + 0.097587f, 0.099899f, 0.102242f, 0.104616f, 0.107023f, 0.109462f, 0.111932f, 0.114435f, 0.116971f, 0.119538f, 0.122139f, + 0.124772f, 0.127438f, 0.130136f, 0.132868f, 0.135633f, 0.138432f, 0.141263f, 0.144128f, 0.147027f, 0.149960f, 0.152926f, + 0.155926f, 0.158961f, 0.162029f, 0.165132f, 0.168269f, 0.171441f, 0.174647f, 0.177888f, 0.181164f, 0.184475f, 0.187821f, + 0.191202f, 0.194618f, 0.198069f, 0.201556f, 0.205079f, 0.208637f, 0.212231f, 0.215861f, 0.219526f, 0.223228f, 0.226966f, + 0.230740f, 0.234551f, 0.238398f, 0.242281f, 0.246201f, 0.250158f, 0.254152f, 0.258183f, 0.262251f, 0.266356f, 0.270498f, + 0.274677f, 0.278894f, 0.283149f, 0.287441f, 0.291771f, 0.296138f, 0.300544f, 0.304987f, 0.309469f, 0.313989f, 0.318547f, + 0.323143f, 0.327778f, 0.332452f, 0.337164f, 0.341914f, 0.346704f, 0.351533f, 0.356400f, 0.361307f, 0.366253f, 0.371238f, + 0.376262f, 0.381326f, 0.386430f, 0.391573f, 0.396755f, 0.401978f, 0.407240f, 0.412543f, 0.417885f, 0.423268f, 0.428691f, + 0.434154f, 0.439657f, 0.445201f, 0.450786f, 0.456411f, 0.462077f, 0.467784f, 0.473532f, 0.479320f, 0.485150f, 0.491021f, + 0.496933f, 0.502887f, 0.508881f, 0.514918f, 0.520996f, 0.527115f, 0.533276f, 0.539480f, 0.545725f, 0.552011f, 0.558340f, + 0.564712f, 0.571125f, 0.577581f, 0.584078f, 0.590619f, 0.597202f, 0.603827f, 0.610496f, 0.617207f, 0.623960f, 0.630757f, + 0.637597f, 0.644480f, 0.651406f, 0.658375f, 0.665387f, 0.672443f, 0.679543f, 0.686685f, 0.693872f, 0.701102f, 0.708376f, + 0.715694f, 0.723055f, 0.730461f, 0.737911f, 0.745404f, 0.752942f, 0.760525f, 0.768151f, 0.775822f, 0.783538f, 0.791298f, + 0.799103f, 0.806952f, 0.814847f, 0.822786f, 0.830770f, 0.838799f, 0.846873f, 0.854993f, 0.863157f, 0.871367f, 0.879622f, + 0.887923f, 0.896269f, 0.904661f, 0.913099f, 0.921582f, 0.930111f, 0.938686f, 0.947307f, 0.955974f, 0.964686f, 0.973445f, + 0.982251f, 0.991102f, 1.0f +}; + +static float stbir__srgb_to_linear(float f) +{ + if (f <= 0.04045f) + return f / 12.92f; + else + return (float)pow((f + 0.055f) / 1.055f, 2.4f); +} + +static float stbir__linear_to_srgb(float f) +{ + if (f <= 0.0031308f) + return f * 12.92f; + else + return 1.055f * (float)pow(f, 1 / 2.4f) - 0.055f; +} + +#ifndef STBIR_NON_IEEE_FLOAT +// From https://gist.github.com/rygorous/2203834 + +typedef union +{ + stbir_uint32 u; + float f; +} stbir__FP32; + +static const stbir_uint32 fp32_to_srgb8_tab4[104] = { + 0x0073000d, 0x007a000d, 0x0080000d, 0x0087000d, 0x008d000d, 0x0094000d, 0x009a000d, 0x00a1000d, + 0x00a7001a, 0x00b4001a, 0x00c1001a, 0x00ce001a, 0x00da001a, 0x00e7001a, 0x00f4001a, 0x0101001a, + 0x010e0033, 0x01280033, 0x01410033, 0x015b0033, 0x01750033, 0x018f0033, 0x01a80033, 0x01c20033, + 0x01dc0067, 0x020f0067, 0x02430067, 0x02760067, 0x02aa0067, 0x02dd0067, 0x03110067, 0x03440067, + 0x037800ce, 0x03df00ce, 0x044600ce, 0x04ad00ce, 0x051400ce, 0x057b00c5, 0x05dd00bc, 0x063b00b5, + 0x06970158, 0x07420142, 0x07e30130, 0x087b0120, 0x090b0112, 0x09940106, 0x0a1700fc, 0x0a9500f2, + 0x0b0f01cb, 0x0bf401ae, 0x0ccb0195, 0x0d950180, 0x0e56016e, 0x0f0d015e, 0x0fbc0150, 0x10630143, + 0x11070264, 0x1238023e, 0x1357021d, 0x14660201, 0x156601e9, 0x165a01d3, 0x174401c0, 0x182401af, + 0x18fe0331, 0x1a9602fe, 0x1c1502d2, 0x1d7e02ad, 0x1ed4028d, 0x201a0270, 0x21520256, 0x227d0240, + 0x239f0443, 0x25c003fe, 0x27bf03c4, 0x29a10392, 0x2b6a0367, 0x2d1d0341, 0x2ebe031f, 0x304d0300, + 0x31d105b0, 0x34a80555, 0x37520507, 0x39d504c5, 0x3c37048b, 0x3e7c0458, 0x40a8042a, 0x42bd0401, + 0x44c20798, 0x488e071e, 0x4c1c06b6, 0x4f76065d, 0x52a50610, 0x55ac05cc, 0x5892058f, 0x5b590559, + 0x5e0c0a23, 0x631c0980, 0x67db08f6, 0x6c55087f, 0x70940818, 0x74a007bd, 0x787d076c, 0x7c330723, +}; + +static stbir_uint8 stbir__linear_to_srgb_uchar(float in) +{ + static const stbir__FP32 almostone = { 0x3f7fffff }; // 1-eps + static const stbir__FP32 minval = { (127-13) << 23 }; + stbir_uint32 tab,bias,scale,t; + stbir__FP32 f; + + // Clamp to [2^(-13), 1-eps]; these two values map to 0 and 1, respectively. + // The tests are carefully written so that NaNs map to 0, same as in the reference + // implementation. + if (!(in > minval.f)) // written this way to catch NaNs + in = minval.f; + if (in > almostone.f) + in = almostone.f; + + // Do the table lookup and unpack bias, scale + f.f = in; + tab = fp32_to_srgb8_tab4[(f.u - minval.u) >> 20]; + bias = (tab >> 16) << 9; + scale = tab & 0xffff; + + // Grab next-highest mantissa bits and perform linear interpolation + t = (f.u >> 12) & 0xff; + return (unsigned char) ((bias + scale*t) >> 16); +} + +#else +// sRGB transition values, scaled by 1<<28 +static int stbir__srgb_offset_to_linear_scaled[256] = +{ + 0, 40738, 122216, 203693, 285170, 366648, 448125, 529603, + 611080, 692557, 774035, 855852, 942009, 1033024, 1128971, 1229926, + 1335959, 1447142, 1563542, 1685229, 1812268, 1944725, 2082664, 2226148, + 2375238, 2529996, 2690481, 2856753, 3028870, 3206888, 3390865, 3580856, + 3776916, 3979100, 4187460, 4402049, 4622919, 4850123, 5083710, 5323731, + 5570236, 5823273, 6082892, 6349140, 6622065, 6901714, 7188133, 7481369, + 7781466, 8088471, 8402427, 8723380, 9051372, 9386448, 9728650, 10078021, + 10434603, 10798439, 11169569, 11548036, 11933879, 12327139, 12727857, 13136073, + 13551826, 13975156, 14406100, 14844697, 15290987, 15745007, 16206795, 16676389, + 17153826, 17639142, 18132374, 18633560, 19142734, 19659934, 20185196, 20718552, + 21260042, 21809696, 22367554, 22933648, 23508010, 24090680, 24681686, 25281066, + 25888850, 26505076, 27129772, 27762974, 28404716, 29055026, 29713942, 30381490, + 31057708, 31742624, 32436272, 33138682, 33849884, 34569912, 35298800, 36036568, + 36783260, 37538896, 38303512, 39077136, 39859796, 40651528, 41452360, 42262316, + 43081432, 43909732, 44747252, 45594016, 46450052, 47315392, 48190064, 49074096, + 49967516, 50870356, 51782636, 52704392, 53635648, 54576432, 55526772, 56486700, + 57456236, 58435408, 59424248, 60422780, 61431036, 62449032, 63476804, 64514376, + 65561776, 66619028, 67686160, 68763192, 69850160, 70947088, 72053992, 73170912, + 74297864, 75434880, 76581976, 77739184, 78906536, 80084040, 81271736, 82469648, + 83677792, 84896192, 86124888, 87363888, 88613232, 89872928, 91143016, 92423512, + 93714432, 95015816, 96327688, 97650056, 98982952, 100326408, 101680440, 103045072, + 104420320, 105806224, 107202800, 108610064, 110028048, 111456776, 112896264, 114346544, + 115807632, 117279552, 118762328, 120255976, 121760536, 123276016, 124802440, 126339832, + 127888216, 129447616, 131018048, 132599544, 134192112, 135795792, 137410592, 139036528, + 140673648, 142321952, 143981456, 145652208, 147334208, 149027488, 150732064, 152447968, + 154175200, 155913792, 157663776, 159425168, 161197984, 162982240, 164777968, 166585184, + 168403904, 170234160, 172075968, 173929344, 175794320, 177670896, 179559120, 181458992, + 183370528, 185293776, 187228736, 189175424, 191133888, 193104112, 195086128, 197079968, + 199085648, 201103184, 203132592, 205173888, 207227120, 209292272, 211369392, 213458480, + 215559568, 217672656, 219797792, 221934976, 224084240, 226245600, 228419056, 230604656, + 232802400, 235012320, 237234432, 239468736, 241715280, 243974080, 246245120, 248528464, + 250824112, 253132064, 255452368, 257785040, 260130080, 262487520, 264857376, 267239664, +}; + +static stbir_uint8 stbir__linear_to_srgb_uchar(float f) +{ + int x = (int) (f * (1 << 28)); // has headroom so you don't need to clamp + int v = 0; + int i; + + // Refine the guess with a short binary search. + i = v + 128; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i; + i = v + 64; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i; + i = v + 32; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i; + i = v + 16; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i; + i = v + 8; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i; + i = v + 4; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i; + i = v + 2; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i; + i = v + 1; if (x >= stbir__srgb_offset_to_linear_scaled[i]) v = i; + + return (stbir_uint8) v; +} +#endif + +static float stbir__filter_trapezoid(float x, float scale) +{ + float halfscale = scale / 2; + float t = 0.5f + halfscale; + STBIR__DEBUG_ASSERT(scale <= 1); + + x = (float)fabs(x); + + if (x >= t) + return 0; + else + { + float r = 0.5f - halfscale; + if (x <= r) + return 1; + else + return (t - x) / scale; + } +} + +static float stbir__support_trapezoid(float scale) +{ + STBIR__DEBUG_ASSERT(scale <= 1); + return 0.5f + scale / 2; +} + +static float stbir__filter_triangle(float x, float s) +{ + STBIR__UNUSED_PARAM(s); + + x = (float)fabs(x); + + if (x <= 1.0f) + return 1 - x; + else + return 0; +} + +static float stbir__filter_cubic(float x, float s) +{ + STBIR__UNUSED_PARAM(s); + + x = (float)fabs(x); + + if (x < 1.0f) + return (4 + x*x*(3*x - 6))/6; + else if (x < 2.0f) + return (8 + x*(-12 + x*(6 - x)))/6; + + return (0.0f); +} + +static float stbir__filter_catmullrom(float x, float s) +{ + STBIR__UNUSED_PARAM(s); + + x = (float)fabs(x); + + if (x < 1.0f) + return 1 - x*x*(2.5f - 1.5f*x); + else if (x < 2.0f) + return 2 - x*(4 + x*(0.5f*x - 2.5f)); + + return (0.0f); +} + +static float stbir__filter_mitchell(float x, float s) +{ + STBIR__UNUSED_PARAM(s); + + x = (float)fabs(x); + + if (x < 1.0f) + return (16 + x*x*(21 * x - 36))/18; + else if (x < 2.0f) + return (32 + x*(-60 + x*(36 - 7*x)))/18; + + return (0.0f); +} + +static float stbir__support_zero(float s) +{ + STBIR__UNUSED_PARAM(s); + return 0; +} + +static float stbir__support_one(float s) +{ + STBIR__UNUSED_PARAM(s); + return 1; +} + +static float stbir__support_two(float s) +{ + STBIR__UNUSED_PARAM(s); + return 2; +} + +static stbir__filter_info stbir__filter_info_table[] = { + { NULL, stbir__support_zero }, + { stbir__filter_trapezoid, stbir__support_trapezoid }, + { stbir__filter_triangle, stbir__support_one }, + { stbir__filter_cubic, stbir__support_two }, + { stbir__filter_catmullrom, stbir__support_two }, + { stbir__filter_mitchell, stbir__support_two }, +}; + +stbir__inline static int stbir__use_upsampling(float ratio) +{ + return ratio > 1; +} + +stbir__inline static int stbir__use_width_upsampling(stbir__info* stbir_info) +{ + return stbir__use_upsampling(stbir_info->horizontal_scale); +} + +stbir__inline static int stbir__use_height_upsampling(stbir__info* stbir_info) +{ + return stbir__use_upsampling(stbir_info->vertical_scale); +} + +// This is the maximum number of input samples that can affect an output sample +// with the given filter +static int stbir__get_filter_pixel_width(stbir_filter filter, float scale) +{ + STBIR_ASSERT(filter != 0); + STBIR_ASSERT(filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); + + if (stbir__use_upsampling(scale)) + return (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2); + else + return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2 / scale); +} + +// This is how much to expand buffers to account for filters seeking outside +// the image boundaries. +static int stbir__get_filter_pixel_margin(stbir_filter filter, float scale) +{ + return stbir__get_filter_pixel_width(filter, scale) / 2; +} + +static int stbir__get_coefficient_width(stbir_filter filter, float scale) +{ + if (stbir__use_upsampling(scale)) + return (int)ceil(stbir__filter_info_table[filter].support(1 / scale) * 2); + else + return (int)ceil(stbir__filter_info_table[filter].support(scale) * 2); +} + +static int stbir__get_contributors(float scale, stbir_filter filter, int input_size, int output_size) +{ + if (stbir__use_upsampling(scale)) + return output_size; + else + return (input_size + stbir__get_filter_pixel_margin(filter, scale) * 2); +} + +static int stbir__get_total_horizontal_coefficients(stbir__info* info) +{ + return info->horizontal_num_contributors + * stbir__get_coefficient_width (info->horizontal_filter, info->horizontal_scale); +} + +static int stbir__get_total_vertical_coefficients(stbir__info* info) +{ + return info->vertical_num_contributors + * stbir__get_coefficient_width (info->vertical_filter, info->vertical_scale); +} + +static stbir__contributors* stbir__get_contributor(stbir__contributors* contributors, int n) +{ + return &contributors[n]; +} + +// For perf reasons this code is duplicated in stbir__resample_horizontal_upsample/downsample, +// if you change it here change it there too. +static float* stbir__get_coefficient(float* coefficients, stbir_filter filter, float scale, int n, int c) +{ + int width = stbir__get_coefficient_width(filter, scale); + return &coefficients[width*n + c]; +} + +static int stbir__edge_wrap_slow(stbir_edge edge, int n, int max) +{ + switch (edge) + { + case STBIR_EDGE_ZERO: + return 0; // we'll decode the wrong pixel here, and then overwrite with 0s later + + case STBIR_EDGE_CLAMP: + if (n < 0) + return 0; + + if (n >= max) + return max - 1; + + return n; // NOTREACHED + + case STBIR_EDGE_REFLECT: + { + if (n < 0) + { + if (n < max) + return -n; + else + return max - 1; + } + + if (n >= max) + { + int max2 = max * 2; + if (n >= max2) + return 0; + else + return max2 - n - 1; + } + + return n; // NOTREACHED + } + + case STBIR_EDGE_WRAP: + if (n >= 0) + return (n % max); + else + { + int m = (-n) % max; + + if (m != 0) + m = max - m; + + return (m); + } + return n; // NOTREACHED + + default: + STBIR__UNIMPLEMENTED("Unimplemented edge type"); + return 0; + } +} + +stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max) +{ + // avoid per-pixel switch + if (n >= 0 && n < max) + return n; + return stbir__edge_wrap_slow(edge, n, max); +} + +// What input pixels contribute to this output pixel? +static void stbir__calculate_sample_range_upsample(int n, float out_filter_radius, float scale_ratio, float out_shift, int* in_first_pixel, int* in_last_pixel, float* in_center_of_out) +{ + float out_pixel_center = (float)n + 0.5f; + float out_pixel_influence_lowerbound = out_pixel_center - out_filter_radius; + float out_pixel_influence_upperbound = out_pixel_center + out_filter_radius; + + float in_pixel_influence_lowerbound = (out_pixel_influence_lowerbound + out_shift) / scale_ratio; + float in_pixel_influence_upperbound = (out_pixel_influence_upperbound + out_shift) / scale_ratio; + + *in_center_of_out = (out_pixel_center + out_shift) / scale_ratio; + *in_first_pixel = (int)(floor(in_pixel_influence_lowerbound + 0.5)); + *in_last_pixel = (int)(floor(in_pixel_influence_upperbound - 0.5)); +} + +// What output pixels does this input pixel contribute to? +static void stbir__calculate_sample_range_downsample(int n, float in_pixels_radius, float scale_ratio, float out_shift, int* out_first_pixel, int* out_last_pixel, float* out_center_of_in) +{ + float in_pixel_center = (float)n + 0.5f; + float in_pixel_influence_lowerbound = in_pixel_center - in_pixels_radius; + float in_pixel_influence_upperbound = in_pixel_center + in_pixels_radius; + + float out_pixel_influence_lowerbound = in_pixel_influence_lowerbound * scale_ratio - out_shift; + float out_pixel_influence_upperbound = in_pixel_influence_upperbound * scale_ratio - out_shift; + + *out_center_of_in = in_pixel_center * scale_ratio - out_shift; + *out_first_pixel = (int)(floor(out_pixel_influence_lowerbound + 0.5)); + *out_last_pixel = (int)(floor(out_pixel_influence_upperbound - 0.5)); +} + +static void stbir__calculate_coefficients_upsample(stbir__info* stbir_info, stbir_filter filter, float scale, int in_first_pixel, int in_last_pixel, float in_center_of_out, stbir__contributors* contributor, float* coefficient_group) +{ + int i; + float total_filter = 0; + float filter_scale; + + STBIR__DEBUG_ASSERT(in_last_pixel - in_first_pixel <= (int)ceil(stbir__filter_info_table[filter].support(1/scale) * 2)); // Taken directly from stbir__get_coefficient_width() which we can't call because we don't know if we're horizontal or vertical. + + contributor->n0 = in_first_pixel; + contributor->n1 = in_last_pixel; + + STBIR__DEBUG_ASSERT(contributor->n1 >= contributor->n0); + + for (i = 0; i <= in_last_pixel - in_first_pixel; i++) + { + float in_pixel_center = (float)(i + in_first_pixel) + 0.5f; + coefficient_group[i] = stbir__filter_info_table[filter].kernel(in_center_of_out - in_pixel_center, 1 / scale); + + // If the coefficient is zero, skip it. (Don't do the <0 check here, we want the influence of those outside pixels.) + if (i == 0 && !coefficient_group[i]) + { + contributor->n0 = ++in_first_pixel; + i--; + continue; + } + + total_filter += coefficient_group[i]; + } + + STBIR__DEBUG_ASSERT(stbir__filter_info_table[filter].kernel((float)(in_last_pixel + 1) + 0.5f - in_center_of_out, 1/scale) == 0); + + STBIR__DEBUG_ASSERT(total_filter > 0.9); + STBIR__DEBUG_ASSERT(total_filter < 1.1f); // Make sure it's not way off. + + // Make sure the sum of all coefficients is 1. + filter_scale = 1 / total_filter; + + for (i = 0; i <= in_last_pixel - in_first_pixel; i++) + coefficient_group[i] *= filter_scale; + + for (i = in_last_pixel - in_first_pixel; i >= 0; i--) + { + if (coefficient_group[i]) + break; + + // This line has no weight. We can skip it. + contributor->n1 = contributor->n0 + i - 1; + } +} + +static void stbir__calculate_coefficients_downsample(stbir__info* stbir_info, stbir_filter filter, float scale_ratio, int out_first_pixel, int out_last_pixel, float out_center_of_in, stbir__contributors* contributor, float* coefficient_group) +{ + int i; + + STBIR__DEBUG_ASSERT(out_last_pixel - out_first_pixel <= (int)ceil(stbir__filter_info_table[filter].support(scale_ratio) * 2)); // Taken directly from stbir__get_coefficient_width() which we can't call because we don't know if we're horizontal or vertical. + + contributor->n0 = out_first_pixel; + contributor->n1 = out_last_pixel; + + STBIR__DEBUG_ASSERT(contributor->n1 >= contributor->n0); + + for (i = 0; i <= out_last_pixel - out_first_pixel; i++) + { + float out_pixel_center = (float)(i + out_first_pixel) + 0.5f; + float x = out_pixel_center - out_center_of_in; + coefficient_group[i] = stbir__filter_info_table[filter].kernel(x, scale_ratio) * scale_ratio; + } + + STBIR__DEBUG_ASSERT(stbir__filter_info_table[filter].kernel((float)(out_last_pixel + 1) + 0.5f - out_center_of_in, scale_ratio) == 0); + + for (i = out_last_pixel - out_first_pixel; i >= 0; i--) + { + if (coefficient_group[i]) + break; + + // This line has no weight. We can skip it. + contributor->n1 = contributor->n0 + i - 1; + } +} + +static void stbir__normalize_downsample_coefficients(stbir__info* stbir_info, stbir__contributors* contributors, float* coefficients, stbir_filter filter, float scale_ratio, float shift, int input_size, int output_size) +{ + int num_contributors = stbir__get_contributors(scale_ratio, filter, input_size, output_size); + int num_coefficients = stbir__get_coefficient_width(filter, scale_ratio); + int i, j; + int skip; + + for (i = 0; i < output_size; i++) + { + float scale; + float total = 0; + + for (j = 0; j < num_contributors; j++) + { + if (i >= contributors[j].n0 && i <= contributors[j].n1) + { + float coefficient = *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i - contributors[j].n0); + total += coefficient; + } + else if (i < contributors[j].n0) + break; + } + + STBIR__DEBUG_ASSERT(total > 0.9f); + STBIR__DEBUG_ASSERT(total < 1.1f); + + scale = 1 / total; + + for (j = 0; j < num_contributors; j++) + { + if (i >= contributors[j].n0 && i <= contributors[j].n1) + *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i - contributors[j].n0) *= scale; + else if (i < contributors[j].n0) + break; + } + } + + // Optimize: Skip zero coefficients and contributions outside of image bounds. + // Do this after normalizing because normalization depends on the n0/n1 values. + for (j = 0; j < num_contributors; j++) + { + int range, max, width; + + skip = 0; + while (*stbir__get_coefficient(coefficients, filter, scale_ratio, j, skip) == 0) + skip++; + + contributors[j].n0 += skip; + + while (contributors[j].n0 < 0) + { + contributors[j].n0++; + skip++; + } + + range = contributors[j].n1 - contributors[j].n0 + 1; + max = stbir__min(num_coefficients, range); + + width = stbir__get_coefficient_width(filter, scale_ratio); + for (i = 0; i < max; i++) + { + if (i + skip >= width) + break; + + *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i) = *stbir__get_coefficient(coefficients, filter, scale_ratio, j, i + skip); + } + + continue; + } + + // Using min to avoid writing into invalid pixels. + for (i = 0; i < num_contributors; i++) + contributors[i].n1 = stbir__min(contributors[i].n1, output_size - 1); +} + +// Each scan line uses the same kernel values so we should calculate the kernel +// values once and then we can use them for every scan line. +static void stbir__calculate_filters(stbir__info* stbir_info, stbir__contributors* contributors, float* coefficients, stbir_filter filter, float scale_ratio, float shift, int input_size, int output_size) +{ + int n; + int total_contributors = stbir__get_contributors(scale_ratio, filter, input_size, output_size); + + if (stbir__use_upsampling(scale_ratio)) + { + float out_pixels_radius = stbir__filter_info_table[filter].support(1 / scale_ratio) * scale_ratio; + + // Looping through out pixels + for (n = 0; n < total_contributors; n++) + { + float in_center_of_out; // Center of the current out pixel in the in pixel space + int in_first_pixel, in_last_pixel; + + stbir__calculate_sample_range_upsample(n, out_pixels_radius, scale_ratio, shift, &in_first_pixel, &in_last_pixel, &in_center_of_out); + + stbir__calculate_coefficients_upsample(stbir_info, filter, scale_ratio, in_first_pixel, in_last_pixel, in_center_of_out, stbir__get_contributor(contributors, n), stbir__get_coefficient(coefficients, filter, scale_ratio, n, 0)); + } + } + else + { + float in_pixels_radius = stbir__filter_info_table[filter].support(scale_ratio) / scale_ratio; + + // Looping through in pixels + for (n = 0; n < total_contributors; n++) + { + float out_center_of_in; // Center of the current out pixel in the in pixel space + int out_first_pixel, out_last_pixel; + int n_adjusted = n - stbir__get_filter_pixel_margin(filter, scale_ratio); + + stbir__calculate_sample_range_downsample(n_adjusted, in_pixels_radius, scale_ratio, shift, &out_first_pixel, &out_last_pixel, &out_center_of_in); + + stbir__calculate_coefficients_downsample(stbir_info, filter, scale_ratio, out_first_pixel, out_last_pixel, out_center_of_in, stbir__get_contributor(contributors, n), stbir__get_coefficient(coefficients, filter, scale_ratio, n, 0)); + } + + stbir__normalize_downsample_coefficients(stbir_info, contributors, coefficients, filter, scale_ratio, shift, input_size, output_size); + } +} + +static float* stbir__get_decode_buffer(stbir__info* stbir_info) +{ + // The 0 index of the decode buffer starts after the margin. This makes + // it okay to use negative indexes on the decode buffer. + return &stbir_info->decode_buffer[stbir_info->horizontal_filter_pixel_margin * stbir_info->channels]; +} + +#define STBIR__DECODE(type, colorspace) ((type) * (STBIR_MAX_COLORSPACES) + (colorspace)) + +static void stbir__decode_scanline(stbir__info* stbir_info, int n) +{ + int c; + int channels = stbir_info->channels; + int alpha_channel = stbir_info->alpha_channel; + int type = stbir_info->type; + int colorspace = stbir_info->colorspace; + int input_w = stbir_info->input_w; + int input_stride_bytes = stbir_info->input_stride_bytes; + float* decode_buffer = stbir__get_decode_buffer(stbir_info); + stbir_edge edge_horizontal = stbir_info->edge_horizontal; + stbir_edge edge_vertical = stbir_info->edge_vertical; + int in_buffer_row_offset = stbir__edge_wrap(edge_vertical, n, stbir_info->input_h) * input_stride_bytes; + const void* input_data = (char *) stbir_info->input_data + in_buffer_row_offset; + int max_x = input_w + stbir_info->horizontal_filter_pixel_margin; + int decode = STBIR__DECODE(type, colorspace); + + int x = -stbir_info->horizontal_filter_pixel_margin; + + // special handling for STBIR_EDGE_ZERO because it needs to return an item that doesn't appear in the input, + // and we want to avoid paying overhead on every pixel if not STBIR_EDGE_ZERO + if (edge_vertical == STBIR_EDGE_ZERO && (n < 0 || n >= stbir_info->input_h)) + { + for (; x < max_x; x++) + for (c = 0; c < channels; c++) + decode_buffer[x*channels + c] = 0; + return; + } + + switch (decode) + { + case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR): + for (; x < max_x; x++) + { + int decode_pixel_index = x * channels; + int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels; + for (c = 0; c < channels; c++) + decode_buffer[decode_pixel_index + c] = ((float)((const unsigned char*)input_data)[input_pixel_index + c]) / 255; + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB): + for (; x < max_x; x++) + { + int decode_pixel_index = x * channels; + int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels; + for (c = 0; c < channels; c++) + decode_buffer[decode_pixel_index + c] = stbir__srgb_uchar_to_linear_float[((const unsigned char*)input_data)[input_pixel_index + c]]; + + if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE)) + decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned char*)input_data)[input_pixel_index + alpha_channel]) / 255; + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR): + for (; x < max_x; x++) + { + int decode_pixel_index = x * channels; + int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels; + for (c = 0; c < channels; c++) + decode_buffer[decode_pixel_index + c] = ((float)((const unsigned short*)input_data)[input_pixel_index + c]) / 65535; + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB): + for (; x < max_x; x++) + { + int decode_pixel_index = x * channels; + int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels; + for (c = 0; c < channels; c++) + decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((float)((const unsigned short*)input_data)[input_pixel_index + c]) / 65535); + + if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE)) + decode_buffer[decode_pixel_index + alpha_channel] = ((float)((const unsigned short*)input_data)[input_pixel_index + alpha_channel]) / 65535; + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR): + for (; x < max_x; x++) + { + int decode_pixel_index = x * channels; + int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels; + for (c = 0; c < channels; c++) + decode_buffer[decode_pixel_index + c] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / 4294967295); + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB): + for (; x < max_x; x++) + { + int decode_pixel_index = x * channels; + int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels; + for (c = 0; c < channels; c++) + decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear((float)(((double)((const unsigned int*)input_data)[input_pixel_index + c]) / 4294967295)); + + if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE)) + decode_buffer[decode_pixel_index + alpha_channel] = (float)(((double)((const unsigned int*)input_data)[input_pixel_index + alpha_channel]) / 4294967295); + } + break; + + case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR): + for (; x < max_x; x++) + { + int decode_pixel_index = x * channels; + int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels; + for (c = 0; c < channels; c++) + decode_buffer[decode_pixel_index + c] = ((const float*)input_data)[input_pixel_index + c]; + } + break; + + case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB): + for (; x < max_x; x++) + { + int decode_pixel_index = x * channels; + int input_pixel_index = stbir__edge_wrap(edge_horizontal, x, input_w) * channels; + for (c = 0; c < channels; c++) + decode_buffer[decode_pixel_index + c] = stbir__srgb_to_linear(((const float*)input_data)[input_pixel_index + c]); + + if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE)) + decode_buffer[decode_pixel_index + alpha_channel] = ((const float*)input_data)[input_pixel_index + alpha_channel]; + } + + break; + + default: + STBIR__UNIMPLEMENTED("Unknown type/colorspace/channels combination."); + break; + } + + if (!(stbir_info->flags & STBIR_FLAG_ALPHA_PREMULTIPLIED)) + { + for (x = -stbir_info->horizontal_filter_pixel_margin; x < max_x; x++) + { + int decode_pixel_index = x * channels; + + // If the alpha value is 0 it will clobber the color values. Make sure it's not. + float alpha = decode_buffer[decode_pixel_index + alpha_channel]; +#ifndef STBIR_NO_ALPHA_EPSILON + if (stbir_info->type != STBIR_TYPE_FLOAT) { + alpha += STBIR_ALPHA_EPSILON; + decode_buffer[decode_pixel_index + alpha_channel] = alpha; + } +#endif + for (c = 0; c < channels; c++) + { + if (c == alpha_channel) + continue; + + decode_buffer[decode_pixel_index + c] *= alpha; + } + } + } + + if (edge_horizontal == STBIR_EDGE_ZERO) + { + for (x = -stbir_info->horizontal_filter_pixel_margin; x < 0; x++) + { + for (c = 0; c < channels; c++) + decode_buffer[x*channels + c] = 0; + } + for (x = input_w; x < max_x; x++) + { + for (c = 0; c < channels; c++) + decode_buffer[x*channels + c] = 0; + } + } +} + +static float* stbir__get_ring_buffer_entry(float* ring_buffer, int index, int ring_buffer_length) +{ + return &ring_buffer[index * ring_buffer_length]; +} + +static float* stbir__add_empty_ring_buffer_entry(stbir__info* stbir_info, int n) +{ + int ring_buffer_index; + float* ring_buffer; + + if (stbir_info->ring_buffer_begin_index < 0) + { + ring_buffer_index = stbir_info->ring_buffer_begin_index = 0; + stbir_info->ring_buffer_first_scanline = n; + } + else + { + ring_buffer_index = (stbir_info->ring_buffer_begin_index + (stbir_info->ring_buffer_last_scanline - stbir_info->ring_buffer_first_scanline) + 1) % stbir_info->vertical_filter_pixel_width; + STBIR__DEBUG_ASSERT(ring_buffer_index != stbir_info->ring_buffer_begin_index); + } + + ring_buffer = stbir__get_ring_buffer_entry(stbir_info->ring_buffer, ring_buffer_index, stbir_info->ring_buffer_length_bytes / sizeof(float)); + memset(ring_buffer, 0, stbir_info->ring_buffer_length_bytes); + + stbir_info->ring_buffer_last_scanline = n; + + return ring_buffer; +} + + +static void stbir__resample_horizontal_upsample(stbir__info* stbir_info, int n, float* output_buffer) +{ + int x, k; + int output_w = stbir_info->output_w; + int kernel_pixel_width = stbir_info->horizontal_filter_pixel_width; + int channels = stbir_info->channels; + float* decode_buffer = stbir__get_decode_buffer(stbir_info); + stbir__contributors* horizontal_contributors = stbir_info->horizontal_contributors; + float* horizontal_coefficients = stbir_info->horizontal_coefficients; + int coefficient_width = stbir_info->horizontal_coefficient_width; + + for (x = 0; x < output_w; x++) + { + int n0 = horizontal_contributors[x].n0; + int n1 = horizontal_contributors[x].n1; + + int out_pixel_index = x * channels; + int coefficient_group = coefficient_width * x; + int coefficient_counter = 0; + + STBIR__DEBUG_ASSERT(n1 >= n0); + STBIR__DEBUG_ASSERT(n0 >= -stbir_info->horizontal_filter_pixel_margin); + STBIR__DEBUG_ASSERT(n1 >= -stbir_info->horizontal_filter_pixel_margin); + STBIR__DEBUG_ASSERT(n0 < stbir_info->input_w + stbir_info->horizontal_filter_pixel_margin); + STBIR__DEBUG_ASSERT(n1 < stbir_info->input_w + stbir_info->horizontal_filter_pixel_margin); + + switch (channels) { + case 1: + for (k = n0; k <= n1; k++) + { + int in_pixel_index = k * 1; + float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++]; + STBIR__DEBUG_ASSERT(coefficient != 0); + output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient; + } + break; + case 2: + for (k = n0; k <= n1; k++) + { + int in_pixel_index = k * 2; + float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++]; + STBIR__DEBUG_ASSERT(coefficient != 0); + output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient; + output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient; + } + break; + case 3: + for (k = n0; k <= n1; k++) + { + int in_pixel_index = k * 3; + float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++]; + STBIR__DEBUG_ASSERT(coefficient != 0); + output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient; + output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient; + output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient; + } + break; + case 4: + for (k = n0; k <= n1; k++) + { + int in_pixel_index = k * 4; + float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++]; + STBIR__DEBUG_ASSERT(coefficient != 0); + output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient; + output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient; + output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient; + output_buffer[out_pixel_index + 3] += decode_buffer[in_pixel_index + 3] * coefficient; + } + break; + default: + for (k = n0; k <= n1; k++) + { + int in_pixel_index = k * channels; + float coefficient = horizontal_coefficients[coefficient_group + coefficient_counter++]; + int c; + STBIR__DEBUG_ASSERT(coefficient != 0); + for (c = 0; c < channels; c++) + output_buffer[out_pixel_index + c] += decode_buffer[in_pixel_index + c] * coefficient; + } + break; + } + } +} + +static void stbir__resample_horizontal_downsample(stbir__info* stbir_info, int n, float* output_buffer) +{ + int x, k; + int input_w = stbir_info->input_w; + int output_w = stbir_info->output_w; + int kernel_pixel_width = stbir_info->horizontal_filter_pixel_width; + int channels = stbir_info->channels; + float* decode_buffer = stbir__get_decode_buffer(stbir_info); + stbir__contributors* horizontal_contributors = stbir_info->horizontal_contributors; + float* horizontal_coefficients = stbir_info->horizontal_coefficients; + int coefficient_width = stbir_info->horizontal_coefficient_width; + int filter_pixel_margin = stbir_info->horizontal_filter_pixel_margin; + int max_x = input_w + filter_pixel_margin * 2; + + STBIR__DEBUG_ASSERT(!stbir__use_width_upsampling(stbir_info)); + + switch (channels) { + case 1: + for (x = 0; x < max_x; x++) + { + int n0 = horizontal_contributors[x].n0; + int n1 = horizontal_contributors[x].n1; + + int in_x = x - filter_pixel_margin; + int in_pixel_index = in_x * 1; + int max_n = n1; + int coefficient_group = coefficient_width * x; + + for (k = n0; k <= max_n; k++) + { + int out_pixel_index = k * 1; + float coefficient = horizontal_coefficients[coefficient_group + k - n0]; + STBIR__DEBUG_ASSERT(coefficient != 0); + output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient; + } + } + break; + + case 2: + for (x = 0; x < max_x; x++) + { + int n0 = horizontal_contributors[x].n0; + int n1 = horizontal_contributors[x].n1; + + int in_x = x - filter_pixel_margin; + int in_pixel_index = in_x * 2; + int max_n = n1; + int coefficient_group = coefficient_width * x; + + for (k = n0; k <= max_n; k++) + { + int out_pixel_index = k * 2; + float coefficient = horizontal_coefficients[coefficient_group + k - n0]; + STBIR__DEBUG_ASSERT(coefficient != 0); + output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient; + output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient; + } + } + break; + + case 3: + for (x = 0; x < max_x; x++) + { + int n0 = horizontal_contributors[x].n0; + int n1 = horizontal_contributors[x].n1; + + int in_x = x - filter_pixel_margin; + int in_pixel_index = in_x * 3; + int max_n = n1; + int coefficient_group = coefficient_width * x; + + for (k = n0; k <= max_n; k++) + { + int out_pixel_index = k * 3; + float coefficient = horizontal_coefficients[coefficient_group + k - n0]; + STBIR__DEBUG_ASSERT(coefficient != 0); + output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient; + output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient; + output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient; + } + } + break; + + case 4: + for (x = 0; x < max_x; x++) + { + int n0 = horizontal_contributors[x].n0; + int n1 = horizontal_contributors[x].n1; + + int in_x = x - filter_pixel_margin; + int in_pixel_index = in_x * 4; + int max_n = n1; + int coefficient_group = coefficient_width * x; + + for (k = n0; k <= max_n; k++) + { + int out_pixel_index = k * 4; + float coefficient = horizontal_coefficients[coefficient_group + k - n0]; + STBIR__DEBUG_ASSERT(coefficient != 0); + output_buffer[out_pixel_index + 0] += decode_buffer[in_pixel_index + 0] * coefficient; + output_buffer[out_pixel_index + 1] += decode_buffer[in_pixel_index + 1] * coefficient; + output_buffer[out_pixel_index + 2] += decode_buffer[in_pixel_index + 2] * coefficient; + output_buffer[out_pixel_index + 3] += decode_buffer[in_pixel_index + 3] * coefficient; + } + } + break; + + default: + for (x = 0; x < max_x; x++) + { + int n0 = horizontal_contributors[x].n0; + int n1 = horizontal_contributors[x].n1; + + int in_x = x - filter_pixel_margin; + int in_pixel_index = in_x * channels; + int max_n = n1; + int coefficient_group = coefficient_width * x; + + for (k = n0; k <= max_n; k++) + { + int c; + int out_pixel_index = k * channels; + float coefficient = horizontal_coefficients[coefficient_group + k - n0]; + STBIR__DEBUG_ASSERT(coefficient != 0); + for (c = 0; c < channels; c++) + output_buffer[out_pixel_index + c] += decode_buffer[in_pixel_index + c] * coefficient; + } + } + break; + } +} + +static void stbir__decode_and_resample_upsample(stbir__info* stbir_info, int n) +{ + // Decode the nth scanline from the source image into the decode buffer. + stbir__decode_scanline(stbir_info, n); + + // Now resample it into the ring buffer. + if (stbir__use_width_upsampling(stbir_info)) + stbir__resample_horizontal_upsample(stbir_info, n, stbir__add_empty_ring_buffer_entry(stbir_info, n)); + else + stbir__resample_horizontal_downsample(stbir_info, n, stbir__add_empty_ring_buffer_entry(stbir_info, n)); + + // Now it's sitting in the ring buffer ready to be used as source for the vertical sampling. +} + +static void stbir__decode_and_resample_downsample(stbir__info* stbir_info, int n) +{ + // Decode the nth scanline from the source image into the decode buffer. + stbir__decode_scanline(stbir_info, n); + + memset(stbir_info->horizontal_buffer, 0, stbir_info->output_w * stbir_info->channels * sizeof(float)); + + // Now resample it into the horizontal buffer. + if (stbir__use_width_upsampling(stbir_info)) + stbir__resample_horizontal_upsample(stbir_info, n, stbir_info->horizontal_buffer); + else + stbir__resample_horizontal_downsample(stbir_info, n, stbir_info->horizontal_buffer); + + // Now it's sitting in the horizontal buffer ready to be distributed into the ring buffers. +} + +// Get the specified scan line from the ring buffer. +static float* stbir__get_ring_buffer_scanline(int get_scanline, float* ring_buffer, int begin_index, int first_scanline, int ring_buffer_size, int ring_buffer_length) +{ + int ring_buffer_index = (begin_index + (get_scanline - first_scanline)) % ring_buffer_size; + return stbir__get_ring_buffer_entry(ring_buffer, ring_buffer_index, ring_buffer_length); +} + + +static void stbir__encode_scanline(stbir__info* stbir_info, int num_pixels, void *output_buffer, float *encode_buffer, int channels, int alpha_channel, int decode) +{ + int x; + int n; + int num_nonalpha; + stbir_uint16 nonalpha[STBIR_MAX_CHANNELS]; + + if (!(stbir_info->flags&STBIR_FLAG_ALPHA_PREMULTIPLIED)) + { + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + float alpha = encode_buffer[pixel_index + alpha_channel]; + float reciprocal_alpha = alpha ? 1.0f / alpha : 0; + + // unrolling this produced a 1% slowdown upscaling a large RGBA linear-space image on my machine - stb + for (n = 0; n < channels; n++) + if (n != alpha_channel) + encode_buffer[pixel_index + n] *= reciprocal_alpha; + + // We added in a small epsilon to prevent the color channel from being deleted with zero alpha. + // Because we only add it for integer types, it will automatically be discarded on integer + // conversion, so we don't need to subtract it back out (which would be problematic for + // numeric precision reasons). + } + } + + // build a table of all channels that need colorspace correction, so + // we don't perform colorspace correction on channels that don't need it. + for (x=0, num_nonalpha=0; x < channels; ++x) + if (x != alpha_channel || (stbir_info->flags & STBIR_FLAG_ALPHA_USES_COLORSPACE)) + nonalpha[num_nonalpha++] = x; + + #define STBIR__ROUND_INT(f) ((int) ((f)+0.5)) + #define STBIR__ROUND_UINT(f) ((stbir_uint32) ((f)+0.5)) + + #ifdef STBIR__SATURATE_INT + #define STBIR__ENCODE_LINEAR8(f) stbir__saturate8 (STBIR__ROUND_INT((f) * 255 )) + #define STBIR__ENCODE_LINEAR16(f) stbir__saturate16(STBIR__ROUND_INT((f) * 65535)) + #else + #define STBIR__ENCODE_LINEAR8(f) (unsigned char ) STBIR__ROUND_INT(stbir__saturate(f) * 255 ) + #define STBIR__ENCODE_LINEAR16(f) (unsigned short) STBIR__ROUND_INT(stbir__saturate(f) * 65535) + #endif + + switch (decode) + { + case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_LINEAR): + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + for (n = 0; n < channels; n++) + { + int index = pixel_index + n; + ((unsigned char*)output_buffer)[index] = STBIR__ENCODE_LINEAR8(encode_buffer[index]); + } + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT8, STBIR_COLORSPACE_SRGB): + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + for (n = 0; n < num_nonalpha; n++) + { + int index = pixel_index + nonalpha[n]; + ((unsigned char*)output_buffer)[index] = stbir__linear_to_srgb_uchar(encode_buffer[index]); + } + + if (!(stbir_info->flags & STBIR_FLAG_ALPHA_USES_COLORSPACE)) + ((unsigned char *)output_buffer)[pixel_index + alpha_channel] = STBIR__ENCODE_LINEAR8(encode_buffer[pixel_index+alpha_channel]); + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_LINEAR): + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + for (n = 0; n < channels; n++) + { + int index = pixel_index + n; + ((unsigned short*)output_buffer)[index] = STBIR__ENCODE_LINEAR16(encode_buffer[index]); + } + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT16, STBIR_COLORSPACE_SRGB): + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + for (n = 0; n < num_nonalpha; n++) + { + int index = pixel_index + nonalpha[n]; + ((unsigned short*)output_buffer)[index] = (unsigned short)STBIR__ROUND_INT(stbir__linear_to_srgb(stbir__saturate(encode_buffer[index])) * 65535); + } + + if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE)) + ((unsigned short*)output_buffer)[pixel_index + alpha_channel] = STBIR__ENCODE_LINEAR16(encode_buffer[pixel_index + alpha_channel]); + } + + break; + + case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_LINEAR): + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + for (n = 0; n < channels; n++) + { + int index = pixel_index + n; + ((unsigned int*)output_buffer)[index] = (unsigned int)STBIR__ROUND_UINT(((double)stbir__saturate(encode_buffer[index])) * 4294967295); + } + } + break; + + case STBIR__DECODE(STBIR_TYPE_UINT32, STBIR_COLORSPACE_SRGB): + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + for (n = 0; n < num_nonalpha; n++) + { + int index = pixel_index + nonalpha[n]; + ((unsigned int*)output_buffer)[index] = (unsigned int)STBIR__ROUND_UINT(((double)stbir__linear_to_srgb(stbir__saturate(encode_buffer[index]))) * 4294967295); + } + + if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE)) + ((unsigned int*)output_buffer)[pixel_index + alpha_channel] = (unsigned int)STBIR__ROUND_INT(((double)stbir__saturate(encode_buffer[pixel_index + alpha_channel])) * 4294967295); + } + break; + + case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_LINEAR): + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + for (n = 0; n < channels; n++) + { + int index = pixel_index + n; + ((float*)output_buffer)[index] = encode_buffer[index]; + } + } + break; + + case STBIR__DECODE(STBIR_TYPE_FLOAT, STBIR_COLORSPACE_SRGB): + for (x=0; x < num_pixels; ++x) + { + int pixel_index = x*channels; + + for (n = 0; n < num_nonalpha; n++) + { + int index = pixel_index + nonalpha[n]; + ((float*)output_buffer)[index] = stbir__linear_to_srgb(encode_buffer[index]); + } + + if (!(stbir_info->flags&STBIR_FLAG_ALPHA_USES_COLORSPACE)) + ((float*)output_buffer)[pixel_index + alpha_channel] = encode_buffer[pixel_index + alpha_channel]; + } + break; + + default: + STBIR__UNIMPLEMENTED("Unknown type/colorspace/channels combination."); + break; + } +} + +static void stbir__resample_vertical_upsample(stbir__info* stbir_info, int n, int in_first_scanline, int in_last_scanline, float in_center_of_out) +{ + int x, k; + int output_w = stbir_info->output_w; + stbir__contributors* vertical_contributors = stbir_info->vertical_contributors; + float* vertical_coefficients = stbir_info->vertical_coefficients; + int channels = stbir_info->channels; + int alpha_channel = stbir_info->alpha_channel; + int type = stbir_info->type; + int colorspace = stbir_info->colorspace; + int kernel_pixel_width = stbir_info->vertical_filter_pixel_width; + void* output_data = stbir_info->output_data; + float* encode_buffer = stbir_info->encode_buffer; + int decode = STBIR__DECODE(type, colorspace); + int coefficient_width = stbir_info->vertical_coefficient_width; + int coefficient_counter; + int contributor = n; + + float* ring_buffer = stbir_info->ring_buffer; + int ring_buffer_begin_index = stbir_info->ring_buffer_begin_index; + int ring_buffer_first_scanline = stbir_info->ring_buffer_first_scanline; + int ring_buffer_last_scanline = stbir_info->ring_buffer_last_scanline; + int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float); + + int n0,n1, output_row_start; + int coefficient_group = coefficient_width * contributor; + + n0 = vertical_contributors[contributor].n0; + n1 = vertical_contributors[contributor].n1; + + output_row_start = n * stbir_info->output_stride_bytes; + + STBIR__DEBUG_ASSERT(stbir__use_height_upsampling(stbir_info)); + + memset(encode_buffer, 0, output_w * sizeof(float) * channels); + + // I tried reblocking this for better cache usage of encode_buffer + // (using x_outer, k, x_inner), but it lost speed. -- stb + + coefficient_counter = 0; + switch (channels) { + case 1: + for (k = n0; k <= n1; k++) + { + int coefficient_index = coefficient_counter++; + float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, kernel_pixel_width, ring_buffer_length); + float coefficient = vertical_coefficients[coefficient_group + coefficient_index]; + for (x = 0; x < output_w; ++x) + { + int in_pixel_index = x * 1; + encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient; + } + } + break; + case 2: + for (k = n0; k <= n1; k++) + { + int coefficient_index = coefficient_counter++; + float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, kernel_pixel_width, ring_buffer_length); + float coefficient = vertical_coefficients[coefficient_group + coefficient_index]; + for (x = 0; x < output_w; ++x) + { + int in_pixel_index = x * 2; + encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient; + encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient; + } + } + break; + case 3: + for (k = n0; k <= n1; k++) + { + int coefficient_index = coefficient_counter++; + float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, kernel_pixel_width, ring_buffer_length); + float coefficient = vertical_coefficients[coefficient_group + coefficient_index]; + for (x = 0; x < output_w; ++x) + { + int in_pixel_index = x * 3; + encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient; + encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient; + encode_buffer[in_pixel_index + 2] += ring_buffer_entry[in_pixel_index + 2] * coefficient; + } + } + break; + case 4: + for (k = n0; k <= n1; k++) + { + int coefficient_index = coefficient_counter++; + float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, kernel_pixel_width, ring_buffer_length); + float coefficient = vertical_coefficients[coefficient_group + coefficient_index]; + for (x = 0; x < output_w; ++x) + { + int in_pixel_index = x * 4; + encode_buffer[in_pixel_index + 0] += ring_buffer_entry[in_pixel_index + 0] * coefficient; + encode_buffer[in_pixel_index + 1] += ring_buffer_entry[in_pixel_index + 1] * coefficient; + encode_buffer[in_pixel_index + 2] += ring_buffer_entry[in_pixel_index + 2] * coefficient; + encode_buffer[in_pixel_index + 3] += ring_buffer_entry[in_pixel_index + 3] * coefficient; + } + } + break; + default: + for (k = n0; k <= n1; k++) + { + int coefficient_index = coefficient_counter++; + float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, kernel_pixel_width, ring_buffer_length); + float coefficient = vertical_coefficients[coefficient_group + coefficient_index]; + for (x = 0; x < output_w; ++x) + { + int in_pixel_index = x * channels; + int c; + for (c = 0; c < channels; c++) + encode_buffer[in_pixel_index + c] += ring_buffer_entry[in_pixel_index + c] * coefficient; + } + } + break; + } + stbir__encode_scanline(stbir_info, output_w, (char *) output_data + output_row_start, encode_buffer, channels, alpha_channel, decode); +} + +static void stbir__resample_vertical_downsample(stbir__info* stbir_info, int n, int in_first_scanline, int in_last_scanline, float in_center_of_out) +{ + int x, k; + int output_w = stbir_info->output_w; + int output_h = stbir_info->output_h; + stbir__contributors* vertical_contributors = stbir_info->vertical_contributors; + float* vertical_coefficients = stbir_info->vertical_coefficients; + int channels = stbir_info->channels; + int kernel_pixel_width = stbir_info->vertical_filter_pixel_width; + void* output_data = stbir_info->output_data; + float* horizontal_buffer = stbir_info->horizontal_buffer; + int coefficient_width = stbir_info->vertical_coefficient_width; + int contributor = n + stbir_info->vertical_filter_pixel_margin; + + float* ring_buffer = stbir_info->ring_buffer; + int ring_buffer_begin_index = stbir_info->ring_buffer_begin_index; + int ring_buffer_first_scanline = stbir_info->ring_buffer_first_scanline; + int ring_buffer_last_scanline = stbir_info->ring_buffer_last_scanline; + int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float); + int n0,n1; + + n0 = vertical_contributors[contributor].n0; + n1 = vertical_contributors[contributor].n1; + + STBIR__DEBUG_ASSERT(!stbir__use_height_upsampling(stbir_info)); + + for (k = n0; k <= n1; k++) + { + int coefficient_index = k - n0; + int coefficient_group = coefficient_width * contributor; + float coefficient = vertical_coefficients[coefficient_group + coefficient_index]; + + float* ring_buffer_entry = stbir__get_ring_buffer_scanline(k, ring_buffer, ring_buffer_begin_index, ring_buffer_first_scanline, kernel_pixel_width, ring_buffer_length); + + switch (channels) { + case 1: + for (x = 0; x < output_w; x++) + { + int in_pixel_index = x * 1; + ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient; + } + break; + case 2: + for (x = 0; x < output_w; x++) + { + int in_pixel_index = x * 2; + ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient; + ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient; + } + break; + case 3: + for (x = 0; x < output_w; x++) + { + int in_pixel_index = x * 3; + ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient; + ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient; + ring_buffer_entry[in_pixel_index + 2] += horizontal_buffer[in_pixel_index + 2] * coefficient; + } + break; + case 4: + for (x = 0; x < output_w; x++) + { + int in_pixel_index = x * 4; + ring_buffer_entry[in_pixel_index + 0] += horizontal_buffer[in_pixel_index + 0] * coefficient; + ring_buffer_entry[in_pixel_index + 1] += horizontal_buffer[in_pixel_index + 1] * coefficient; + ring_buffer_entry[in_pixel_index + 2] += horizontal_buffer[in_pixel_index + 2] * coefficient; + ring_buffer_entry[in_pixel_index + 3] += horizontal_buffer[in_pixel_index + 3] * coefficient; + } + break; + default: + for (x = 0; x < output_w; x++) + { + int in_pixel_index = x * channels; + + int c; + for (c = 0; c < channels; c++) + ring_buffer_entry[in_pixel_index + c] += horizontal_buffer[in_pixel_index + c] * coefficient; + } + break; + } + } +} + +static void stbir__buffer_loop_upsample(stbir__info* stbir_info) +{ + int y; + float scale_ratio = stbir_info->vertical_scale; + float out_scanlines_radius = stbir__filter_info_table[stbir_info->vertical_filter].support(1/scale_ratio) * scale_ratio; + + STBIR__DEBUG_ASSERT(stbir__use_height_upsampling(stbir_info)); + + for (y = 0; y < stbir_info->output_h; y++) + { + float in_center_of_out = 0; // Center of the current out scanline in the in scanline space + int in_first_scanline = 0, in_last_scanline = 0; + + stbir__calculate_sample_range_upsample(y, out_scanlines_radius, scale_ratio, stbir_info->vertical_shift, &in_first_scanline, &in_last_scanline, &in_center_of_out); + + STBIR__DEBUG_ASSERT(in_last_scanline - in_first_scanline <= stbir_info->vertical_filter_pixel_width); + + if (stbir_info->ring_buffer_begin_index >= 0) + { + // Get rid of whatever we don't need anymore. + while (in_first_scanline > stbir_info->ring_buffer_first_scanline) + { + if (stbir_info->ring_buffer_first_scanline == stbir_info->ring_buffer_last_scanline) + { + // We just popped the last scanline off the ring buffer. + // Reset it to the empty state. + stbir_info->ring_buffer_begin_index = -1; + stbir_info->ring_buffer_first_scanline = 0; + stbir_info->ring_buffer_last_scanline = 0; + break; + } + else + { + stbir_info->ring_buffer_first_scanline++; + stbir_info->ring_buffer_begin_index = (stbir_info->ring_buffer_begin_index + 1) % stbir_info->vertical_filter_pixel_width; + } + } + } + + // Load in new ones. + if (stbir_info->ring_buffer_begin_index < 0) + stbir__decode_and_resample_upsample(stbir_info, in_first_scanline); + + while (in_last_scanline > stbir_info->ring_buffer_last_scanline) + stbir__decode_and_resample_upsample(stbir_info, stbir_info->ring_buffer_last_scanline + 1); + + // Now all buffers should be ready to write a row of vertical sampling. + stbir__resample_vertical_upsample(stbir_info, y, in_first_scanline, in_last_scanline, in_center_of_out); + + STBIR_PROGRESS_REPORT((float)y / stbir_info->output_h); + } +} + +static void stbir__empty_ring_buffer(stbir__info* stbir_info, int first_necessary_scanline) +{ + int output_stride_bytes = stbir_info->output_stride_bytes; + int channels = stbir_info->channels; + int alpha_channel = stbir_info->alpha_channel; + int type = stbir_info->type; + int colorspace = stbir_info->colorspace; + int output_w = stbir_info->output_w; + void* output_data = stbir_info->output_data; + int decode = STBIR__DECODE(type, colorspace); + + float* ring_buffer = stbir_info->ring_buffer; + int ring_buffer_length = stbir_info->ring_buffer_length_bytes/sizeof(float); + + if (stbir_info->ring_buffer_begin_index >= 0) + { + // Get rid of whatever we don't need anymore. + while (first_necessary_scanline > stbir_info->ring_buffer_first_scanline) + { + if (stbir_info->ring_buffer_first_scanline >= 0 && stbir_info->ring_buffer_first_scanline < stbir_info->output_h) + { + int output_row_start = stbir_info->ring_buffer_first_scanline * output_stride_bytes; + float* ring_buffer_entry = stbir__get_ring_buffer_entry(ring_buffer, stbir_info->ring_buffer_begin_index, ring_buffer_length); + stbir__encode_scanline(stbir_info, output_w, (char *) output_data + output_row_start, ring_buffer_entry, channels, alpha_channel, decode); + STBIR_PROGRESS_REPORT((float)stbir_info->ring_buffer_first_scanline / stbir_info->output_h); + } + + if (stbir_info->ring_buffer_first_scanline == stbir_info->ring_buffer_last_scanline) + { + // We just popped the last scanline off the ring buffer. + // Reset it to the empty state. + stbir_info->ring_buffer_begin_index = -1; + stbir_info->ring_buffer_first_scanline = 0; + stbir_info->ring_buffer_last_scanline = 0; + break; + } + else + { + stbir_info->ring_buffer_first_scanline++; + stbir_info->ring_buffer_begin_index = (stbir_info->ring_buffer_begin_index + 1) % stbir_info->vertical_filter_pixel_width; + } + } + } +} + +static void stbir__buffer_loop_downsample(stbir__info* stbir_info) +{ + int y; + float scale_ratio = stbir_info->vertical_scale; + int output_h = stbir_info->output_h; + float in_pixels_radius = stbir__filter_info_table[stbir_info->vertical_filter].support(scale_ratio) / scale_ratio; + int pixel_margin = stbir_info->vertical_filter_pixel_margin; + int max_y = stbir_info->input_h + pixel_margin; + + STBIR__DEBUG_ASSERT(!stbir__use_height_upsampling(stbir_info)); + + for (y = -pixel_margin; y < max_y; y++) + { + float out_center_of_in; // Center of the current out scanline in the in scanline space + int out_first_scanline, out_last_scanline; + + stbir__calculate_sample_range_downsample(y, in_pixels_radius, scale_ratio, stbir_info->vertical_shift, &out_first_scanline, &out_last_scanline, &out_center_of_in); + + STBIR__DEBUG_ASSERT(out_last_scanline - out_first_scanline <= stbir_info->vertical_filter_pixel_width); + + if (out_last_scanline < 0 || out_first_scanline >= output_h) + continue; + + stbir__empty_ring_buffer(stbir_info, out_first_scanline); + + stbir__decode_and_resample_downsample(stbir_info, y); + + // Load in new ones. + if (stbir_info->ring_buffer_begin_index < 0) + stbir__add_empty_ring_buffer_entry(stbir_info, out_first_scanline); + + while (out_last_scanline > stbir_info->ring_buffer_last_scanline) + stbir__add_empty_ring_buffer_entry(stbir_info, stbir_info->ring_buffer_last_scanline + 1); + + // Now the horizontal buffer is ready to write to all ring buffer rows. + stbir__resample_vertical_downsample(stbir_info, y, out_first_scanline, out_last_scanline, out_center_of_in); + } + + stbir__empty_ring_buffer(stbir_info, stbir_info->output_h); +} + +static void stbir__setup(stbir__info *info, int input_w, int input_h, int output_w, int output_h, int channels) +{ + info->input_w = input_w; + info->input_h = input_h; + info->output_w = output_w; + info->output_h = output_h; + info->channels = channels; +} + +static void stbir__calculate_transform(stbir__info *info, float s0, float t0, float s1, float t1, float *transform) +{ + info->s0 = s0; + info->t0 = t0; + info->s1 = s1; + info->t1 = t1; + + if (transform) + { + info->horizontal_scale = transform[0]; + info->vertical_scale = transform[1]; + info->horizontal_shift = transform[2]; + info->vertical_shift = transform[3]; + } + else + { + info->horizontal_scale = ((float)info->output_w / info->input_w) / (s1 - s0); + info->vertical_scale = ((float)info->output_h / info->input_h) / (t1 - t0); + + info->horizontal_shift = s0 * info->input_w / (s1 - s0); + info->vertical_shift = t0 * info->input_h / (t1 - t0); + } +} + +static void stbir__choose_filter(stbir__info *info, stbir_filter h_filter, stbir_filter v_filter) +{ + if (h_filter == 0) + h_filter = stbir__use_upsampling(info->horizontal_scale) ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE; + if (v_filter == 0) + v_filter = stbir__use_upsampling(info->vertical_scale) ? STBIR_DEFAULT_FILTER_UPSAMPLE : STBIR_DEFAULT_FILTER_DOWNSAMPLE; + info->horizontal_filter = h_filter; + info->vertical_filter = v_filter; +} + +static stbir_uint32 stbir__calculate_memory(stbir__info *info) +{ + int pixel_margin = stbir__get_filter_pixel_margin(info->horizontal_filter, info->horizontal_scale); + int filter_height = stbir__get_filter_pixel_width(info->vertical_filter, info->vertical_scale); + + info->horizontal_num_contributors = stbir__get_contributors(info->horizontal_scale, info->horizontal_filter, info->input_w, info->output_w); + info->vertical_num_contributors = stbir__get_contributors(info->vertical_scale , info->vertical_filter , info->input_h, info->output_h); + + info->horizontal_contributors_size = info->horizontal_num_contributors * sizeof(stbir__contributors); + info->horizontal_coefficients_size = stbir__get_total_horizontal_coefficients(info) * sizeof(float); + info->vertical_contributors_size = info->vertical_num_contributors * sizeof(stbir__contributors); + info->vertical_coefficients_size = stbir__get_total_vertical_coefficients(info) * sizeof(float); + info->decode_buffer_size = (info->input_w + pixel_margin * 2) * info->channels * sizeof(float); + info->horizontal_buffer_size = info->output_w * info->channels * sizeof(float); + info->ring_buffer_size = info->output_w * info->channels * filter_height * sizeof(float); + info->encode_buffer_size = info->output_w * info->channels * sizeof(float); + + STBIR_ASSERT(info->horizontal_filter != 0); + STBIR_ASSERT(info->horizontal_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); // this now happens too late + STBIR_ASSERT(info->vertical_filter != 0); + STBIR_ASSERT(info->vertical_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); // this now happens too late + + if (stbir__use_height_upsampling(info)) + // The horizontal buffer is for when we're downsampling the height and we + // can't output the result of sampling the decode buffer directly into the + // ring buffers. + info->horizontal_buffer_size = 0; + else + // The encode buffer is to retain precision in the height upsampling method + // and isn't used when height downsampling. + info->encode_buffer_size = 0; + + return info->horizontal_contributors_size + info->horizontal_coefficients_size + + info->vertical_contributors_size + info->vertical_coefficients_size + + info->decode_buffer_size + info->horizontal_buffer_size + + info->ring_buffer_size + info->encode_buffer_size; +} + +static int stbir__resize_allocated(stbir__info *info, + const void* input_data, int input_stride_in_bytes, + void* output_data, int output_stride_in_bytes, + int alpha_channel, stbir_uint32 flags, stbir_datatype type, + stbir_edge edge_horizontal, stbir_edge edge_vertical, stbir_colorspace colorspace, + void* tempmem, size_t tempmem_size_in_bytes) +{ + size_t memory_required = stbir__calculate_memory(info); + + int width_stride_input = input_stride_in_bytes ? input_stride_in_bytes : info->channels * info->input_w * stbir__type_size[type]; + int width_stride_output = output_stride_in_bytes ? output_stride_in_bytes : info->channels * info->output_w * stbir__type_size[type]; + +#ifdef STBIR_DEBUG_OVERWRITE_TEST +#define OVERWRITE_ARRAY_SIZE 8 + unsigned char overwrite_output_before_pre[OVERWRITE_ARRAY_SIZE]; + unsigned char overwrite_tempmem_before_pre[OVERWRITE_ARRAY_SIZE]; + unsigned char overwrite_output_after_pre[OVERWRITE_ARRAY_SIZE]; + unsigned char overwrite_tempmem_after_pre[OVERWRITE_ARRAY_SIZE]; + + size_t begin_forbidden = width_stride_output * (info->output_h - 1) + info->output_w * info->channels * stbir__type_size[type]; + memcpy(overwrite_output_before_pre, &((unsigned char*)output_data)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE); + memcpy(overwrite_output_after_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE); + memcpy(overwrite_tempmem_before_pre, &((unsigned char*)tempmem)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE); + memcpy(overwrite_tempmem_after_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE); +#endif + + STBIR_ASSERT(info->channels >= 0); + STBIR_ASSERT(info->channels <= STBIR_MAX_CHANNELS); + + if (info->channels < 0 || info->channels > STBIR_MAX_CHANNELS) + return 0; + + STBIR_ASSERT(info->horizontal_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); + STBIR_ASSERT(info->vertical_filter < STBIR__ARRAY_SIZE(stbir__filter_info_table)); + + if (info->horizontal_filter >= STBIR__ARRAY_SIZE(stbir__filter_info_table)) + return 0; + if (info->vertical_filter >= STBIR__ARRAY_SIZE(stbir__filter_info_table)) + return 0; + + if (alpha_channel < 0) + flags |= STBIR_FLAG_ALPHA_USES_COLORSPACE | STBIR_FLAG_ALPHA_PREMULTIPLIED; + + if (!(flags&STBIR_FLAG_ALPHA_USES_COLORSPACE) || !(flags&STBIR_FLAG_ALPHA_PREMULTIPLIED)) + STBIR_ASSERT(alpha_channel >= 0 && alpha_channel < info->channels); + + if (alpha_channel >= info->channels) + return 0; + + STBIR_ASSERT(tempmem); + + if (!tempmem) + return 0; + + STBIR_ASSERT(tempmem_size_in_bytes >= memory_required); + + if (tempmem_size_in_bytes < memory_required) + return 0; + + memset(tempmem, 0, tempmem_size_in_bytes); + + info->input_data = input_data; + info->input_stride_bytes = width_stride_input; + + info->output_data = output_data; + info->output_stride_bytes = width_stride_output; + + info->alpha_channel = alpha_channel; + info->flags = flags; + info->type = type; + info->edge_horizontal = edge_horizontal; + info->edge_vertical = edge_vertical; + info->colorspace = colorspace; + + info->horizontal_coefficient_width = stbir__get_coefficient_width (info->horizontal_filter, info->horizontal_scale); + info->vertical_coefficient_width = stbir__get_coefficient_width (info->vertical_filter , info->vertical_scale ); + info->horizontal_filter_pixel_width = stbir__get_filter_pixel_width (info->horizontal_filter, info->horizontal_scale); + info->vertical_filter_pixel_width = stbir__get_filter_pixel_width (info->vertical_filter , info->vertical_scale ); + info->horizontal_filter_pixel_margin = stbir__get_filter_pixel_margin(info->horizontal_filter, info->horizontal_scale); + info->vertical_filter_pixel_margin = stbir__get_filter_pixel_margin(info->vertical_filter , info->vertical_scale ); + + info->ring_buffer_length_bytes = info->output_w * info->channels * sizeof(float); + info->decode_buffer_pixels = info->input_w + info->horizontal_filter_pixel_margin * 2; + +#define STBIR__NEXT_MEMPTR(current, newtype) (newtype*)(((unsigned char*)current) + current##_size) + + info->horizontal_contributors = (stbir__contributors *) tempmem; + info->horizontal_coefficients = STBIR__NEXT_MEMPTR(info->horizontal_contributors, float); + info->vertical_contributors = STBIR__NEXT_MEMPTR(info->horizontal_coefficients, stbir__contributors); + info->vertical_coefficients = STBIR__NEXT_MEMPTR(info->vertical_contributors, float); + info->decode_buffer = STBIR__NEXT_MEMPTR(info->vertical_coefficients, float); + + if (stbir__use_height_upsampling(info)) + { + info->horizontal_buffer = NULL; + info->ring_buffer = STBIR__NEXT_MEMPTR(info->decode_buffer, float); + info->encode_buffer = STBIR__NEXT_MEMPTR(info->ring_buffer, float); + + STBIR__DEBUG_ASSERT((size_t)STBIR__NEXT_MEMPTR(info->encode_buffer, unsigned char) == (size_t)tempmem + tempmem_size_in_bytes); + } + else + { + info->horizontal_buffer = STBIR__NEXT_MEMPTR(info->decode_buffer, float); + info->ring_buffer = STBIR__NEXT_MEMPTR(info->horizontal_buffer, float); + info->encode_buffer = NULL; + + STBIR__DEBUG_ASSERT((size_t)STBIR__NEXT_MEMPTR(info->ring_buffer, unsigned char) == (size_t)tempmem + tempmem_size_in_bytes); + } + +#undef STBIR__NEXT_MEMPTR + + // This signals that the ring buffer is empty + info->ring_buffer_begin_index = -1; + + stbir__calculate_filters(info, info->horizontal_contributors, info->horizontal_coefficients, info->horizontal_filter, info->horizontal_scale, info->horizontal_shift, info->input_w, info->output_w); + stbir__calculate_filters(info, info->vertical_contributors, info->vertical_coefficients, info->vertical_filter, info->vertical_scale, info->vertical_shift, info->input_h, info->output_h); + + STBIR_PROGRESS_REPORT(0); + + if (stbir__use_height_upsampling(info)) + stbir__buffer_loop_upsample(info); + else + stbir__buffer_loop_downsample(info); + + STBIR_PROGRESS_REPORT(1); + +#ifdef STBIR_DEBUG_OVERWRITE_TEST + STBIR__DEBUG_ASSERT(memcmp(overwrite_output_before_pre, &((unsigned char*)output_data)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE) == 0); + STBIR__DEBUG_ASSERT(memcmp(overwrite_output_after_pre, &((unsigned char*)output_data)[begin_forbidden], OVERWRITE_ARRAY_SIZE) == 0); + STBIR__DEBUG_ASSERT(memcmp(overwrite_tempmem_before_pre, &((unsigned char*)tempmem)[-OVERWRITE_ARRAY_SIZE], OVERWRITE_ARRAY_SIZE) == 0); + STBIR__DEBUG_ASSERT(memcmp(overwrite_tempmem_after_pre, &((unsigned char*)tempmem)[tempmem_size_in_bytes], OVERWRITE_ARRAY_SIZE) == 0); +#endif + + return 1; +} + + +static int stbir__resize_arbitrary( + void *alloc_context, + const void* input_data, int input_w, int input_h, int input_stride_in_bytes, + void* output_data, int output_w, int output_h, int output_stride_in_bytes, + float s0, float t0, float s1, float t1, float *transform, + int channels, int alpha_channel, stbir_uint32 flags, stbir_datatype type, + stbir_filter h_filter, stbir_filter v_filter, + stbir_edge edge_horizontal, stbir_edge edge_vertical, stbir_colorspace colorspace) +{ + stbir__info info; + int result; + size_t memory_required; + void* extra_memory; + + stbir__setup(&info, input_w, input_h, output_w, output_h, channels); + stbir__calculate_transform(&info, s0,t0,s1,t1,transform); + stbir__choose_filter(&info, h_filter, v_filter); + memory_required = stbir__calculate_memory(&info); + extra_memory = STBIR_MALLOC(memory_required, alloc_context); + + if (!extra_memory) + return 0; + + result = stbir__resize_allocated(&info, input_data, input_stride_in_bytes, + output_data, output_stride_in_bytes, + alpha_channel, flags, type, + edge_horizontal, edge_vertical, + colorspace, extra_memory, memory_required); + + STBIR_FREE(extra_memory, alloc_context); + + return result; +} + +STBIRDEF int stbir_resize_uint8( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels) +{ + return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,NULL,num_channels,-1,0, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT, + STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_LINEAR); +} + +STBIRDEF int stbir_resize_float( const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + float *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels) +{ + return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,NULL,num_channels,-1,0, STBIR_TYPE_FLOAT, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT, + STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_LINEAR); +} + +STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags) +{ + return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT, + STBIR_EDGE_CLAMP, STBIR_EDGE_CLAMP, STBIR_COLORSPACE_SRGB); +} + +STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_wrap_mode) +{ + return stbir__resize_arbitrary(NULL, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, STBIR_FILTER_DEFAULT, STBIR_FILTER_DEFAULT, + edge_wrap_mode, edge_wrap_mode, STBIR_COLORSPACE_SRGB); +} + +STBIRDEF int stbir_resize_uint8_generic( const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, + void *alloc_context) +{ + return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT8, filter, filter, + edge_wrap_mode, edge_wrap_mode, space); +} + +STBIRDEF int stbir_resize_uint16_generic(const stbir_uint16 *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + stbir_uint16 *output_pixels , int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, + void *alloc_context) +{ + return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_UINT16, filter, filter, + edge_wrap_mode, edge_wrap_mode, space); +} + + +STBIRDEF int stbir_resize_float_generic( const float *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + float *output_pixels , int output_w, int output_h, int output_stride_in_bytes, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_wrap_mode, stbir_filter filter, stbir_colorspace space, + void *alloc_context) +{ + return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,NULL,num_channels,alpha_channel,flags, STBIR_TYPE_FLOAT, filter, filter, + edge_wrap_mode, edge_wrap_mode, space); +} + + +STBIRDEF int stbir_resize( const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_datatype datatype, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, + stbir_filter filter_horizontal, stbir_filter filter_vertical, + stbir_colorspace space, void *alloc_context) +{ + return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical, + edge_mode_horizontal, edge_mode_vertical, space); +} + + +STBIRDEF int stbir_resize_subpixel(const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_datatype datatype, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, + stbir_filter filter_horizontal, stbir_filter filter_vertical, + stbir_colorspace space, void *alloc_context, + float x_scale, float y_scale, + float x_offset, float y_offset) +{ + float transform[4]; + transform[0] = x_scale; + transform[1] = y_scale; + transform[2] = x_offset; + transform[3] = y_offset; + return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + 0,0,1,1,transform,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical, + edge_mode_horizontal, edge_mode_vertical, space); +} + +STBIRDEF int stbir_resize_region( const void *input_pixels , int input_w , int input_h , int input_stride_in_bytes, + void *output_pixels, int output_w, int output_h, int output_stride_in_bytes, + stbir_datatype datatype, + int num_channels, int alpha_channel, int flags, + stbir_edge edge_mode_horizontal, stbir_edge edge_mode_vertical, + stbir_filter filter_horizontal, stbir_filter filter_vertical, + stbir_colorspace space, void *alloc_context, + float s0, float t0, float s1, float t1) +{ + return stbir__resize_arbitrary(alloc_context, input_pixels, input_w, input_h, input_stride_in_bytes, + output_pixels, output_w, output_h, output_stride_in_bytes, + s0,t0,s1,t1,NULL,num_channels,alpha_channel,flags, datatype, filter_horizontal, filter_vertical, + edge_mode_horizontal, edge_mode_vertical, space); +} + +#endif // STB_IMAGE_RESIZE_IMPLEMENTATION diff --git a/src/platform/gba/packer/tracks/cygwin1.dll b/src/platform/gba/packer/tracks/cygwin1.dll new file mode 100644 index 0000000000000000000000000000000000000000..fc4d32210ab3a6128cc5c1f2382c69fbd463819a GIT binary patch literal 2992181 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

@XBIz^;wArV8EUW* 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∾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

n($~_?=7< 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

SF@hHT!1dxy#%AI%9Sx?qgi@vus@c( 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

_pE}H01WsL1NlNq4|$LWSI89{+!3O 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 z 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 z

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

v!S^wr|s*HFeTaa`8 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 z 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

  • 3do`%@aI=bFGY*oC& z+^>5I{PoihxSBS`NyqZoKu!x&g!kG8m?*G8*gA&odS zjAfPepHOUTOKPu-+8bk)>$W$aC0>lAFga1m+#^1fA5E?9%P>}w-9q+Y@A*{Zo4YRx z(Uq37k^GJnRuYIG)q!VI*t12v2$Da@xfS{qIr>FcPMN@$xqPtqFx3&$4$OIh;@S|$ z)9YU306fQDk>6OLL^i|<6w$6te!pd}D$%XZEPH(b%y^Hokq4Kxeh6;$Gz+tt({9eM{+ zZr@uXstgfAetz2j>+%%{71K>HL!@$sLy$e%)Uuos!O~%VU;G%M(;C+Yb!tAJgyOkR z@D;Z`ZJzz9ZFRkG?%n2X+GuCC)fkItDU7{hZp8iChy6`I=O*5|j%>p;ove+{g0E#z z30hTtC&mD=)Z}Oc_Olq9pdDkS|iSPPkSzkG}At@JEQ0!DUO0cO|ZVV~!s!;Mu@eCt|MJ{G2 z9=KG!9}Fa6h5{!7@H4WH^IMAG8F8ce+Jmp5(xKg>;|%fdRr94weer|HqW58Q!SYsbxb!g@Sw zbqATBV{yfOBAsFdPm|39efr}6Rs+d%cLWpH;Z6QUOCYutU+9wzsK8vM&sG(3*C<76 z^F)s853#M#hDb__i^C;r!WdJ-p4C9<2`0zkaWMW($*0jzgRwQpJ2Uf}*gO4X%&q$! z*$T$C`xTMkXmvd~&Tp!SE$tVyCQ=0qy>vxnF&C&2vvBXBv(PXt0S{Yt1WVp?mB7@C z9oMsdzozS>0F!EZK`8bn^%|`CY9E6JoO=FL$qnLBn$2KdcF6g2c@tRV*I$i|iBT6$ z_^_!Rdi|up%lc4deP88!+M!3ztyE+m+DMf>L|d|Wa%wP)Q%ADAg^&b;&-fbSt9e^5 z0;v5r*+wL%9bXtO*)9l?PL5|?*zWwE520B7VR$6$XnHuD43OHi!?~UX0LtF)q?_|J z8Y^6^{z0LX`;KdmEZrFN4dcGoVXV0uBDWw$`hD{zFo32<#>Ha8j23Jr)ske(@+hoYvYD8e z4qs@O8*^Q9ILYL;vO%`9hwTr3C96W_YjOr7`304S2XwbT-Rw5{X;yoYg+crWaXc}> z1%k0}psPJ$Sw!~qoOK2^QV1M(2I<>51Tv`*yAa2w4 zHeh4pc-M45(DSKVY17k$6aMaxht9|85OK zUZ`qo_D^v+As$eWhV=DUK_$sC2WmW;lr>ngF;h($`NA>Gj24mr7o_w z%c&Np$9$)f+A;?@G)LtZg0*NzI9W7*GLlB3#{+uEATazISYRRqHdeA=G%HH!{DOI6DkyeOFrx&n{CzM>4Yy8BK*Ldn>Va&4G^~2R`;mpzzJVMVL!q!NZ)pHSE>wK|4=@TYJ;}LW> zKg^MfGsRsJ1J_MbZ@lYyFy{a+EG6uTRBJTr@
    xe!b#zZ{)FaF1Nnr*sGDBNqeI zxKWmukg75O_0+qRJwVFxYcl@OrSVm+#{7BHFcyw)r>VR&=21WhTU8vppm!hfI%Hk3 z-?5A3=55GN<@%D=n3Ml0_Y2E<2#(gyG2AGbuh%HF+s9o$Ep9quUY3ia46g8 zs|_<{%Q5_QcM^<-*yZAHhCa_6JpwCI|{jO+U4G$4DCdk!l#18$}oA+MNL(@H%AOkS*Lo=gZ7ncLo@VQY=eH4h%GpyI;*LaCRb}XWOG+J6~H*cLG*< zP)U?CQ__cf`mWGz7K>n};`S9&Pirba|whuoPvy_Qe#y#4O1ihMshR^V)wHJoewy zRZ)Z2OCJ3rx#c`J*|aRh6@2l#p{#aiI96s<9HHd7NZKK78B%9BuE8LZeTHK(sLSxI z!6}|qt2@@Ktndf<&biw9$HjSVd>>$yupNjfyLM^5j^( z9;Mfr?PsrogY|MCyNb;48js5CLn8mRE9h4La=E&aIV2KqLPeOSy)^f&je|kACwGy8 z>H3{{W*>t$^c=m>!H;vP34xy-+#umni%*#*AJNz2PckyjJ^WG5o)s)xbB|NQCcB@M z$=;jnxU~4<7XpNH27eeHvr}`=icA(2>CDUs8m~-iEY2MfKpsIwx9{b?p#Gs?}32ISlkBh&S{=S8Zi&zu)IJMFXYyeVyHL&XQKGQbRy zdpKyp1V-aYL7w@VHC9*Zt3}z&VUcRGrcVGk*Yd?VnAY5ISMu>)i%fvG6SCXx&Ax?8 zd@rsGc3!Qso~-?|`l6ssdtmu0Hn1PH`)!~;Y`Tbv9h=Kra--(5AIW`75e=I@3Yl1) zza4DiaYFxuRX{4JeN{Gsh_I>XQG!wRU0uJ>p66=ur@K9zq>Ccmd*$X`JxI{*v1_Fg%W6r>wh?HZ)2Q0+R)`ea>`Vvbbd-hF+U1{|>c{oRm_D4C z>ch+(s{8M(DlGU>L{f>zilShz#-q-N!}^up*EGG2bX#~m`rWn8>h~C@BhmO}k5g=K zVdOko=rk*Y0VOvmAG2PKh>x)?or0YkqXRNhH>cm~W(;xV{?d9*@2rsEy5?IKp+^U; z+>|iBbP-NgU|ypqA#@z=g7fIdi?Cy--e*9Fl{K6TSCfBO!E#at+yW49$~%XtEF!xq zb1tSWd(RT&>~&e?=bQ3_C_m4X|DpQ&GES!-PPrAv^o+O-3aHaXytCA3%2eS&s_+Ra zq;M!zc-B(829L3HUpR4%h86#5sw~F)w%&D?v&T!xz%FVjuh@4x75q+(U-D#Pn4Qa> zdS@ge*b~EAL~@hR-m)bg0|nu2#Ll5%m=5|fM+Mz zGp}qJ!kx7bVM{Wm1tXtFdxqSmf2j5@1|!}%ZY2-!nE47;>tZ$&nYs*KVr5-m4LR5= zz=V^h&4#oG_F45pDJk=Q+uQo(oqf))a|pTE?kT(whtUmD0nzShjrdxWRimPyOp(x3t}{f|s#xYRs%piBpN5WQOwj;_vYmm(;h%$$J5-&@=oF zCi*_c?{M;hF&s5W-5OH1_iSx~d?5~2;FXB;z&*<9o~-b!m~nbIae01~=dGsxA-thE z*DHhK-UA?8QPt*_kWdOo;7D4hkQ5hO3&P3b(iJnjSny|{|C)m?ur>OS35dzT4&u7d zB6gf`30`jKDH27K%nNjXCGf;ygTmJN<%A{)w(Wp*fI$XZ@d|tA8?uM>B$;M|v9g<~ zfnGP8UiWzaO!Zp&NAug;3YD=l+M!4C!e@w!@h~~?rQOGyc76Y6yS@+N=p21t)pT5_ zbg4o*r26hp^*!D3+#ssiOs5-XtW9_NFDBZI7M);XL3dF}vgpr$Bo@MPYrO8YB3a)Q zKtEaZus$E~i=Q{}`2jvdTRN%ZeEv4!V8F`R!peuQvlb_Md^FbWdaak2gdb|w6rDxd zoubwn){9tK75&bMlmstXAKSMta$;;>YosE!@25!THYz8cF`10~-qd8@LhWwu=sNVJ zhw^F0dc!hn8>8$fi@NfrX)TFElvp7?eoQbCXknaFSRzKC=01cHJbYbj3si(2sibi! z1WgqjNG!LrlMD+@(GNgHH{{eQy04&tk_8$_}6U=H_A)e(OB&<`qUy$e&gD$Hn zZS5WHAG{>cfy+`n9VywZx9r@Qv1!Zbm2NW)5-x^-(Y&yKyyfftTWD+AU@ExOB|*q_ zO?BDs=kTS8PHZhY=>gs0LfGub7AkVg>AId}0)zM5?+Hy?+89AkWZ;?zps6chK6=PR zkJ-)xaAAJ@&3Dq#Rbn?e7Rnti5~e_k#*o)6X=z zs>#|PJB3@wnJ8~*sy4&`cjp9QK?kxodw;l7kPdJ!l1Ucjry!kd;(MS%G~u8wb%DGt z4WwOt;`go9Wv$Pu--Yhdg~xxewfDf^sS5+oFtF~l&oHoVv}bM?tUJXViHP0@aQ`ce z^U|R-rLM5vtuA}ev~qE4(dPS8*d1Mno!KeT%5{S z{Re~M%{WD^U6DfvE@zG z|E&uq&{cZ5w)-*%#q>Lx*}GI?B8%8Y`#NM=LrcgE`*->AXM|X~d`h~@<4vQPE?@M( z|L*d^ZkJ24x_k&V*eg!>S(pECzuVq@eG&jBA`RTM4{cvBG9H=+p{Z(<-9BYt0jGWe>jPBDMU2~PN z(JD?XeRrQ5BksEq0@DOy@8*t-BFDW~$y+d68MH27W_y<(ZR-5yIMvzz!*;d4Vq~?1 z_s?#g)h18-9Fp3aKFUmS#QXQE%MMZ(BK??&Q-MXKF|`dA!kVWi;|RfG>N7L9+55ol zU@zJmuuh`MhMWo1ZjYx~H`zZG7vAK?O4v`|ajB$t$%AlyaYINsN}989^LZ>T zH=hdzQ@g$6I0f@Ivzyg(b#>X4e+k$VAn8}`b;tLWkign#6GbUKxQ|q%A!P! zv^|ElyR@}^(l546r@pwy?bH`=5_PIpyEE~^o%ZTs*`3OUv(bg~9{`ocXKxqIQ?uY~ zx(zrVDIwNWW`p9Q^dJN33C-RWHa5!g+KSoVWbW;PXx%X?zY7oGpETb0!=nMXT0o>;3Ao%b!Xi^+*G$kop3* znWiZ3gJbuDG_}ACyz6cksdvHVti52h9)q3>>#U(ESbs*OlDruFJAf>W)W-V_uv>Vf zfxX`X*pUKONEL4^uP&>5QeYn2?7g0^o+zuO_rNwV2V}s6ah9_yPWISwmjK*o?|>=U zEryP@X(~V8c`wjeQzkQYI-%GAsspp2I?aVDoCQ^mpnBn0NHX3w*Q?9=7`RH?3E0iv zbqms?enrm=F7G%djmxYV�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�!}xlE8mYY5zmVSv& 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%0A!NXcSSf0r_x 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
    djg%Ks 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 literal 0 HcmV?d00001